diff --git a/packages/server/.babelrc b/packages/server/.babelrc
new file mode 100644
index 000000000..662559d1b
--- /dev/null
+++ b/packages/server/.babelrc
@@ -0,0 +1,8 @@
+{
+  "presets": ["@babel/preset-env"],
+  "retainLines": true,
+  "plugins": [
+    "@babel/plugin-transform-runtime",
+    "@babel/plugin-syntax-dynamic-import"
+  ]
+}
\ No newline at end of file
diff --git a/packages/server/.env.example b/packages/server/.env.example
new file mode 100644
index 000000000..482b7d991
--- /dev/null
+++ b/packages/server/.env.example
@@ -0,0 +1,41 @@
+MAIL_HOST=smtp.mailtrap.io
+MAIL_USERNAME=842f331d3dc005
+MAIL_PASSWORD=172f97b34f1a17
+MAIL_PORT=587
+MAIL_SECURE=false
+MAIL_FROM_NAME=Bigcapital
+MAIL_FROM_ADDRESS=noreply@sender.bigcapital.ly
+
+SYSTEM_DB_CLIENT=mysql
+SYSTEM_DB_HOST=127.0.0.1
+SYSTEM_DB_USER=root
+SYSTEM_DB_PASSWORD=root
+SYSTEM_DB_NAME=bigcapital_system
+SYSTEM_MIGRATIONS_DIR=./src/system/migrations
+SYSTEM_SEEDS_DIR=./src/system/seeds
+
+TENANT_DB_CLIENT=mysql
+TENANT_DB_NAME_PERFIX=bigcapital_tenant_
+TENANT_DB_HOST=127.0.0.1
+TENANT_DB_PASSWORD=root
+TENANT_DB_USER=root
+TENANT_DB_CHARSET=utf8
+TENANT_MIGRATIONS_DIR=src/database/migrations
+TENANT_SEEDS_DIR=src/database/seeds/core
+
+DB_MANAGER_SUPER_USER=root
+DB_MANAGER_SUPER_PASSWORD=root
+
+MONGODB_DATABASE_URL=mongodb://localhost/bigcapital
+
+JWT_SECRET=b0JDZW56RnV6aEthb0RGPXVEcUI
+
+CONTACT_US_MAIL=support@bigcapital.ly
+BASE_URL=https://bigcapital.ly
+
+LICENSES_AUTH_USER=root
+LICENSES_AUTH_PASSWORD=root
+
+AGENDASH_AUTH_USER=agendash
+AGENDASH_AUTH_PASSWORD=123123
+BROWSER_WS_ENDPOINT=ws://localhost:4080/
\ No newline at end of file
diff --git a/packages/server/.eslintrc.js b/packages/server/.eslintrc.js
new file mode 100644
index 000000000..1ad00ade5
--- /dev/null
+++ b/packages/server/.eslintrc.js
@@ -0,0 +1,34 @@
+module.exports = {
+  env: {
+    browser: true,
+    es6: true,
+  },
+  extends: ['airbnb-base', 'airbnb-typescript'],
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    ecmaVersion: 2018,
+    sourceType: 'module',
+    project: 'tsconfig.json',
+    tsconfigRootDir: './',
+  },
+  globals: {
+    Atomics: 'readonly',
+    SharedArrayBuffer: 'readonly',
+  },
+  plugins: ['import'],
+  rules: {
+    'import/no-unresolved': 'error',
+    'import/prefer-default-export': 'off',
+  },
+  settings: {
+    'import/parsers': {
+      '@typescript-eslint/parser': ['.ts', '.tsx'],
+    },
+    'import/resolver': {
+      typescript: {
+        alwaysTryTypes: true,
+        project: 'tsconfig.json',
+      },
+    },
+  },
+};
diff --git a/packages/server/.gitignore b/packages/server/.gitignore
new file mode 100644
index 000000000..5207e9543
--- /dev/null
+++ b/packages/server/.gitignore
@@ -0,0 +1,7 @@
+/node_modules/
+/.env
+/storage
+package-lock.json
+stdout.log
+/dist
+/build
\ No newline at end of file
diff --git a/packages/server/CHANGELOG.md b/packages/server/CHANGELOG.md
new file mode 100644
index 000000000..391f903a7
--- /dev/null
+++ b/packages/server/CHANGELOG.md
@@ -0,0 +1,76 @@
+
+# Change Log
+All notable changes to this project will be documented in this file.
+ 
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).
+
+## [1.7.1-rc.2] - 30-03-2022
+
+### Fixed
+  - `BIG-354` Validate the warehouse transfer quantity should be above zero.
+  - `BIG-358` Refactoring customers/vendors services for smaller classes.
+  - `BIG-341` Refactoring expenses services for smaller classes.
+  - `BIG-342` Assign default currency as base currency when create customer, vendor or expense transaction.
+## [1.7.0-rc.1] - 24-03-2022
+
+## Added
+ - Multiply currencies with foreign currencies.
+ - Multiply warehouses to track inventory items.
+ - Multiply branches to track organization transactions.
+ - Transfer orders between warehouses.
+ - Integrate financial reports with multiply branches.
+ - Integrate inventory reports with multiply warehouses.
+
+## [1.6.1] - 19-02-2022
+### Fixed
+ - fix: `BIG-329` Total of aggregate/accounts nodes of Balance sheet.
+ - fix: `BIG-329` Total of aggregate/accounts nodes of Profit & Loss sheet.
+ - fix: `BIG-328` Localization of total column label of P&L sheet date periods mode.
+
+## [1.6.0] - 18-02-2022
+
+### Added
+ - Balance sheet comparison of previous period (PP).
+ - Balance sheet comparison of previous year (PY).
+ - Balance sheet percentage analysis columns and rows basis.
+ - Profit & loss sheet comparison of preivous period (PP).
+ - Profit & loss sheet comparison of previous year (PY).
+ - Profit & loss sheet percentage analysis columns, rows, income and expenses basis.
+
+
+## [1.5.3] - 13-01-2022
+
+### Changed
+
+ - Optimize style of sale invoice PDF template.
+ - Optimize style of sale estimate PDF template.
+ - Optimize style of credit note PDF template.
+ - Optimize style of payment receive PDF template.
+ - Optimize style of sale receipt PDF template.
+
+### Fixed
+ - fix: Customer and vendor balance summary percentage of column.
+ - fix: Filtering none transactions and zero accounts of cashflow sheet.
+ 
+## [Unreleased] - yyyy-mm-dd
+ 
+Here we write upgrading notes for brands. It's a team effort to make them as
+straightforward as possible.
+ 
+### Added
+- Dynamic filter for resources list.
+- Dynamic search for resources list.
+- Dynamic resources to switch between active and inactive items.
+- Add virtual computed attributes to sale invoice list and individual.
+- This CHANGELOG file to hopefully serve as an evolving example of a
+  standardized open source project CHANGELOG.
+- Remove subscription free trial.
+
+### Changed
+ - Redesigne organization tenant metadata table to depend on table on system
+   database instead of tenant database.
+ - 
+ 
+### Fixed
+ 
diff --git a/packages/server/README.md b/packages/server/README.md
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/server/bin/bigcapital.js b/packages/server/bin/bigcapital.js
new file mode 100644
index 000000000..54a7c6014
--- /dev/null
+++ b/packages/server/bin/bigcapital.js
@@ -0,0 +1,203 @@
+import commander from 'commander';
+import color from 'colorette';
+import argv from 'getopts'
+import config from '../src/config';
+import { 
+  initSystemKnex,
+  getAllSystemTenants,
+  initTenantKnex,
+  exit,
+  success,
+  log,
+} from './utils';
+
+// - bigcapital system:migrate:latest
+// - bigcapital system:migrate:rollback
+// - bigcapital tenants:migrate:latest
+// - bigcapital tenants:migrate:latest --tenant_id=XXX
+// - bigcapital tenants:migrate:rollback
+// - bigcapital tenants:migrate:rollback --tenant_id=XXX
+// - bigcapital tenants:migrate:make 
+// - bigcapital system:migrate:make 
+// - bigcapital tenants:list
+
+commander
+  .command('system:migrate:rollback') 
+  .description('Migrate the system database of the application.')
+  .action(async () => {
+    try {
+      const sysKnex = await initSystemKnex();
+      const [batchNo, _log] = await sysKnex.migrate.rollback();
+
+      if (_log.length === 0) {
+        success(color.cyan('Already at the base migration'));
+      }
+      success(
+        color.green(
+          `Batch ${batchNo} rolled back: ${_log.length} migrations`
+        ) + (argv.verbose ? `\n${color.cyan(_log.join('\n'))}` : '')
+      );
+    } catch(error) {
+      exit(error);
+    }
+  });
+
+commander
+  .command('system:migrate:latest')
+  .description('Rollback latest mgiration of the system database.')
+  .action(async () => {
+    try {
+      const sysKnex = await initSystemKnex();
+      const [batchNo, log] = await sysKnex.migrate.latest();
+
+      if (log.length === 0) {
+        success(color.cyan('Already up to date'));
+      }
+      success(
+        color.green(`Batch ${batchNo} run: ${log.length} migrations`) +
+          (argv.verbose ? `\n${color.cyan(log.join('\n'))}` : '')
+      );
+    } catch(error) {
+      exit(error);
+    }
+  });
+
+commander
+  .command('system:migrate:make <name>')
+  .description('Created a named migration file to the system database.')
+  .action(async (name) => {
+    const sysKnex = await initSystemKnex();
+    
+    sysKnex.migrate.make(name).then((name) => {
+      success(color.green(`Created Migration: ${name}`));
+    }).catch(exit)
+  });
+
+commander
+  .command('tenants:migrate:make <name>')
+  .description('Created a name migration file to the tenants databases.')
+  .action(async (name) => {
+    const sysKnex = await initTenantKnex();
+    
+    sysKnex.migrate.make(name).then((name) => {
+      success(color.green(`Created Migration: ${name}`));
+    }).catch(exit)
+  });
+
+commander
+  .command('tenants:list')
+  .description('Retrieve a list of all system tenants databases.')
+  .action(async (cmd) => {
+    try{
+      const sysKnex = await initSystemKnex();
+      const tenants = await getAllSystemTenants(sysKnex);
+
+      tenants.forEach((tenant) => {
+        const dbName = `${config.tenant.db_name_prefix}${tenant.organizationId}`;
+        console.log(`ID: ${tenant.id} | Organization ID: ${tenant.organizationId} | DB Name: ${dbName}`);
+      });
+    } catch(error) { exit(error); };
+    success('---');
+  });
+
+commander
+  .command('tenants:migrate:rollback')
+  .description('Rollback the last batch of tenants migrations.')
+  .option('-t, --tenant_id [tenant_id]', 'Which tenant id do you migrate.')
+  .action(async (cmd) => {
+    try {
+      const sysKnex = await initSystemKnex();
+      const tenants = await getAllSystemTenants(sysKnex);
+      const tenantsOrgsIds = tenants.map((tenant) => tenant.organizationId);
+
+      if (cmd.tenant_id && tenantsOrgsIds.indexOf(cmd.tenant_id) === -1) {
+        exit(`The given tenant id ${cmd.tenant_id} is not exists.`);
+      } 
+
+      const migrateOpers = [];
+      const migrateTenant = async (organizationId) => {
+        try {
+          const tenantKnex = await initTenantKnex(organizationId);
+          const [batchNo, _log] = await tenantKnex.migrate.rollback();
+          const tenantDb = `${config.tenant.db_name_prefix}${organizationId}`;
+
+          if (_log.length === 0) {
+            log(color.cyan('Already at the base migration'));
+          }
+          log(
+            color.green(
+              `Tenant: ${tenantDb} > Batch ${batchNo} rolled back: ${_log.length} migrations`
+            ) + (argv.verbose ? `\n${color.cyan(_log.join('\n'))}` : '')
+          );
+          log('---------------');
+        } catch (error) { exit(error); }
+      };
+
+      if (!cmd.tenant_id) {
+        tenants.forEach((tenant) => {
+          const oper = migrateTenant(tenant.organizationId);
+          migrateOpers.push(oper);
+        });
+      } else {
+        const oper = migrateTenant(cmd.tenant_id);
+        migrateOpers.push(oper);
+      }
+      Promise.all(migrateOpers).then(() => {
+        success('All tenants are rollbacked.');
+      });
+    } catch (error) { exit(error); }
+  });
+
+commander
+  .command('tenants:migrate:latest')
+  .description('Migrate all tenants or the given tenant id.')
+  .option('-t, --tenant_id [tenant_id]', 'Which tenant id do you migrate.')
+  .action(async (cmd) => {
+    try {
+      const sysKnex = await initSystemKnex();
+      const tenants = await getAllSystemTenants(sysKnex);
+      const tenantsOrgsIds = tenants.map(tenant => tenant.organizationId);
+      
+      if (cmd.tenant_id && tenantsOrgsIds.indexOf(cmd.tenant_id) === -1) {
+        exit(`The given tenant id ${cmd.tenant_id} is not exists.`);
+      }
+      // Validate the tenant id exist first of all.
+      const migrateOpers = [];
+      const migrateTenant = async (organizationId) => {
+        try {
+          const tenantKnex = await initTenantKnex(organizationId);
+          const [batchNo, _log] = await tenantKnex.migrate.latest();
+
+          const tenantDb = `${config.tenant.db_name_prefix}${organizationId}`;
+
+          if (_log.length === 0) {
+            log(color.cyan('Already up to date'));
+          }
+          log(
+            color.green(`Tenant ${tenantDb} > Batch ${batchNo} run: ${_log.length} migrations`) +
+              (argv.verbose ? `\n${color.cyan(log.join('\n'))}` : '')
+          );
+          log('-------------------');
+        } catch (error) {
+          log(error);
+        }
+      }
+      if (!cmd.tenant_id) {
+        tenants.forEach((tenant) => {
+          const oper = migrateTenant(tenant.organizationId);
+          migrateOpers.push(oper);
+        });
+      } else {
+        const oper = migrateTenant(cmd.tenant_id);
+        migrateOpers.push(oper);
+      }
+
+      Promise.all(migrateOpers).then(() => {
+        success('All tenants are migrated.');
+      });
+    } catch (error) {
+      exit(error);
+    }
+  });
+
+commander.parse(process.argv);
\ No newline at end of file
diff --git a/packages/server/bin/utils.js b/packages/server/bin/utils.js
new file mode 100644
index 000000000..3c3dff0e2
--- /dev/null
+++ b/packages/server/bin/utils.js
@@ -0,0 +1,94 @@
+import Knex from 'knex';
+import { knexSnakeCaseMappers } from 'objection';
+import color from 'colorette';
+import config from '../src/config';
+// import { systemKnexConfig } from '../src/config/knexConfig';
+
+function initSystemKnex() {
+  return Knex({
+    client: config.system.db_client,
+    connection: {
+      host: config.system.db_host,
+      user: config.system.db_user,
+      password: config.system.db_password,
+      database: config.system.db_name,
+      charset: 'utf8',
+    },
+    migrations: {
+      directory: config.system.migrations_dir,
+    },
+    seeds: {
+      directory: config.system.seeds_dir,
+    },
+    pool: { min: 0, max: 7 },
+    ...knexSnakeCaseMappers({ upperCase: true }),
+  });
+}
+
+function getAllSystemTenants(knex) {
+  return knex('tenants');
+}
+
+function initTenantKnex(organizationId) {
+  return Knex({
+    client: config.tenant.db_client,
+    connection: {
+      host: config.tenant.db_host,
+      user: config.tenant.db_user,
+      password: config.tenant.db_password,
+      database: `${config.tenant.db_name_prefix}${organizationId}`,
+      charset: config.tenant.charset,
+    },
+    migrations: {
+      directory: config.tenant.migrations_dir,
+    },
+    seeds: {
+      directory: config.tenant.seeds_dir,
+    },
+    pool: { min: 0, max: 5 },
+    ...knexSnakeCaseMappers({ upperCase: true }),
+  })
+}
+
+function exit(text) {
+  if (text instanceof Error) {
+    console.error(
+      color.red(`${text.detail ? `${text.detail}\n` : ''}${text.stack}`)
+    );
+  } else {
+    console.error(color.red(text));
+  }
+  process.exit(1);
+}
+
+function success(text) {
+  console.log(text);
+  process.exit(0);
+}
+
+function log(text) {
+  console.log(text);
+}
+
+function getDeepValue(prop, obj) {
+  if (!Object.keys(obj).length) { return []; }
+
+  return Object.entries(obj).reduce((acc, [key, val]) => {
+    if (key === prop) {
+      acc.push(val);
+    } else {
+      acc.push(Array.isArray(val) ? val.map(getIds).flat() : getIds(val));
+    }
+    return acc.flat();
+  }, []);
+}
+
+export {
+  initTenantKnex,
+  initSystemKnex,
+  getAllSystemTenants,
+  exit,
+  success,
+  log,
+  getDeepValue,
+}
\ No newline at end of file
diff --git a/packages/server/knexfile.js b/packages/server/knexfile.js
new file mode 100644
index 000000000..927f6574d
--- /dev/null
+++ b/packages/server/knexfile.js
@@ -0,0 +1,17 @@
+const { knexSnakeCaseMappers } = require('objection');
+
+module.exports = {
+  client: 'mysql',
+  connection: {
+    host: '127.0.0.1',
+    user: 'root',
+    password: 'root',
+    database: 'bigcapital_tenant_hqde5zqkylsho06',
+    charset: 'utf8',
+  },
+  migrations: {
+    directory: './src/database/migrations',
+  },
+  pool: { min: 0, max: 7 },
+  ...knexSnakeCaseMappers({ upperCase: true }),
+};
diff --git a/packages/server/package.json b/packages/server/package.json
new file mode 100644
index 000000000..b9dfdbb5a
--- /dev/null
+++ b/packages/server/package.json
@@ -0,0 +1,144 @@
+{
+  "name": "bigcapital-server",
+  "version": "1.7.1",
+  "description": "",
+  "main": "src/server.ts",
+  "scripts": {
+    "inspect": "cross-env NODE_PATH=./src nodemon src/server.ts",
+    "clear": "rimraf build",
+    "watch": "cross-env NODE_ENV=development webpack --config scripts/webpack.config.js",
+    "build:resources": "gulp --gulpfile=scripts/gulpfile.js styles styles-rtl",
+    "build": "cross-env NODE_ENV=production webpack --config scripts/webpack.config.js",
+    "lint:fix": "eslint --fix ./**/*.ts"
+  },
+  "author": "Ahmed Bouhuolia, <a.bouhuolia@gmail.com>",
+  "license": "ISC",
+  "bin": {
+    "bigcapital": "./bin/bigcapital.js"
+  },
+  "dependencies": {
+    "@casl/ability": "^5.4.3",
+    "@hapi/boom": "^7.4.3",
+    "@types/i18n": "^0.8.7",
+    "@types/knex": "^0.16.1",
+    "@types/mathjs": "^6.0.12",
+    "accepts": "^1.3.7",
+    "accounting": "^0.4.1",
+    "agenda": "^4.2.1",
+    "agendash": "^3.1.0",
+    "app-root-path": "^3.0.0",
+    "async": "^3.2.0",
+    "axios": "^0.20.0",
+    "babel-loader": "^9.1.2",
+    "bcryptjs": "^2.4.3",
+    "bluebird": "^3.7.2",
+    "compression": "^1.7.4",
+    "country-codes-list": "^1.6.8",
+    "cpy": "^8.1.2",
+    "cpy-cli": "^3.1.1",
+    "crypto-random-string": "^3.2.0",
+    "csurf": "^1.10.0",
+    "deep-map": "^2.0.0",
+    "deepdash": "^5.3.7",
+    "dotenv": "^8.1.0",
+    "errorhandler": "^1.5.1",
+    "es6-weak-map": "^2.0.3",
+    "esm": "^3.2.25",
+    "event-dispatch": "^0.4.1",
+    "eventemitter2": "^6.4.5",
+    "express": "^4.17.1",
+    "express-basic-auth": "^1.2.0",
+    "express-boom": "^3.0.0",
+    "express-fileupload": "^1.1.7-alpha.3",
+    "express-oauth-server": "^2.0.0",
+    "express-validator": "^6.12.2",
+    "gulp": "^4.0.2",
+    "gulp-sass": "^5.0.0",
+    "helmet": "^3.21.0",
+    "i18n": "^0.13.3",
+    "is-my-json-valid": "^2.20.5",
+    "js-money": "^0.6.3",
+    "jsonwebtoken": "^8.5.1",
+    "knex": "^0.95.15",
+    "knex-cleaner": "^1.3.0",
+    "knex-db-manager": "^0.6.1",
+    "libphonenumber-js": "^1.9.6",
+    "lodash": "^4.17.15",
+    "lru-cache": "^6.0.0",
+    "mathjs": "^9.4.0",
+    "memory-cache": "^0.2.0",
+    "moment": "^2.24.0",
+    "moment-range": "^4.0.2",
+    "mongoose": "^5.10.0",
+    "mustache": "^3.0.3",
+    "mysql": "^2.17.1",
+    "mysql2": "^1.6.5",
+    "node-cache": "^4.2.1",
+    "nodemailer": "^6.3.0",
+    "nodemon": "^1.19.1",
+    "object-hash": "^2.0.3",
+    "objection": "^3.0.0",
+    "objection-filter": "^4.0.1",
+    "objection-soft-delete": "^1.0.7",
+    "objection-unique": "^1.2.2",
+    "pluralize": "^8.0.0",
+    "pug": "^3.0.2",
+    "puppeteer": "^10.2.0",
+    "qim": "0.0.52",
+    "ramda": "^0.27.1",
+    "rate-limiter-flexible": "^2.1.14",
+    "reflect-metadata": "^0.1.13",
+    "rtl-detect": "^1.0.4",
+    "ts-transformer-keys": "^0.4.2",
+    "tsyringe": "^4.3.0",
+    "typedi": "^0.8.0",
+    "uniqid": "^5.2.0",
+    "winston": "^3.2.1"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.14.158",
+    "@types/ramda": "^0.27.64",
+    "@typescript-eslint/eslint-plugin": "^5.50.0",
+    "@typescript-eslint/parser": "^5.50.0",
+    "chai": "^4.2.0",
+    "chai-http": "^4.3.0",
+    "chai-things": "^0.2.0",
+    "colorette": "^1.2.0",
+    "commander": "^5.0.0",
+    "cross-env": "^5.2.0",
+    "eslint": "^8.33.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-airbnb-typescript": "^17.0.0",
+    "eslint-friendly-formatter": "^4.0.1",
+    "eslint-import-resolver-typescript": "^3.5.3",
+    "eslint-import-resolver-webpack": "^0.11.1",
+    "eslint-loader": "^2.2.1",
+    "eslint-plugin-import": "^2.27.5",
+    "faker": "^4.1.0",
+    "getopts": "^2.2.5",
+    "gulp-postcss": "^9.0.0",
+    "gulp-rename": "^2.0.0",
+    "knex-factory": "0.0.6",
+    "merge-stream": "^2.0.0",
+    "mocha": "^5.2.0",
+    "npm-run-all": "^4.1.5",
+    "nyc": "^14.1.1",
+    "progress-bar-webpack-plugin": "^2.1.0",
+    "regenerator-runtime": "^0.13.7",
+    "rimraf": "^3.0.2",
+    "rtlcss": "^3.3.0",
+    "run-script-webpack-plugin": "^0.1.1",
+    "sass": "^1.37.5",
+    "sinon": "^7.4.2",
+    "start-server-webpack-plugin": "^2.2.5",
+    "ts-loader": "^9.4.2",
+    "ts-node": "^9.0.0",
+    "tsconfig-paths-webpack-plugin": "^4.0.0",
+    "typescript": "^3.9.7",
+    "webpack": "^5.75.0",
+    "webpack-cli": "^4.10.0",
+    "webpack-merge": "^5.8.0",
+    "webpack-node-externals": "^3.0.0",
+    "webpack-watch-changed": "^1.0.0"
+  }
+}
\ No newline at end of file
diff --git a/packages/server/resources/css/modules/credit-rtl.css b/packages/server/resources/css/modules/credit-rtl.css
new file mode 100644
index 000000000..8b298e3dd
--- /dev/null
+++ b/packages/server/resources/css/modules/credit-rtl.css
@@ -0,0 +1,553 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+/* Document
+   ========================================================================== */
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+html {
+  line-height: 1.15;
+  /* 1 */
+  -webkit-text-size-adjust: 100%;
+  /* 2 */
+}
+
+/* Sections
+     ========================================================================== */
+/**
+   * Remove the margin in all browsers.
+   */
+body {
+  margin: 0;
+}
+
+/**
+   * Render the `main` element consistently in IE.
+   */
+main {
+  display: block;
+}
+
+/**
+   * Correct the font size and margin on `h1` elements within `section` and
+   * `article` contexts in Chrome, Firefox, and Safari.
+   */
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+/* Grouping content
+     ========================================================================== */
+/**
+   * 1. Add the correct box sizing in Firefox.
+   * 2. Show the overflow in Edge and IE.
+   */
+hr {
+  box-sizing: content-box;
+  /* 1 */
+  height: 0;
+  /* 1 */
+  overflow: visible;
+  /* 2 */
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+pre {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/* Text-level semantics
+     ========================================================================== */
+/**
+   * Remove the gray background on active links in IE 10.
+   */
+a {
+  background-color: transparent;
+}
+
+/**
+   * 1. Remove the bottom border in Chrome 57-
+   * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+   */
+abbr[title] {
+  border-bottom: none;
+  /* 1 */
+  text-decoration: underline;
+  /* 2 */
+  text-decoration: underline dotted;
+  /* 2 */
+}
+
+/**
+   * Add the correct font weight in Chrome, Edge, and Safari.
+   */
+b,
+strong {
+  font-weight: bolder;
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+code,
+kbd,
+samp {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/**
+   * Add the correct font size in all browsers.
+   */
+small {
+  font-size: 80%;
+}
+
+/**
+   * Prevent `sub` and `sup` elements from affecting the line height in
+   * all browsers.
+   */
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/* Embedded content
+     ========================================================================== */
+/**
+   * Remove the border on images inside links in IE 10.
+   */
+img {
+  border-style: none;
+}
+
+/* Forms
+     ========================================================================== */
+/**
+   * 1. Change the font styles in all browsers.
+   * 2. Remove the margin in Firefox and Safari.
+   */
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+  /* 1 */
+  font-size: 100%;
+  /* 1 */
+  line-height: 1.15;
+  /* 1 */
+  margin: 0;
+  /* 2 */
+}
+
+/**
+   * Show the overflow in IE.
+   * 1. Show the overflow in Edge.
+   */
+button,
+input {
+  /* 1 */
+  overflow: visible;
+}
+
+/**
+   * Remove the inheritance of text transform in Edge, Firefox, and IE.
+   * 1. Remove the inheritance of text transform in Firefox.
+   */
+button,
+select {
+  /* 1 */
+  text-transform: none;
+}
+
+/**
+   * Correct the inability to style clickable types in iOS and Safari.
+   */
+button,
+[type=button],
+[type=reset],
+[type=submit] {
+  -webkit-appearance: button;
+}
+
+/**
+   * Remove the inner border and padding in Firefox.
+   */
+button::-moz-focus-inner,
+[type=button]::-moz-focus-inner,
+[type=reset]::-moz-focus-inner,
+[type=submit]::-moz-focus-inner {
+  border-style: none;
+  padding: 0;
+}
+
+/**
+   * Restore the focus styles unset by the previous rule.
+   */
+button:-moz-focusring,
+[type=button]:-moz-focusring,
+[type=reset]:-moz-focusring,
+[type=submit]:-moz-focusring {
+  outline: 1px dotted ButtonText;
+}
+
+/**
+   * Correct the padding in Firefox.
+   */
+fieldset {
+  padding: 0.35em 0.75em 0.625em;
+}
+
+/**
+   * 1. Correct the text wrapping in Edge and IE.
+   * 2. Correct the color inheritance from `fieldset` elements in IE.
+   * 3. Remove the padding so developers are not caught out when they zero out
+   *    `fieldset` elements in all browsers.
+   */
+legend {
+  box-sizing: border-box;
+  /* 1 */
+  color: inherit;
+  /* 2 */
+  display: table;
+  /* 1 */
+  max-width: 100%;
+  /* 1 */
+  padding: 0;
+  /* 3 */
+  white-space: normal;
+  /* 1 */
+}
+
+/**
+   * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+   */
+progress {
+  vertical-align: baseline;
+}
+
+/**
+   * Remove the default vertical scrollbar in IE 10+.
+   */
+textarea {
+  overflow: auto;
+}
+
+/**
+   * 1. Add the correct box sizing in IE 10.
+   * 2. Remove the padding in IE 10.
+   */
+[type=checkbox],
+[type=radio] {
+  box-sizing: border-box;
+  /* 1 */
+  padding: 0;
+  /* 2 */
+}
+
+/**
+   * Correct the cursor style of increment and decrement buttons in Chrome.
+   */
+[type=number]::-webkit-inner-spin-button,
+[type=number]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/**
+   * 1. Correct the odd appearance in Chrome and Safari.
+   * 2. Correct the outline style in Safari.
+   */
+[type=search] {
+  -webkit-appearance: textfield;
+  /* 1 */
+  outline-offset: -2px;
+  /* 2 */
+}
+
+/**
+   * Remove the inner padding in Chrome and Safari on macOS.
+   */
+[type=search]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/**
+   * 1. Correct the inability to style clickable types in iOS and Safari.
+   * 2. Change font properties to `inherit` in Safari.
+   */
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  /* 1 */
+  font: inherit;
+  /* 2 */
+}
+
+/* Interactive
+     ========================================================================== */
+/*
+   * Add the correct display in Edge, IE 10+, and Firefox.
+   */
+details {
+  display: block;
+}
+
+/*
+   * Add the correct display in all browsers.
+   */
+summary {
+  display: list-item;
+}
+
+/* Misc
+     ========================================================================== */
+/**
+   * Add the correct display in IE 10+.
+   */
+template {
+  display: none;
+}
+
+/**
+   * Add the correct display in IE 10.
+   */
+[hidden] {
+  display: none;
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+th {
+  text-align: inherit;
+  text-align: -webkit-match-parent;
+}
+
+thead,
+tbody,
+tfoot,
+tr,
+td,
+th {
+  border-color: inherit;
+  border-style: solid;
+  border-width: 0;
+}
+
+body {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  background-color: #fff;
+  direction: rtl;
+  -webkit-text-size-adjust: 100%;
+  -webkit-tap-highlight-color: transparent;
+}
+
+@font-face {
+  font-family: "Noto Sans";
+  src: local("Noto Sans"), url(data:font/woff2;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Segoe UI";
+  src: local("Segoe UI"), url(data:application/x-font-woff;charset=utf-8;base64,d09GMgABAAAABNGYABUAAAALiJQABNEiAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGoUkG4OmVhyBlhIUoygGYBaLYACkPgiUHgmTAxEQCp66AJuseguBjRQAEoTYMAE2AiQDgY0QE4OEcAQgBY0qByAMkEBbEHraNPxj2fafmXYoU4pEYMYW3FEDLgcRp1IlaJbEw81E41HPGvX3B9i7DfopKmHXnw//OUb2xq8DKGEtBNu7NRB0jdELA4ZiVtq9JRH+l9z7WdnJcgDslDD/S4cW5bBtyf7//////////////////////////////////////9Dyn+dzs3Pv+89733v/5ychG0tYTVAhSFBABGURXFoRRUSUKlXBWqtobau2tmptZ6q1U8cu02XWztKBqFN40QBFnCCTZrlcvqVQJKVyJdMixJsIJ2yroq2dCjqqnUXtSkmwrpur5nt6+3Yq4t4a6m39uxycL2M32eO9cFVFB614F1jBAAaJFgYaQ3uH0RypdkqtFfti7GcqyraLsJ7NifFolcsrdnFjw5kGccR1Jsh74vdRxW4HTxxSJyQXvMO4kK4DoiLIOsSO25NxE+ozB+GCjk6KTjULbo/gUKtPPfVSdsWCCFLB4Upxsr86PYPZOV9CJg+H8fYjmGfrnlvQMVb4o7zPkFkhvb27uWM4LieomuejjxFzQt54k4qKsHLSkm5yoKOOiifeaR1CHAQKgcIpnMA54ohTunjKe08nl05mySnF7OJpQRcR5gwRulwn6VnvBSvn5oJHoKvIsEnWtEDP0yrWlB8WeppK7cJFb7COEFHHAk5p8a1LLkAEcjlswEM1DtWAjIRaIB773t47H3JM15WcQ0MKZKUJT5KrPZc9GYhDzaOJsLNUu+ZjOHgZc7op0wKfr8Se5tJR74moEMXWGQcv0OuYk813yA3iHCtC9xppb42+CxdYEbMr3E0IU6FCMi39UBNnwXsRqZFEvDpC69wYE0iVcwpFN52/xfZKRMXzI9LsI83c6uSZAVJMQ0wCZLPO9gtXGlfjY/Q2OZLP5/VADUtzOrHiFL7UxLVAPF8uz3Oqyjkxbiu8s9XjHE60TvSu75leTcg2ymTLTfXjDnHMubsoktadWRLzGX7aozyDVqQQ5zy21vC+Jwv5e6GPE+znBMq1q7LbG9wHNba6rKSNOCUjCw14z5zJzzjSAdnAduo+VLoiCEJX2LMXk530Wg/5iBFynxFs37Kk+oBpDf3jBQg24eDx8MSy88gnqGZCgFxN4PcHchrjcNjIVqX8lixxqRtoH9e7tYc4+i5iaV3dHRplufH2EEKxuFxYu5Ukrdfij1takvqE/2TxUYw4LiPBe+2b7iKEvlthhU7Tlm3zpgVvJRfoPSF3zcoGn7ISzWfc+tRh9p5hu003b3KyVLT1zhC5+vhI8TC9PgcX/VlW0MywK6jlpjqw0otT44ySdSY1eBL57Q85nx+AkBKC+dPohM1NEPmcKNXSEzjqHJmFg2MOCJsEVsR4dq5jbJhMz+XPXe5D6zwvYn7TXMxXTabIXlLXZ9Y1vsBwLpc16IvuS/4i/5i9M/Z+W5uyz5h5g+7o22YgRkWbSgZpKpE4K67do1vMVdKn0ZT3YNDRP+y/AEc+Jn/EV+596gq0Qp+/kA/lDSJ34faVXyAQ773CVUR9Ww8CyfRMkJM+Cyc4j0/1a4hRfWD14+m1W/CbkkAkI+oa4tx6xvmgCDMCpSIiIhBMdSocJH7vUHG71BhYuHL55RcFFBoIB0g1pmqnY7Y6kmH6jfGyRXX86UFgBoS7Wa1VfOVbXEWWE0iEW7NMrrxZmSBv8K38PPtYeRfBcf6dvh6ll4wXxJ60r3CvMECC+QvzgvEJ+op+DZU3qUDNNnAQ+0Wo8JdH0JW4aOaIZ4SOUeGXDO5EdpbtfILbzftmr/jnfDWyP18+zj29gUXGa3iNae6C2PFw9DBKg4+gb3oRMimKJoSoQKGIBSrMJ947CCcQ/Q5HNONlHKcfpd+pDkKJE5z7NjjxQ4cxlCBA5Pz2SY8U36NbXYpLAv/VsEObzIZFUhKiV/BI/MIzOFLwIgjEVbKkCL2ibXvR5pA/6C/hfsje2K+oTPU4xqE6BKGuUEJyqR89zZ0bkzS7JWFdSfA5VgzcOpZJ/HrJG1brP2iRDm+hTEYQE0ULGcz40q7RAfTHmnvxAamH/EkIHRTGMyP0WQsK+VeSOdaISZY4JcFdgQ8hczA++6Q9PhSPtXjyZcqKsEIuUl/Ccf2cOFL6QfC1I5WtHDzcqZTdxd1OE36E3XjKrX3WxSm6uRU5Z5s0WeELYp2fOcY1Es8v2JagxAlaORELn+E1hP5o306yzZxA7S/sWkLmzL+y4Ceas7sXW4KbCHqeOrzkPbukrAgrXA6CuMQmSA0e2ub4CUdG7Q7ume0/W//Lt5CXQjXylWh+ZL4xalr6nH5vUZdRlp15xDk6STsjq0bSznby1cB54/uRBnaAz6zsAB5EE/OxuUQg06zwapHyL8l12xtcYAMvvPAS6Sv7t+0tcu5oSa5BUBlgA5+ywgsvpMP4uv2/WpxlF3JEkCQpJxBOoKZi1GH8V3vvD+MXmiAdhiNpNyu8sBJFGkHzbyJ2/93mIvfyGxGaWLnG5/GPRxb4SP9p/887gAfW/8v6X+3/7d8QiN2vdwQVe0vcbygIybO9wgovvETkqb4i4T+KYOx5MZco2ncA/7X/J/o/u3/HYbE++3/LT9NTVi/ar1Hl7Hps6SD/W+MxWSZqHAsrDeVOQPgh8oOY6XGaRKr8E97zOTJN/U8YJaNwxrk8K8qKSYY8FeZ3/jn72aJt0wOCiFzWdr8BHAA0IZXSTWZlpQxlrZpNjK2dvXAQjk65CGfLpZmU7qpud4uH8PTy/ozxlfmT+ZfZhQpqWnVktQC7BWSxiaS5sT1A6NmBA1wE4wKQ5ZUH9kW/A8DfwvOIfvRi/3m7/6/Ffeo23v89YARHHY2QEQwnCMcRzFByFfz/t9//25p7F5yqA3QpjPeH+AjzQciMCIOOb7rb+Vig1xnt20dJfBBhzvqvaslOsuCHQLfPBCcA4GQsdQT8b1sWUkZWxE4qQO1E6HSd5IfQlilS19VZv4n4SUyObu/uAhpMGmva3IxFWBDmlXme/2fZvAP/7cIspfZN78ZhI4TuLieOyDhUVBWq/d+cJgW2jKkaKsC8nC0KEz2gImUFNnboNuVvxIr4/y7dOzaOuXBfbsc6KDH1Bxck5D/6alEGt6JAPCH49ZRb3xnmocYQYJwNh/mpAwUix62QD0HjUeE0DhgOh3EIkxAghhiOGLiD3lGii4EN6AaMsxp0PT7fZb/Z87w+RNWCfp8729WzAqGxivAYtEVJhEIjv1H/XS3OWXR+n3SlpUhG/yed+b03oNGMNCKwLMtIWe9mk3Xydy+3HwjrO64Tf+AO0NWVvwP0IXysDpsiRXn3U33HScWI1G3+05RhzNtLF79e8snXneQctuWOZRBYbiEATthSQ8gZ91IVHv5/7X/7nLnz/h19dz6S8IQnPJHIookk2ogVD43WoLIInXYSC+geAzkgENAACwcGB/i8/dvbzGhmOTfnnePKFQvJl68lIbEkJK1CKqQQUlqihJYkRhJr5gghluPMceU8myPniG34b87/zpkp7+3OTMpSRdSD1dHqkUgpgdDSltJch+R87e+9v09660aoKKQBKoiGsSRXwJ/87vqfa/k4vhX6KLdJd3vvgLIKIYegaiygbIVBi761wA7QfWL3LXyX9V0tWZbaHg9hiBYmWaDQcg6A4IseMCwRB6oY4i79927mP4mOizARrlOqqrY3hcNVyaAUQpfqUQYkAzA3Bw4EBKRKJSUkWqRqVMVG1DbYxopRgwWjtgEjsgREVETQRhsxbt8YgLk5YMRGjo0NNhbJEtaMXgUMVsCITAlB0gJBSlBBRIzOG33zdlx/fwdgbqIgKiqK0NIxRvRYVTBWsMGIjaiQKlERI/K3/uv9W//7bp439vTz7IP5k9xAMmiBQSAMCIXTCFmtq6q7Q+ea0EwrrnJGgTijeaX/N6pjdnAutEtnILNKpIgUkSJSREoRESkiRaSIiC9FpIgUa62mNnWstSJSRIqUIuKLZx1rHcdxstYREREpIiJSRIqIFBEREREREREpIiIiIlJESpEOXfN5rKnX9ZHjAUJS5L0/1/+8hpBJqaSTLCi6ePTW9vUG1nKDnMRyoRK9EsrMOVN/M/jyB7kmKFeMuzugCEVK/puZ2aVfSIX/pWbZ73ej0UA3gIYdzHCGxNDtrDvMHs+ZkXfh+cqX62iGB5BVgAxXhrdy6W2QydogOROplOkUOp6pXKW/3++rOuciPaAPmPQrK7Oa8A6QatADdt0AqY1aUqzYmKEG235J2FViZ5Ker92+Swa/VUJ3UNzsfDzMQDBiuTagMMmcRDhbLF+6NT/8u+1/hzFSUHkScpEcSAw3GTViO0SPSp2o3MiXkb+R8RWR/r1opNm8opYngJMbuuZCRxhAMv+qy/hKo/l9sGl/Z2cXokbNnLpYKk6pm17O8wJj1Ypo2flV795ZgfAIeRqDUSiB0igUzhJT/b8680o4LEdzyxvwNpenvm7MM9DGpCuhkyPyka2kiv0lGb5F/v/7pda97z7gz4UiEz6ZgnL7u1YKWvFJ1D3gyQBCDez7ZNkni2WDT6tKStlyYiVdwyQP+vSKYJVI7fle1XIGA4BEH5ROgmCXBElDcSTZkL3GbLU2Z1/rsFPq161Sun1+T0pROv0er/hrf/O1RV55nerbMLxmOs3nq94Xpvgqc8/X/pTV50/rAqpggn+IFqxUHAtwmx3j2cz1/fTq/H5GsiGcM5JsIDf7aukjjWyT4IZtcHJLQ/L8yORV++4fxaaEEKpJaZCQUroKyb13d8O2v/e1uiSq7F8DkgS2e2bv8klVUKa7kgbNU+bXVL954IS8izMykgMDUkbxX2i6K7r+YHoK/fZ/Oa3+rypRfZUVj2eXrzPHwzzZoiROYqAmkPwvdrKYtBeoMwhsW0l3L/J52By4vGMor6rqm+w68ULpBfQCeJDq9J7+DpUJ2A48VqqjR/ifpVkBpJz5yFJVkinf7Quh+MX3NR3xxyy4zh5uCB3O2uOe5qbr2tPBGlYFlO0KXIfOdSS7ucZjrEZrMxY0UKo5D7CW505hi7aB//+x59c+N5mboTVjEovR/EGZ4a1Dtqq4/6FMkhDokfUTE199v9eWmBRJAIPCZsmOT26ypb3y1U2GSroz8ULjJCHAOPk12kOmRnH/PYBtijSapgqiOCEb735uv/ZfnPohYRASYoxiPinPkOqM/0rfKANC9GsWQiLE06ek4KRTQnXBZR1vvNW17pFGdIRdUiP9G99LXWY4IJZ9JEv2Wgpzm1TpkmfoGKtM/0BQUVH9fAcEP1/n+3fOxcxUQvK6ZFIs42L1qIlbT1zEnAft9OV6+7/XXPpyLYFTyOUKeFuMWFXCTB0Bj39d+caU81n54IobZ/r/q2rfu3gAiEwEggQDQmJIDySYQJECFaLt0aTkzanrt6i/nSlLtjclb+Uz3XT/uFNRjTVCdRHuDzWGDer8vmSSSbZkyZYlE8aJEycP84Bm5vMCUnXACwhNue0dNy36j7qyJ8uyLdkyDC/PLof5HzAVPVBZzxcFuj5Nk9wdYXWOV2UBucnlQyE4fHHs0/gZNWl3MKP+UZtiUnopGT2NV2PtmPkEPv0/iRikRdRavhtCgsoQxRsl7InRzDJqXiqxcQTfJlzcecFKkmI+CdEAEIKQ5mC5gsJYHBgTIe3aT4eThIOKmd+XuyqiRAIEKTnOW34vczlc5+9V1Qd89M6m0iEeZMEpTNOnJowZFp6HWXumrQ4zCkWq1EOYSqa50qYudKoL08fwct+0151t2l21lU7lJF39rZ0d3d5o5PYBNCApAAbAABiE3QAMigEPspEBzDNFMZZVz+YivAYko/Ks2bNQX/H/f7/2ez+GfcYvamkO+OqmjUgiQUli0SMlEjrRQzL50ogz/te/r2bndLx9u/t23775ZYSHQIB8oCgGJfINRmPDtlDShN2M0myKI1sklUYUysSG0ThdVV1sCZv05681NZkOgqngLG3IkqO0WxyXhnJMHM2l9xo/gZ6IL6JXkV4n6+RhRhmwB5wRRB5QBpxFkccueHyKXI4qD8hyeUUPbbntKHGlilvtThnAgzGbtXLEZPCa7HdPrCfao1CoqqI6Hex9K6efmkTsIurmRM94Fpzixza/ZnfzBXglaZqWCqLBtE4VRswO9+OatkxAQO4V153i9iL7wkp8/Y6UCuMwRxBe+MMGUPT91NzzQkSOyg7QM4Pgy6uwJMsBkr4hYX19RUqWLdPuEei4fEI60eWU8xYAOeLGsAki3RSa7MPXXF/1Sl6JxypJRYGqGIHuhigtFuWLkXTo2VESSOgZJ3TS3TVCxWCt5lOBhF6X28yeTE67NzuLncRaIaHA4f+pqncgqQonIKkOl38+US6gRLtTHSFwanhihd4DXA8O9EhqSikVaW3NMH54gjLVOmVYkrGVlfmwEHHtp/8/d7KBBXYRaSpiiyY5pd3X+9fnY4yxG0T8xtlO/zrLqynegrV/KbCNhYSM1nMKYxbQdYxkXfWT1rhdQyRyV7ssp+Yy/1dwPn5IqVaBGSO2Fd54SDUk+fi6DpNvNGuEms2t7e2VqVXZXdXVQgmIhiJAokGQGEFyZpYr1AmtXTUzJ6qx7oue8j/ePc1X0jvv3De8W8N82zScv6XDDUHEDi2eiSc5XFpqNNJqq2a8Y429Z9lnXyte/X9ax6R0mI4DWIJYDh8MDvqw0MPcs/HYv42pYuqGXG1iELbB1jkR6lQu+7elbnFLDSIaQI9t7a4+TWgmDm34cHKw7vm5R9qtUodArur5cLkx+Du4ewqRww/8kdKOGQsN4yDYUXU+FyJzMxpaug4a7p32pll9RfGMtV6nNECCgpI7QO/xX1JqtYfsWN9kRrrSUKkANkAO0NTEAWLMjQyMn3LaVz05YFZZKqEliyxZZMm2Yoo7cdpN6e5B8gKTaujEbwluf05LcM4sd87Lx+Wc5/T/0lX//UkCZaaUmZKqVNw80zM1sAS9vUgmogvYmhtRMpc0EdkLaDjM5lvDI7SmF7/1scCTyjjkfK+8JBwsRHXjxbgga/9+r//waWP9pOk1m+7BR+0ALaAifBlhzP8xZ5/ZLcUo6T0W2k4y8Ge2xKcebw2JgouD+v0WFuE5syKcX45kaIacBf9PZzlfI7DkkTQzYssgmRZ8QKCEq3TOS82gH8QfwqJMhWXe2/LWRXV7ReeiDIXbqiDSDbXd+JDWkXyQfUMyw8fLc10dPTpCJIpq6TDOAi3kis4u7KIwExEVozEc45GgfvnNsvXI6obY8k7iWOGQSHmXd++Rwn6yzEnFKN0SYtIIhdAYhXBJKMn/36tabd/DJ8wHCKIA0QGUXW6wqu0DqRPkSVvbVXVO2RNCWMX0373/P+C9BxDA/6DN/yHZxCdlE6TsIkipSoRUXQAYmnRLM7I6JHfMnpQJSi4XKVWQ6Bq3aHWQ7E72pOqQorsnelc9u9mFvJxdLSek5SyWNYttd15PWKwWs9jNZj2L1fDwtd+rfX9PeNUnFf3UTlSUi4uOUVS8BXIhWwZV3palRYeaVOtErQ4YrUshO++sQALjPQ6eauknnXd7c9I6JqYyIltylp0Z0s6sPL/V21JNSU6ZGV1ETkp1NY4RIEMD+k2dsbENADTgVweI/89Us53dnaEGwOAECBeAi4Qj5ZCKStSdnJIqh6qY+f8PBrs7AwHYhQJAKpDShRBBUPdMwlk+p9T5XeVUuboQXcamsN+3tKSrndMldGcbgpAgdnVXl7Wj4JRRJLB/hZ4kOSPDEAlBc89Gid389+rst/dJwEiGZGSnyVPNVJH8Ys78s6dNaX33W73vyrLfe5KN9GTDs2yIJAMjS5RnmRBZJgwYknGlJ8fU1GZMSOWfeZILsg1ElnBcKAE51XAyNIeWQjszjtNMmYxDGuMwrZVllv/81V/OYllaX/7dfk5W///VnL8tbbEqpaz/6m/WHx5LX/9ttUB+xObDlRvypq5SdTJWnrnEoSbPC7swWUXqAv/FUqVePUC0qUsFAwWYKbzo3D/clE0p1e6HzFI6RC7ITJIJCqABgAXjjDkI/9Tfo5qfQ5nQm4DJzgavtVLAEBSrUnqKgx83gfRsRXO86GaS9ICTvpVbWf//V6rV74tIJAnAkpwA5TIoL02yXF0Ue6Nrtl9SS/W2bhH33hcv872IBBCZAIFIQCIiKRlIkDIRScpEgpQjMklVIin3ASl3H5mlPkclzWJrNlm9qTQbECBlMUGqxAQpWSBljUBJPkeSq3pxzbLKmk2t2Wj35nbP4t52n/74mmX/nK/5nJ/P+V/2j++/gadv7PfV9HQLjUZo1Hz37QwiOkjWNPg+zEODkAjR5KuF9vl/+AuTM9dOpC3YgljexxnbALUzSEShiELwrcwv2llBbJl0vEFiI8BmOKtMzR5ZQexu5P1ob+svOs7/K1X731YDlkXJEyR7gjzvhxD3dHh59X9eLdH3VnV1V3V1A90ACKLBoAZFW4Rky6DSUPJMB4CuBiAZpOQ5JO2ZL3uS4zhMypQ9yTM/2C/vft5sQ4yr5Rz/EDeLD9+TZS71Vvmsb2CaqAeCKAFJXP1mOeZzyY60/v/Vva5XDQS4gEjRSxXpbX664KbUNiVT1mz/vye40I+FKz+Vn94nyVV6ZuCTPsaTjyc7y9L6MCfLnhP+KS7GN0e9+RSYbRjuhRGdx1YmkEEiPP/+Ltv9h5SloEqJbibY7K0LWhU+RDWdvrQd5E+kAStzod3/x1KNpsuu8DhdxzMIhXAO/kkukicD9ADHLln6jqetNLX1Py0t0098YLdFkFXkNNft626fQa7N5AybbewkkvB/C5oGnrg7JH2I8n0HiUYRlHF8tn2nm9r/z5x9abUbGlTfOLM+SCkpaSBhzo82myQU773iarob+PJ/jfMpr9Du6UIJ0jrN+nSbkEYUQKb/5fzXFkm2WXAAPZxipzYXvSmr/89Fd2Yvnv3v7+LEc0KJF+ZHHCIKFVLFbOWmdR1y6npDVLNKeveL7er8MwNqRo3QdZa2WuWyrPsmNL1oQ+Mfvnh62s/soNs2k/0jQUNTU3NmQJGhlDN+Sx6WUlPwCj/oq1Yn5vNfl4rjryeZfv100EO0KIXMN5eTqoyeR5fhEVTou3h63q1zuPuRR1a7Wow22qSNyJslhbq1DcMQQghBREREQrbc3a8Vnn4tNG++qI4YKlYcx3KcCBGhlOrCf1ei9+dwntMc1hprrRUVERVRFRVVNSfa92fnWtl3pZklPEJYTAhGCCEGMQhfaf9D34n0O7v/NnD97omoqKio1duwMqOQvT73hiAhBBGRVMTduwv2CyEMRUSGqb2aM/unvuRetpsPPoTwCCEEY4QoRCFESC/rDPS/lEYSuKtSVBZiIYdFCpFl+HyWsFg+jrG2JOqqfXwWfDScSAgiIiISggxBxGukkX08L5rmrIoipO9ce2gvsQgjjBDGGGOMMUmxJE2xr1nWsky4PGoFI6UWERDQ9/x2h+EW/7JUr7jW88wVDBi9wfaqz5jv/fwZOvuLWm23/3vt1jPNNhOyIEB4j8CNQ+ZMHHTudzJWAAegMm1oCYbkQvq+jP26B9sYfmNA2sesU+qSzRqu0PZMea9YCAmx3cThzX9izseSgDG7bf6vfyaaSByIgqw7uNvv3YhtefjU7V6LfzI3QcyGlf9lqv/Hju20Tdd7/+etJI0HmLEkQCABAol5hVDjy34ZNZgQ8JxnpVYtFTsie30d9/f6vGz6f0L9vN/1i3WmUAhiw0JKbZbcu0G0vV/8n9Jz3zOfc1+hWZogIiIhiIgECSIyhPXdKr54Sfc+c/YUPiJSiEgRJEiQIM6ywn+/H1rvGwkmSXuGsqyJ1qUUXT4++yNL93svG5Dp12DsrlpZvtA0Fx3QwNKWsoh4+v//+/lv5t4Yb+Q+Ftd6Ttoch7WKijwMysPFQ1zCVojN6H9/Ym39R0Gxsv7VXmdtinDPwBzvzcGAgJbWHoM/5/+fIFi69I4zplcqU0BBVsKQsBOSQPv33hRrVoMCaj7nTTK3kxmTqDxfN3QLzSMgz9eNgFp1/5kdgBMHvCheQ9wa0BUMcu6lhD0PZc2bd3A93P/P8A+eAYPCfTTfOdid+bV3e8fSV6hRN+QN74WNPOcbv5qbH+kXvpt7/mt95X/8L8rrJCiXIlHl0UmAevMo9FsIXO1ACqMuAzLbhMlqM5Dd5RQ5bQVy20aR1zVASTsoYOEHwOd5hCmLxAssFixl2eDAciFSVowW7BwaZZ9IwdGRY8dGQzkpOnBKTJSz8gJ8P8eUBZyNqfPtJs9YdaVm8sqorsaRTyblWyv5tagqqqDKatSPxmkiqduIodHQuRYlg5sWjXvgABDxwAFQABDSaH2sYVTlnIJT1XMaxh3mDowHTwich08ojEdOBJwnTAycp04SnJcMGc4r5j2MPZMF43WTDef1Q4HxhvkE582TD+NtUwA3vgWA5rkac5ScVafxdVnlZvcS3NHquvdSr9L16671Uf//VnV+4GamcofRBOgMTaMBUIClgOWAFYA9gNMHEt34BPspaD+DfYzuiyXo5C0BA946iEQb9ofh6p9mI9T/cjms8OKbwdQBH7+1Rgd881F22+AXqrz9H5vkGr9XNsh1f99OyQ08qt4id+YT6h269A9dHG5ZxVUsNzkllG4SJZVvCpRSuSlUWs1UTBm104Fa57g3q675hJInVI8dKUeECz8q5Ap8abr9efXoWde4Af3zG6Dx7WvaSfRr02e4nPyrjormraf9WRh245E9YxQRUpRoMjxo/o6QsbXpHLjyQnRPpKfIn/aPalKvXZ9Rs5i2ZA4duASxvO89Fv7kKYhAHgqH+JJk8Wf4rIWln9biUIEaApUEFGKb8YECP9CQhBSkIQNErp+AAS4RRR1ZkVOT7YD8w04K6vYEEnyGbmu/OKrAmUCEJ6SQSxmNeA/f4XfAISJUoiFt6Exf3mPiyTy0U8suTnJdAHheMtKWk7wVrBgmk8IS1qtPs9qCiVDnhQBAVwP8xnLtiW4F4jzW+nmkLRNSlQhJWHX6mHcn9NIT+gYm9L84YeKFCafwE049OOE04/DcJ5senld5Sg4+vCa3mfl1Wg3IZ28oBIeYdHNl5Y8pzBpb3MtHWQ7+2VserkGM+bG+lfQ8gFz1gINMuJOfdLd1XG/TA4zPm5Dq/+Fj6kUhqNg/9eQTdv/q8sN8x/UFT+0d5wue/mR9/2f/7CCTnvv4uI82fww4ZnP/5w8Fcs+u9Tzkqrdx+ZN0OtDJf7Tmq9GpXDIv2wJ+tEvt2glq0SUv2wI17GNneGbt0oEh3YIMajBzYC233+Y4ISDOdN6VwJefhJpb+xFWk0J2O9anUGlCkVSh1ur0BuPM1fc2Z7bntLwRl1AAEGHCuJBKz2ABLMdGAXAQYUL5QnegWCyq3eH0BGWmwkAABxmRNdkBCQUNAxu+iRsePgEhcTLIKaiUpIeJU71Wbdp16tJdz3xV+g0YNGS4ESK7Bk1aMXXUJYesO2LTaWec7RzOa3U9e/HqPwAIAocQFhFCojBYEpnOYLLYHC6PLxSJJVK5QqnS6AxNy7VpK8c5sXkRGERQDCcoFq2rp28wwwn3HD83HISJjUvGnKUVmDVbIa/KUKBKkRolOeCszKBqca3atNeRq6hHqhsIdR3EVDOYNW/JshWrHerW66hNJ5x06py+zoHrFu7yFSkGAYMazOhFORsCdxTB8UXEwMRq3rqjHnt2tvhC8YbKL6ZS/fBK93AIiCy6RkWiZKm0AwZ92YzKl0KgwAlbSGjY8CAqUcrIrIxVBbtOwcO7TwbxokxUHXY85uLs9H9KP2nsVpCKnWo0W9L+FHRKMLb2RBLPBwfNfWFxP+rDZVH5hCAZK4vPkZsgwC5N3st+Y6f1haUvLuCoHlfTkeyTZPVsSLZi71lcFkqGyfZgY/SGpbcsSd7HR6FACF42WCMPPKYYfDPA39Dh/+jE/l+vqL/8taTbfV/nWk6unWeLVNoufUruDOVLXyhIHHiTYte5ctSvPL0hQl2JR1LOWvKNnWzCOSaWVO5PkpA8gOWiSInDJE6AehqI+Db5E+2Uqk+2iQS9Jc7ctpnTtq14wua4E046te2cvKU/u0Pmb9sqBv9PB6tcZ2oT2f8NYIDcQIAHFzc3wCDe3ix2jSCEtlAArMvE6O1eyd7cg1K9vSdkYw5LOd1Bq8uOjKofl3PnAY0DGW+tu3grVXdga3Xu0iXpOtvz7IBRRzii0Uc9hrGXcTLdl3MqvVdwOv03cu0m7a/fstPwQgZPxFuf4KwCXVDJCDiIhGhwC+qHWiL1sdgDNeEBgsSMxQtxxZcqz6/rOhjX2zzc5wA+qr/L3Fo4spGjJfDQfkrNnwy5Ki3JoXFT9tW0VVuuee/tsfvP92W7CnQ2LAU5jLyQNGohGM1YxtO99wlbQhpwIlZHnSWgrqeCeOoWDp/BhgBWXAJ5hiHNn24rlh06SuWdMlP2j7S85A/RBhfutdFlmxdi5bVY9xux18YyEUMQExOSwjAMszt5Yo+fUlR2Guo1jI52zauWo8c4Rsxrfwv97D/xf6tvu3Z4daf2oe7+HnA9rWdvL+pFr+t17+rdvpcwbJ2C+gDXR6xPRH15MNbPOnTYf0IAACcAOAvAcAMoeMbxcvN1z+cBoBFoyOanUMMYRBu+TryRTroxXl9qHB/5JqziE3AZRmXyrnqrb/UDMIUxn2TZ4E+rhjIb9R3YN4bFKQAXDG4wwTAheITChAEiJkW3bGOgiUWIn15K67OZAcBQlE4O3djD4gNTASDAVGKogqmBqcWDCFM3q/quP1KTL21DpjV1U63dGrOZdXTHdXVPti8wQ38Cwz3GMd5z6+Z7+WxXgs/a5Db6etvunW717Q763tfDPmK5H8CDSQ/7YY/6UY/7cU/7xb3qt9mTAE4BH5HPjPxk4Bcjf36x4m88AHz2MeLhORcfD1+KIX+9HD9sFfhWg22OtR9wAOwg2NHAWbCzMQbDzoGdi3Ee7PxZFcReYaoqSnXFqakktQsFDMO4bOZQKT8LHezigu8K2JWzqk51tamtLnU/G9PEuiWtEyOMa0/nbPdg3AvcP2koQy8jGf+IJLhlQRvDbQa3BbatRjYLWxDQjph2npXrEnJfUp5LueDl39vwTEtfQ5lr2hygGXD3jPq3f/fg9QHcrzD9BjNiI6lD7kVgZMHIg1Gcs1SOmtrRUz9mmuef9rFX16z0j5/hCTM60RoDY4qMOTKWmLEFYw/GAYwTGBcwbthJAZMGJmOUdebAV1bOWcu7igrOXtFVV3K1wQ62peBBwIMaoQ8d9rCLB4YApgpMDRgiZurBLID1/4Ebpj2Qp8+Qz31APipIFUj6Avm6R+EIALr1hmbdqqResYSSvY56+Oah9ydYpg6URPYP3+OP6nEJd5I0nrN4+DXrezl1l5J3ssdzhf4cfB/QsZ8lu+X4nKzDOrLVEp5Nq/s2i98blkI+snx8pGqECgP+pSwZ9vyauUn/OVVaPJrkHvxsUQ+X6gm2Xw/4yEAPlwjQeWNh8z+TglK4MOdmdEPD9/6mk+34bfOEnoMdYOfBrkJ5rc8d7r79HuD9z4pvdi4wPqDWRiWOHKak1MxYbqwFPAjTKGvLUKNpnVbf987exJ4rWWenwzLFJtxy7lcUVZYhK1AfXXPVovWrS+/Kw5LahDtqzL3NKuvgGiCniNOK9h84s+cWwaZ45H0+WEWmJ/ASEyU/84SwipyAEEadXyCUuc6vEMbc5DyEM3e5+FydfQ6YcwXbxuaqg2ScrhYoxuPqfjKMz9UHzQRdI6x6xDUFe3S2D3BNzPUJvkm6XiAhUMn630CYtKsI0GR/rUFpbjpPY950PjpT4nUYTDXnIaNp5D4s/1PY3vw2b8Bu6/EmXLYBb8FrGzMRftvMfA0uzDVC1R1Ex0cyzBfvIn4Pc9kQN2OPsjIRvI/UPYoPyhaDzCzvEDmo2MOx7Hx5tlmBgiWxGmUz4GuAlsI3qFka36FpGWxGx7Ivzvxuubz1DNzz2QYhEDJ7wS2/74XsvPL3EvZAXAuyD+JbJQchjY3+asMONL5/aVMN6UGw2jv98RkKXqK5xMoWdgfNFw8QJ+OB+zLPjNruTV6AYTvhDHkPFG6HYMNNE/4CSDP93vv56ZcCU6TVcAQampjTmStBKNpiBK/x867QtW918UjMCvMWE0FISiayUJRKcEHhnajcgIVVN3ASmpimPSNnV064dbny9xZ+gyjW/k7MretXSVy0+om9v4IQH6n/NppDiC40xNfrEokpDKUTR9gAiSdcFEggfFhIJMJnYGWbCCkYxdqQI5fQ7raGFZziCS/bSiBAJNi2GTeIqF0uSsxbvHZ0lKn861UOqUQDjJ2IEF67diWVR/qKCgzn3uskQPVm2G9z4n8jax5jtsgkOhVtt/jG+fow6DEKWIOwnx16jtqtbgMBOdzGYRy3xZrDYh/MtulRdkBcEJfcqua8y/lPXsrPj7gX4kMx//s5bj+EoIA79I+1GGH9LEooDA5zlGnlt0hVxJEopKSEOw6VySQpSGOFZf7WRC/uDGShVxGPsufdOYhBxbKZihRUS3Upq55aUtNb6i46JcHBvmjUJNace1Ca4NuhV8vYR5yFLHYuna5kn1K68mcw8TT6kHcozQ3iGsMp8GNmJZqE5gCaaWq1f8rEW7Z/iwsiuTWZw+jWZamOnxuyUvfPTS4p3W05wPlJNJPrdqq3y9UuscfjSVZufVVwsIFCP/cL/JNhYQVpiFhxNICGJg3/PChofZY+qglHX+DlqBUTxWYcsOmvhnI/D/1BflLeRe8A1FzN42NAi6bUw6d04oLVipMVPMoIkAWJ5zhFQ3Nz6QGFrtahs5e2nLoQGHPXhQyauN1GY7TrbgoVcefmRmfcirYEUd+hu7A+6/ALNrHfTPAtpnCQcTDqJjSeXbcA2jfpZ8Zdd3P8att6jq2Ri5tnUZ0WDFNQGtf74OxCPafdWzoSFLGOhjBwtkhiZwOgn7PlFsMHW+WhlEBQna0d7GFbbziow5uHVB3yMZzXBooFFzBx9NxtcMzOXHg68sYqm28Oix6b+04fI3Fr2oea4l7HAhUYM5ys/OK3toHtsDUM96HQPb/jgfArc+6P+gPOAwa2yvhk+OwT31997Pz/9zKwn52HKnHfNORsQVfxPcIp5o2PWWStypfK5W80yjjpf3EqOgEhp5o9Vl7Ted3JIMWbTgUjPo/Yr8473tz5LsKel5g7HTpdPK/KNffxWnRF1nzdvq/HaXNnIFp0/nJCDPP2Se5W9JS2Xnwlwk7fRNdkXaMNTDxtAzHoZWogRtxGyepC3dp7wBkj1P8rWLqY9HLAjmkvDyln1itoEOTOHkVm057Gt1+eq2+mP+b5OUv5Y39oi834jH+bWOWsuWQVO+QVQUhuN4qMe2MHMInVNT5hsdHlzw5nG1LgmOhZdzdQQxsbvAfs+V/Jf5sUcHPPFpSTWx97Mw6Rnr0qVzGvthQHul4FcSxn01PSnX3XmiMuAOd2qVvPnnWUFfutzvR+YEfoLH497BxasxwPlUg8wtbuJ0TXQ2fj3lvUOMXZLSJY44gTqptgSBifAbk4R8YI6xxFwnUrZEzb3QF1loEn8ICokrMy2No0Ez5A1p1E3ZSKJtyjbgn3PU5dK3/M++sjqbuhsrOtGLtIG/VCkP2R0gP/bghfBDp1tt8i/XDO34B+blT+gOe3Sr83Lofvt3auueBv/Vx3kd+3inWx3ybgXPK31bfh0r8dvs0Rdf9okP0N+bbc2++Aj+hKJQxlflbLs/nXz0ZJQNuuXV58O65XXn27blDyUOjnuBQxd7NSmXtuUeqT5b5Ka+57WOlOlkeU/jzwqDKahx5TplPsceVjyvx2+ZwKTyrfU+0pdW1ee1pdV8IPp2dj3rChRWFP0XMrcd55ft2ZZi+su9PmkNS96XSAlTU97Yn7HMq6P4MOTT2YEYeuHs6Yw1DFM0mOFqOVbFl9iZtp23Wuz+wjrYf/OR8Z/fmf55HdE/98j9z+8i/4yO+v/yKPwp7/F3uU9OJJPoK9ctKPyl4/2UdNb523R13vnlIy9P6pgpIlo3saXAMQJKM22JUeLavpX5v0/KUCvL6BuZbs3unpJZf34wxoGrk193ixf3jGEbiWUDJX/tH/y+ljYTT6FXbOLHii/wubq5RC58+T/7op6haehYX1T0NMce/3+Uqpv2sn8pj5u35idkCGjLOq7WZsAJdyfzcvrLubPWRxj25s4b6da/zpIEY11Mi9QU9aDiRA1bEjx66myiWI28KuCsKlmVA03Ou/8nYeoUivvJoKDv0u/EigN0zlsffJT7XB+niL/H85+f/ug5Ga4+AiUudnEECl93GoAm2rF1NeHH1bjsapQX7Uw4PvoXZyeHT1lqqYJW/3qGf1pdfdXZ6b2fBez91se/9n954PecxzIG3d+UQ9sjn2cY/TN/Mpj8e38BnoF/WtnvMEn2C+UCNPCF+eVqCohlt01GrsCeWbNfmE8Z2afsL595p92vbD+gYxKl9XelJLi+TntYqQY1kbi+JXtb1oAV57ixGQdbDYAV3Hixuwdaba4iw+givPYbBa9bI94Ovi+T0Q6hcyD+QGW8JAbYglCfSGWmBgNsxSBk7DfaCNaAJP7tLV80EEQdtehiBqpGUMQKMsy4fQwHNbXvYHeWN8IoKqsZfrQdu4y/ugb/zlf7htwhWC5hVd0QdTk6z4g/UPuFIPjj/KlXlw/9GgFqA/upV7CPwxLEsI/zGugj7Ox+6SXOXwvP3jbTDxx7Jq/3iwPzX9qrmeOuHljxeKPrz+8T+9B6CFniwh/yf6NAzFFn+ahErN/ud+qLfU0zy0WuZpGbot5yOaXisg16kh9Ft5rUjUNvxKNzcyjFpno8O0vW9s+GjDjQ+f5WMTwnebbHJca/NNjettuelx40FGlo+SIWZVYV0yKGk4xHc7TYZs6dJ8KJB7XA71Jbnsn9XcenCJaTWuLyXDx82lZeS4u4yMHubLzthhC3C5PpDxwxngi5u7QsvuK8mE4YFqhEIMQlk2mlMhofJs+mlc5OELgIXQ9tm6qCPoG2T6iASUmTliAU3mjGRAl3m1cQ3UjaSheI99XIKRDRgVgyM7r6XzS7vj2jN0Ye+6KFhCp+i83h/huswubBEIQvf6k3Huhkayo3kIUrVxAcqYL5IReKgzEB8IpLI7Ek2/S3RhZzoR+V5ABsZbIOcKQ7A7z/pRXZTJBE0LSj5XAqKVg24h346GAnMISvwnzabRvrVs/du7zXkDCUcTBWLM/XLg79edaLJby6xbbqQFrAJWXLYJbic7/g7MVnb/Hd93ixqz0nPo7+IOT6LHUKirzYDoikicBoht1lBgBfRIIGsK3Qm0klk3YFgcz+Lhp9eFhTtOa2XxAfeqBbpcGWDyqwBRRRgiRrAED4hhiCj0saajnJDEKy4gk4+44JOd3C+ikCLcUMl3LqOJAa5ginkCscgK97ErkH1CpaGsGKQpRyqModgFDrAZG8OKf1EXbnAotFoVTCgYoSeHB3zHjHNUn0k7wurQL0pqSsuU1op2qKp/YlPPECiaxy1oTZ72cZvzqk/ajTd82SGMNc3T/OD5LLAnS1liX1bDZn+5ubgh80Vy2XChZ2ovuZ4tXgp1Lp1KU9BCRo/5slLsTK1pPZ/Z9UcvZnfjAt9cboSSKAYam8CeG5nP9rOaF3nx3M6rvH/u5Ev2PIvzPfufJd/cm3wIet8fsEJVWdGpD4FOfQ44/xvo1BeKl4ZrpU0gPgMh9ENioCn310C/dNAfA/SP0YYt0H/27+9wDbzfH/IPhx6IPik+nHpe5pVy0xSeU35e7S2a79R5P1xHSHBbf2FghwP64fHeuOEb3+pGAFduATwBA+htIyAYARD8HAAXQERmC1CucR2c2waS+6AEPiWAEAzkBniEBJEAn/hBNCIJGyQwMUhici1IYQpSRhrTMchjHUtg2JBDACwAv/HZCCQEvg1wxgWQjo47fvfQE8+99CrwIIMONvgQQg419PxdMsMJTywQi8SAWC4ExarjeLRivfj2OBWT2BqHM3EHSiDhPDuXRF7ymnyKLqSSeloup+u40mrjUuMyE3Kp0HvT03cto2qqX7o28pHPfNdarddmbRWxDk52ate52nOzWLWfDkAEENgVMEgSFW2w3cgOJ9RwYRTar04Frjmq8L+oxquxHV9lPZ6Dd8Q5rqi4wc4QKnVnz1xRl6vQkOs05ia7cvuu6ITlgaYk5KXdSfocoRkCzIAH3KUEWi4hqPSiXrS+TffjVNFAGz0MMMYMC3wRRgRRxBDHbZJIiT8/jQyyyT3iHwmPJEfgkfJIc6Q7MhwZjyxHdrropZ8hRhlnihnmWGCZNTbZ4TuHnHDOpcgiCCs8Ld0fn+E3/BkAApJXTgFADF5Q8QCE1jN+EYI1EYZ1EYGNXVEUDcboKZigVAOOgingItbFqNzF1cBnPbibzB33b2vgVr4v9fVNv4kLN+DyDbt2nyfsJsz2q5Xf76uHN+/JLXp+K17eule3FfjtBnn7Qd9RsHca/P0I4X6GfL9DJdFhLehYDyY2goPN4F1sheCCGKKLnQAudkN+sReqC1ZoL/Zl+osD2e3Focx0IW6zrZDJHFB0kHfphloG4boawM0duHKlwriTPcMsS8AWL3DGKzyRhy+KCEYFkagjFq0XaJ/nwAs+7ozuG/1Mimn0sbE+a8MOVjbpR8/WUMp1VHMDjdxE20ZSsLBJXG6hFyMk0TyZRAxyB+Oc0WIJGy73sEgWvuyGhoxP38ugv/WBdHwi++vi7eMqKncQ9REFTETicl8Jy4OLNTR2dnixi4EoXe5iFt/YUaICo6VYkUdJrETGdVCBoPdMNoYUSgQXNNE1qVYk8lqJYgTFZpDFN4pu3ikxNobNStwYsnEbfcAWFeuonTnfd5S02fSQZBt+5qWPlL+ghoOk+QNrVPGl8lSEjIyRnUlyLar9qCmbKoJApOJ0OEdafMVM286y5Nv96rM3Cs9KlJxVCZ41qDxrU3PWow4dvNrZgIZj8oHS8Q4/PYEWHS1YUWklI9iosK2eC5jpPdmC+xjrkhzTKN/8TA49/9iC9vyiq4yXyLJcolGdiZZeni0H98NER6Rt50p20bPNeoQp8nXyXcdmz8l9bZbTs6/KnpkDhfnZOVS9IRZcZ6SmAaNI8ujMN9z3yMWet9QESRJzz8gQbav1hihbB31LjHFNweitlDgMCnL7aC+cxQv+y0OYJWuwiGx5JNHqihTzdeQKxeuoL8TKODxS8WiGed3r+Az5tao0N6rq3KkaY1a1x+ZwJbCuLfBu43SvBqrH40Hl+DzO1IJN8PUrXUaFDKn1cAS0bClSjbYlUmnSpFY0Vxv3sxPzLGdSe+j5SY5w1HsSzOEeutZM2ouxrL8kLfX6JfM29atg85lq4YhmsoUn9pNfEJ8vEc1qrLcLAlBwYIV7XIGj6inR6ApBf6EY2mSQD1cYRgvHeHO1zVSRmNnfWRTmisZCMVh+8q3YrFl0xVU2i6/sPHsS7Z2gUPleEuWwQOVkllTZvaVUzkujXJZOuVp5g+ESPtWDTeM+w3Zhn4AUwjvLJXx5RSi/yNkRX/+1QqJWVPS2en3ah6q4mG1SrU3vMDM43Ixve2ZHmsVR5utoCzvGIo69qONWzpOLOf4P3Al/bJ+EDYmC/H10SUgu5cAftFP+YJwmB8Jzsl7cD7aoHfYOgieXe4VZ/pXuh/DKcGfND8mVUb5hH7+yXkcmd5vr7MkFryw/lFf21Vy5VmR9Eq9c3ZX36YOd2TVc+XPKWuK2NV6F0M/WUg6VecISbxDshnjeyogH5iQACxKBZQEdNO+smuRgUyqwIy34Ln1MQ0PdnnHPgROZwLmsK4KV+NS9Ca7kbrigRirQaIXvunOsnhuvRL6lc82dE/TSZL3aeuc5Vfmmq9hMVZpDjQ7xLuv+kTXngstWiy6777SvauCy3/LLUasup629/Gj95afAlPXt5Td3sAI7ZOPNdnij3d5syFsdMDHGv+5n73bCe/1iVr96/zzvg/OiD88rFp/XLUODrzu7hbfuWnHet1r0+teMfH0+9c35h+/OP20+/7aNmalZsxN1jshm3Z5ZvM3AYmu5is6xH/aLr8Yesdm6LtV5Dtx6L7P+y1WlbegK9UMebKNXtmMbv9p7ObA+lLrmp+CxzVzHP1eJ9at+5O59Czfc8k22dvNt3rKa3HZute/ICbvHcxdm/cyw5d+3xN+fbNOy1LSqz71TAb9RBnkJg75QS8x2SI7J4DkODlMQON6b8k47J1BQOZGCzgFMEY8p5OSojXF3lSfewY6GUyl4ai1TPHVEydNuytX6LOLZ0atvFYDaVDNvOlgIrbYyqh0sajffAV67S3/XpoZ0qwP61GEjBec5Y+kQCGgK/RWA/8D6lEfrijldl5IamgMtoDbu4hsO4SUshs3nl6SEwtwIqQFN3zLrfqE96HfDTTbd8rXHWBZjFVZlbdZJTWGum45CPqqQR3/Iofcd/38ePkERMTlKSst6U1LV0H5S6fWsB8ZmbBb0xGkRyYZsijWwZhZnvSzFhtkEm46fMAlzYMo06TJwZsySPVfenVQE6jTuDBsslHmAGQAQgohRsFxw2yDxgAcbH/GYsb6vxAQz9u42y2w95jry832vulel/qf9QZmEmrWvfgyd79Jb/cF/NN5em7EP/WE3JafkwrZ+tGB6xfhAkqdZWv1HA7VjDaE0bGpVdfI0wki+xqhU1zTENCDS8eI6UcLJX9KpTpNyhjNlnON8OXebknuVParicTX+m3T/tWabo+7lfjSABljN+6i9Te3Zf3W7by/FnPlZxlwBBwm62cKChwAZKvSFzYQDTyp40r0+IdoWBpDKpSqpVqqX3kpNUisO3IWYEAHCPF+NTdIEL44F0lfyFKlQp4VJMlEcumdFH/pIrIKtPjDVD8sNHgSE8yOfPL8q8X1zgaCfuXRtaosWwKJXA0QvreRGe3iOntUMwhDAGgvtJZVLTdKp1i6kpXVtgMQBXETtnCV66iq9lUxQAbvaO/PVOBdL+5LVhSYoWNRPxS3pHeUAQDY+SQdx+VTlCYwAZgCHgBiQaQoDUBME9gBMiutB45Zwf2wB/klq4Bq4kWKBwOsOMEs/ZIOKHHDKYx3su6QGtY3gxJIPkbQStJvwwXNsEAXW8MTbvtLP2tvcmsFTpeesRL8DWJez5lR3ajg16ifp6lPLqb293mWv/dw6V+xwqLPTqON+wSRrJz6pvxiv2p9RkMo/cOZoT1POOOfCp+a0HIlFZuO0hvy06Y7fc/uhJ9bI+S/3pVeBB6l1rCBxtwkae7xggw8hZPQMnkDYCDX0MMmHExw8mUAmkgEyufRYIvazDERFw+OWy7QyvexW5tcH1mNVIsWVWnyZI+7AfBmUwMDNC+c5wPEk8pL3zPkUU0k9rXTT9zAADnC+D0WvMooyIJuCp94BDdA2r+wjn/nuWvTS16O5T1dJw2iBiGJvJvmsNH2Wyp653lRSVQ211dMApMaaaaF1z+ZY5tPfp69vS4YZYZQxxk1mct42yRSLB5lmhtnmLlzhKf9UCBambAmwMbVpTmfejxIQg8OZzJwdxMmZu9NowOWgyIdl/qwW3ofU2M2GbsPxXRa9WPq4CbSCxEl8WiSHFiCs+sUvIUztktEe9KBQCtxElxCiebbr3egm9W6V2B1u2f+72z1LzljdPzuQOnD08Ex8JjtTSN2f/qqBRa+lo96c3Z2Zz2x11oO7vgYxnUUybazJppvt26m0pVbbaLu9DjrurIt+DUzVbg7C24MKFmZw1CdLQxrK0IYx7OGeckE+KAQlIAgqQQ2oawtnAI2g5RRGfuzjGu/4kYOh1z2I8MyXuvTP6ES7s8zlnElxcREQyALLO5VItR9aai1i/GkclloKcJvOBeeic+Bcfq4613bs1Z9t7u35o7Xi2J/BvdAGwDM83EFVPu8qy8u+bn6LW9n6aM5ba93u9kcoX9/RU0HvNAJUTFH7sZ/oI4DzbwvyUd3CLbZK+jq5f5Yt9gz6rDy5DFN9VZ0DwA8C/nD9OhHgY8Z8mYAbPCwRKnj0g42EYR1+H5lhE3EucOeHW8d1FJHaLleHJdbZZAfGtl+qjO2RivYEAjCRjvq/UV9/Ck7/lRPgDEDxP5wDOM6DGxyBB+cKAvpOdlPaTPy/Wp+xDzx47z8Jf/qsP7nn+pX3NoiRJE2WN0pUadCmx4AxM1uo+8oHAwQoMODYhgQFGgzYcOGbcENioJhSTHOEzhhXMGA0yzF2XHjxu1D04oNF2ma09FFoHfY4/jgw2tgn4yTELbrOUuflylI4ImcFu55Upkfo46rVLPlIIuBOjzIwjEbBIEnIQFJ/VAFjjPWK46brAVVAkEY864MtKclljZGoScueDWsKHcZNCTPT8VIYJNkGYRbhHdRAknwlYciknFvc9pHs7WkRwT6h1JRQvbugb9BWZZ+hONR7bIdK9HqogitcsT59y8+ku88zeIBUiIEYYlRrHQnxUIIiuNqqePaLjpcRBTWj1UVi/BZoT9I2kQVGE2Y3yYu40qptsstCxv0q8ixVFOHdKffKPruGc+GSaMRcaaJYK66aiWqKzissDeqeSsAM7HuyyXbhlcROrLd9apLV5roCzZY8CjYMvxlhGFl7Ki8ZHWMew4GHgGwvspgBIBdVRxstINpeH8tVbjMTWM0xb+HG14qAhIPnMjF44ZV8UfS1UtH4XObelqvXlaQqGrTpMWDMjEX/lakv0aqKFAF8F/2yweo+8ruvNlxl1d2srfXpTh5CBYrT1OK4yHX2ebdtN0fsM8Plcr1tZp4eCV9am+al6qel3R5tr1AlblGEb+njR/CYFh/n2Wdi/4DvN8+6NU5y68FGv8njqq18J70yYno75XZuQOuu193t6vY8i30O5FDIVcxT1DoZilL9LhS/9VqmcGN3fWDuEFj3mtn8qcR6ZH2d03e6Lp7A1wezlotAzJI5kfzStHbMuLU8CtCM8Rz0HLli7E5S5VuvXnqj5c+O+/4the/igoFnNf7M2CKTCAMbYTXrvfJqPc0HKWZ9MPfNnebWZ0SH3byzP4DGS56BcMUs9aDUeMKMiDkvE2Z/2gS1SlcWTjZW8856kvnE63opFPNthGxx3tO8zpflPn7/jUeCbyU3uswDXP8OvG4DDZMCXB4q7V7ZTCVzXKrlK1NDudHMNiqhrF43xkfFJVMaaMdOrx/w7rJ+TnoSO5YcthP++glIEr8PeN5fEvAZu57g1t1AFRj4jr/owgB8BGAQah8169DvdaVQ+xHnq5/vxqtfIatlrWwpW99199lOxriNlaRYD2UkFwC0HZS29/VeDhCPETefxgAmeY4mU/JUZgLiKNFX1QPyS4NQfAUl90qYxAuRsPRdSRB3JZmRTP1Q+M0FOjRd6RN0EcqQmisjkq0Yei23XipckDdBAfqn122oRH04ZMu6xT/UW3QQIAJoyk1lU606SCSRoYdbTGbVzaHEjYckEIR5JtF8sVcf5CleWIEpBAr52agjphedwqRw2ub1BPr/FVEMFJpipFhensy2b5effZSRx5Lvc8j1vNZ/uJeM84jcUh9A3hZEwAXv4PuNDAxVWxIkbUnSsyVDw5YcAVsu0rVUKNPykKWJ9Pbp9fm9DxrWOgSQcAA0UNPrQxXc5z+qX3TfSxvF9/0fQD3hnbDa/O0iO5S9ZfF9K0sfMgBGM4541AprZpq/aqkInSokqjcWci1rFGO8Tq/lTtYuzn2XDfS2ENAgAYdSvGY8DlnKj8WY0OakFLOsVwaJzhNetMskG68an7WrpXeKqxD5EIf45Z8ZtJBoUHtVQV+DSCPaH2ZyLYMqIfLKhzQzflTTrg5KT2KUa8B7fwKWRvxyYr48HHDzWNhcboJcc0JS/0acCG1qHY75kXmjX+Zzs4wDbcL1alk1+FjcwHSSAHVFWt4kS7KKDtIbLpfqPBfOFGMb4en3RmKrRySnOLOD4YpfiB3eNsJsmG+oHmXX8f7Vq4/z8NX+OL9GHNWElvKNGgs3bnAdRbdNwtQfFLwenPIsFHUz8BbqZ3ioGmb5dGuZjTNu1ByYOf1BUGG5UhG6up5VSOj/0ZI0uoOCh1OKkyl08vACuyuT5mnhhz4MLm1GkC7CDBDL8FIRp5TnbM8NrsNnmJ0rw1tVqE0q8/sUBzpHOfVpHvX2VqjydePfqKv/wi7/b8GpfbMQHZMvsVySXUMov12dFh4T1in3sqI1V9Jou3lTMVfzNDcjxGfwSLmA/CcLz2lHu+rXvc845z7I9r8vfi3bL/w6tG+Rz3O8L8sk3TTgw3Yho/l2dNMYRRyBbVRl4av90fXeFdyL5kcuqavhLy4ZGyiXcKnk763tV3WtOePwuLEjHgMwejm8aQ0plY21Tzmt1tC1okM3RFXX4q2VYN8jePS4RmoK300ReMuqAlBwWDgVKtUgIaOgatFv8ErvTV+WNvpbMu2e1k3+m3OWRKSspH2/R05pqYy34SybBGmUA+Qpv0ehisrqYhmZaSNVIdWqBYiqAzUDrWKOaVdHoZNueuhlYGUI35Kdgnf0y1KiKM1UpUWQjRzyKJx31qKqkFqI1KlZj1a1A530MNAbuoytW/YluH3AT35HRRvVMOmgu9d7X83kq+yOMOeejC/JDvJhfhwVwS742upQMGmng84Pu2N+ujfsNnYKAu/3pUInkzfqgV0jkLSpKhnfM3vKmOSPnU3xOEjgUyoWxCDFgx2c5CyaSunpnxrZGRyi/AxPo8Iu09TNtFo0zJphaZz1tlgzGwe1zE5om929DFAU1x3cSuSp2fFYJ5+R40rX95+LD23wXT/Q5Ncqtw2a/J0i3cooszrKrY0KG6LSpjDaElX2l084aJ+5I4ERfn5dAVeUtg1lbG+hrJ0QytltqMATFe2jsB/AB8gPJAAsCCIYKhQmHC4SIRopFiUeLREjDwsBgALCgODACBAkKAoMDY6BwELioPDQBBgiLAmODE8RAiItSQlZKYWRmplGGS0rnQp6dgbVjGqZOHnUI5rYWlBtmE5cN6EX6Cc74mrVhnanMjH17MAXUSGulm7s4LjIs4DK/WgSqLXPJ7ja8tRYedTJvRMNj9c2BmDiSZmbLTCs7BEBEB4YNBGBjYGDCQQ2IjEXyxB8keUIYR4rcB3/wUrci/sQdUDxeCHbn9/i+hes2f+e/84dkE7jn8Lo1ukiCJ732yIMIuWyGdDgP6DBfwnq/oFAg/+BzeyVDizF3p9tOJYJMu8BZamFsm1xq1zwAAkaLHghTExTlLxfTwcVg9ARJnDgiaBTo33HRySARI6piqq8zJ5bnCWXFvTc9qZ+XVaT8NWxd4RbMxUhANg59r0+//2wxUtd5urmzBLjgmNQSBrlR5RiEmeDRlWE09CbjPYW/XdHzcEeMz2oR7jsMXJGLrnGBiUkhDGfMyExpyY5gFW40BisVtRavah7+tjIErO74UMAgOfIvnh1ej13y3vYcywumMVeB0DRa/5G76Z3zffVa0iuSFRPE+l0DIRAOYNWCk/cqTx1J8XrJRv09l8flfs9nKSCXHbssoHl5MAEH5IIwxb5fGN3kXIvQYmVi+pb8dolmhW3PBAvMRickHNSQ3pqYqYsdforXK+2cB3NqBZ1Uq6I6lkqk6TgPngDr03rwMZaVV/zZuYd6cJjUAEKTyrUAXQl1t2bzNB0X/RxBXx2uU4Hr8eR60sSbBqE4LMtZF91IfWHIkJCMAdECshQCp6mzFFf0Na9ti2v3x2z7q73xUOkv+akhmyWWCR929fL5Cgrlr/EonjQ69ojWgkEIvWrxfdKCgIp0jLRefbIs1IS/eCJWwubfE6hL6lTd5KnhhHjSRGIEZBy6v4mMu6XhHqTKbp1/tdHtb476vTNUbnNR832cdJpLjsbqQUz/QURo/TjhIaNokCsI40VGyvKIE2EYbx6QQJpWaJI60IReaJJJTQ+wkapuwuLqMujk8pEHxE2JMeEzk/USHIQ+9g0JR/hTuj9PARIa1IBZL0UGuNlKrFoPt5bDvKtOXlUDC4btuuN7accBZ3CRj/I5wXdPYtPWd67+8ese3C8f0LA4HjOPTyWnYqPFaZqfY2Tbln41Hsm3H7LM101rxYpaEARtZ8B+8fpeqHw5DUikPMEbkWtNYm6+6rPzet7mmJOJ8g7+HiD4hqqWRKWDpKFxJi1ka80c1vB641CE9GV+qwdICpzpG2GfFZnR1NKDR+Y68feYbRLXHa1gjKN1duOvfqeR63wPdIKdlEjBc14lxYHkdxoXfFkWQBa7sUrvEgFFqvnJauY6ek8UaLIGKwgGRXihAa1BzUB7A6cdO2yLaue8IhVDpt5617F6bqJd8M7GYWOtahW+dSSclyHUOFQiaLGQQFfxuE0FLiabVoWoEGVi0H16My72CIVCfyDQJ1DTWKlxz2TtipRaxMacQlVybucCWxQUVZ9WlXUV9gOulWDR1ZJvG6rVxMo1Az5dRhbgrF3mMITByVhWkGihC2TSK53W62YaHPEIaQeMaAy+BMI1SGqxOaLkG8PvqMZmkHLOJpKSWq2sYR6mQCAqtcKYXSoEUALzexEnUBkEBfqRED9DceR1ArEaVUJYOdd/6qqlP0ftxg7quiGHVQ6mnWBe8Il6vh1Yr6wlMmfLFUVkb0Ck9u6Tn7ENpYidTq6b4+4Ym5I784Aga6vPnX9wBFup+mINpAofENBXvPKjllXcbx/QscMnf2Jw+ObUzW7xEtidu23N6+/a9561YiDN+aIaa1R8SlbE90DCENYgKBjH9leAjoscUSSamYQ05nnQH5U8GXc0PtHGXHQOjzKtfaPCgcOkpxHRXwuxbEmI6/w6ieysVkNxbnU6c87dPsMpX1OL50kE+bMWbKc9nKrhSnmjJMRLSdT+OCzGmEXV6f2+8F3dFmyZrce5ssz7vXx/ukN3FXm5+5Ody22noPn1cfmN4vmevWx7U7nTTrig+Niao4TT35+e9+sZF24HDMuZdnBBH3yIlXOzwBskRBSpJ2Gw93u0fYkkT/nl9xQERomMSOSxBAprIcUr0NKaSDpKZBkcD43IEn2dAcC0Cu7FIG+6W58+lPiULCdalLG0Q2NCiHoQ4gDJ5J4qCOthNIYMwlMohqCXmlOWU5+pLq/hqLVKYzx2MnwsR5n6V/E4yJTB3s85ezxnr1y2aSP/yp2+pE+l6DwpBtu+FMiTcnTZZrmZ1Kwbz8fPXD5DzTaYljP/fG/jLv+FArivBYh2X486scSx3eOk3BM/VaAvfZZHq5Q/TYDK1ZfLYb9p+YDMAwv5QRQqDWDxqlxDNjGsebg4QKIz/HwA6KWXbxUeX7mJrnjn2APCz6v9TVS0GkhJgGx+oAMQaY4wtzOIFggLGHkuQctCS2w1xZeeCUvRahQl9bE8E67NK0QpJ+QZSSZwgef8t1B7d3xOfSIClombM7pXC0zanGBLFZgi4P+7L4WN0wWr/e4MzxZvkLAjeBp9N9Dyei4oY9P5a5yB7kbnIcL9+188r2nl5lh0RkXn2WpJ53nPhr/r67lfhQ6Sg8lzi7nQgB83UMKrttk5utbp0SVhm9bz8yAcTmbWbiv3MEcBCgwhlN+GxIUaDBgKzdEZ4OPEImBs4Ih01B3SjTozKCb0U0tqpPYly64TCPYjsUvXuPa12PSwY1vdovjvR+ZDJOppCFpTuJZ3iS1v4uRTDxNhItPSAKkpKFjYOzNLAt77WLb73xefiFR8ftySs1+Z0ZOQVmtklWsIJz/UOHsKCKF7mhiG4kov1giyRaafTNPSbhNXNgJ7WKnoUtSEDZDU7OdVv9/q1SL8NCYtIuN0QLdiTdXqxpqVO7Jp94PDt2IgXhkrGEd2ay3Yptq4bjwrd5E9gQnOqAjF9U6zbkWAYuMaJpwtDGF4QQ/y3yGbqb/FcQD5dPhn7Q4+0lSFoy8/y8HB/J/CrIqw2umW2sQuLjdH02iWoqwvWiS85OXqgYOtN7dlTPS4J/w3znB80X2hgcK76W3Hw2gn0gNGNxr/sXOpAcxqXTB5rFTaScAfUhp6TFcl9dIronh5myry+5hGNyfgRtH5ErrvukIAgfceWBdICrjfDKHRVeXK3au1U4DJ4e4jasydBPth8nRwZ6azptHeoRmfldletwxZ4b96T4fTOuXvHsn+/eohGrR9HRAaaav18+icJLNLVMCZmSZoXbdMzyCanhkJnmDc2Unn7NcO0ZVQ8Z/h5DLuKgDxrWxBbrjoYyCDD4YbOt3/oMXA3Hhp0t85OS12jnWDvnLC1ySVlzGexh0V13A+6Q3WQFmutjA2VyJb/9oCzn8hV8OGmBhH96zY/x4QhuLpUU0jg66ELsNq8K7hAyBIX4EYBhMxOqb9W4+sU/1XzzURS+1WIXlGuwU8/jhcLS0SFv8sB3wxdYP48NV4MmFmzbZa0/n6Y7ojpFb98AZWeD55A6LGbxf6wYrFc8kpP31QsLljnLtxs3Z7cO/JVX82XavdUS3T6kPfLVnQLmMrPtM8QM7OIMxrjlWecHR3AI1JQ0W0Vu3hiZW9CdEvThLlpO+ErDa37yTCz1NI2PAJI0fHFJ4uwq4yzAkFVsMHsjJEXl+jRPCDGuJL4N+d+J0bTvOg0kILPCFUFBpTn9hzb7d14p/8R5bkJAte3A+47fw/JK3BGMfIHOLXmpqZGNcNURFvM8KgAEZa3JbnTplxs4Tc7zjUKmMHfzCoJ/Bz+9P18BPnOVqdjSTdQ9wgiutaXfMHBDjumoxY27uCgjy8EZt5baEPJ75Gu52cmm9lz2dxa1dDid3HWumNfA/eN/Uqb3nkjygXHLsEoWpQJLojtF9/D6Nn9j+zg99xfDwxIbgWnpRVtb1PZQzPW2DnWfMGo8NLpz/ZXDOvF5kjrq+1l4PfhQbPmZ9MILNdp0z7bscZR9tJ2jrJC4wfSvIMxk4/fsa7frr8rulF1kx2hpIJXKKa9wUr6DXYDMOYsY9/FPOPvzidIs9Eq9oHyl4k/feI/45fvHTS59tdD0ErX7A+lXpF+l3GkQqiddw7nNejCfj6fWLP/DP8Zf47COxKvm9W6e4YcE7zwe+Yeb+xFQRIeo7AOZB5X1PLy5zM52V93V9s8wTfBc/wB/k6eQ/6X3tPwG6R+OO8E18K322/HevPw2WyqWY1C5mb/875J/pJWXe6Hv40+s6Q57jhrORowYu92FaPjkBeLA/cBNeGvywWYB+f/zjMvdDvTXYsqZn+VPVU4bcS/mZisdTSGjgpz6fTi3c4L76qX0NtZ6K5IVOey197HjWxZOTkT/V/CD18s/0dA+i4cuws+bU0QPk9Kr/b37Oz2PhzCx41eY6yyfyV31WddPvpKCtND1BxovVh6KWZBnJTVF9LS0dZBCVB7RgHDoQEWLVCqUcE0nEAiop0ylDWqUoxRXXtV8za5qa2z64TP1HaxS4J8jo8zRu5jyF9gqSiIeWfhvHXSnW7hzAjmmouYrxFlNTtx4W3a+dce2LK1+XZFxllJzSZxl2yQETdFBLHnKotscROk3paX4iWyLcNkB6Pby56STI8pqOlSu83mBeOEh+JSPMcB4YcyLmABq9UlA1BTFMJQtphfsltKwrbWbofts5jOFZk5nyioV6Oclp6rTTmh5X2DIniDch5LSYk8SxrZOHzBAkW/KxBnHfySxgNzlaiHYAnuBZSLnkKVRWWCISl7aL0IesEyU52bTvmaOUlE4eerLFnYFEdgm28wKltdNR3XncPiZyPAqAH1reF3/7uCGwiGghUmpeLlFyhamNcD1ST7JiSiaoilN+RzXcrtryOEjcr/kszwr5Bt6tjsYJexmtsVKmWKFvaMfQweeugh9HMe1qS2nlV+5XAD22UlzS//dEr8d1//pQ2oknXEoYGHFH6IqQnUmRMFkCWbJ/S2BVroPwdjNNIm0pNj+KV/o6GcE+fvoRt7rXmltELvfiECbaDtYgvWqdc2vC/wD+g7wMsCF5tcsfxib6nPp2osCosCWoUGI8WHHHEW2lsZm4SDEciScyvlmwtCB5UPFyl5rK6+SZnCoRjtZgNNvuRM5lN2V2ZZFIaUurHQMk0e7AjcoooaxlazvKLaF3EWFePMHbjso1vg6ynrMs5RH7ESTbkgAUR6SPZtxte9iJFe0HSSzKnbRxe878yhGAiY1wDrF6Kbvva6SSLPOj82Ho1nR9Jo5sM0t+Oy65zW1tkBG6icb+5seddVHaFSdHmYeeZkwcY1mcrD5dCnf+Juswuiao6rZH4A+9aT0pPH07VWgyHUYdnE7sc1sjG1eNqowPrwSzjn7NK3pwaKaOZqIzDunDM2U4OVX1tm6CZ4U2y0ZYRbytVpN5YtkjIcGyxCrrPkJLq3fgoNFyAceRRYYa2ZQQVrjWugdorzijlU4SKozPVOAEutmKiU27k6Pdra5qhLh7IImbRWzXF7YTtiLgMr1I08rpqpsABv33CuwhaJlIqXm5hGSZqY1wPVJPsmJKJijFVfNRFe2h2vK4kJV+zdfyhMwNvFsdjRP2MlpjpUyxQt/QjqGDz10FP47SdNzWpRmvRD8KuEETjYekTUY4hoHETWgReo/zlSIYS8CSTZKmxV8Jej+Lq4UMkePejgMmYtfnVz5nTfEX/yAvA96QV7t8cTbR59S3EwVGhS1BSYntQeRedtRWGnvMcqVYHNFExjcLlhYkDzpeuEtN5XXyXE6VCEdrMJptdyLnshuZhqwkUtpiFRmUJOjAjcoooaxlazvKLaF3ERw43jzJu6hyBD1ZpIzwKwi2JRDFE+mrGd3sYycU+UVSi9JZG+en7v3J0FcaoaA4m1i5lKX3ZaQmWcz3ToYRomxxrF7ittRNZUTX+LEKryZqLOKVl3RHWFVN+kae7C70UDrsVJXbGsJlo2o13r10ZkG/pivyIKUKRzvUQR5aynJbR+C2QpNlqAq8SGvaHLG0kagDE7HMOnqEllbdgYOMVhdwHLGwoZpsqhCq0GvZA2SvckZWMklIoflMDZxAV7bEmE2zk6O1W7pqI4Q7B5JosxDT9YXaCbZGQMvkhTWtOl3qFgCDO0t8AAy5Wtr9Wj9YqpiPT8rYo83Sahq29lieDptTlrw44OAzaF+8jO1ZrMqWOcG0WtUoydW+klGxPvfsAWZ3sKdpEVCSJ/kr8rtsBEiyvD3mbZSi43RxG11bYX3F3zhdVIZibWpYGgnlXX/+yUdNg4tajp1z70tMku1Jh/0ew110Vu7Bq7zoD1CTw8t0AM7lLeh9UKNqoFlWpwHgBIEZm4Ew2cC3av476GZKT/GJCCYH18ZD8B04oQR7R94pdiytC9z/XzZUVbICSafJhaOxCcryEop0VHS17qbXrTIxyy+G7F8u2fZOGDeel47vJBun627SNVrviwFkd5k1MfGFw2OrKymjPys7k/b//o8Rbdb7RtvZt9WUL872Fn8Uy88bwL6uIdhfw1aa2lHo1YfStS59eBpOUDPfa8jYBUygBqhV7Q4ZPYbo1B8x84ustbkMyvkD60iHHQAWFPLZiR5HmlMShv2WIdpgYB7ZmlrZTDkIq+2x9qNkl4diSskMaXt7n5BN6pWfdUtNWa/icZIIGJ1W0bcHCaIkrGeEkRHrAiVAdTDJUEY/SHOAqWphzvttUpJvfVFDjvU0ZSqMFaQOkZrk74tIX1KcDhhaKw2xZRL3C+RsLhSXd/k9LmdxwsGn5X33w5qSSeApQ0ylRMjEHAOeoXEkJ838Yp8sSOolK+J7NOE/SULpLtz3a7Acpnu1QkEMv+x4SGbGSbnYJdYcLkFOpx7OO3IOoMqh5QHo/AmrPj+5EJtxL3FvgOJ9CyXMJWs4JJRtod2G56VBIjKgMT9PlmyC2XVXQEBUjIl1GxcZW9qZX230CfuPgdC+mnXX+/VSk2hvaYNJ1MwD7QMQiczT9myFNV0ep8M2F+k9IiNwdHGn935XRKxSbtdY2P1Ce95wmhhRplVDj3XUHPOOQyPF1ZxVoylGq8t2AUd/joCNCZHAbxAHOs/jwozlDKiJlUo/2rDNm8CPbI+NblojFYeE6KpWiatZxtRVySMDVfHiUP1awCovNVElIh1tVaJanwguoXAEVXVVCTExTib2Rda/HFbbIa6V7UptGh1ly9FNHdA9JktHxkTGxqKN5JoGDVXYFs39Qtu1xTHIo0lJevAElOZQ6wMBd2qcA1Ngwxcn1DmUzAvzDQKogQsMV4fzhKtRJUxoHJtl77YDdDrNJlmLEye+Qxlus2aCp8vBeGKd2P/2ZEfNtXdNYgCiyta3ZUYKxMr7PEAS1lVkMHkmHOiJfQtqd8KLjO1JqlETNAYjfmZMYndQx9OsMWkwwUOvi6VPo60srEklNqUOn0ERocs04qIzOPBhNWaD3YdMg1pJaLN5Pe/4z6Ua1Le1cztMJmCDE9PlfYmIFbpJ90FZhO9agLJqehwJbsl/4KxBAG1/BppZbfg1GGo+dnQSUj62K661WPvIBAiniFhe0rBTJDkcqwbZi/8EK3HdEowkgi3xf+owjNOTFKrmW9c2gqwDLgMo9SXogfzSSvd2BtYY3dNcAYa6I0p4sEdA8+AiDeVSmC/6QJiNhIgmt0W/y2uT/osSyawqQSoVy5zs8w+rTHNPPZBw1bV1BxyDGT7IMOx+iXUJet7uSo7FN1JWNcGLAN1h7T7aQ39UzOVdWHOwaxkEMpRU+qGRhE82VwjTAFvKbIy1VL4QiSfKvalj0v4ncCigo8QvAKuqBoOHwqaYlGz+MO12Q25+cbRwZQJKYcFVqyAWxv7W0LqtZdNVIwO2lfc72s2ufcBdcA1DZ6z9XeAsp+WFzEnQFcBhazCpJfLkHvE3wBWl0kP7rvSTS1/gzvVnoF8RwjpS950lH7e/wHBtGYn6TcbFouuKFApezqyxJKokUBci7+5jPElgvWoeGIVBp9rk8+5QmRCxSwqt2bPu9FjEjsY8wWiP/0r9hF6jjUS8NDaMr4asp1+vaIxlXl0I8C0ZviWw24DQCK96ruGZbGAtcUnVnfFWnji5krgLsYaU+8lhvdFIbLfuhwMNapxounr9Z3WEHumSyKqglI2S/hyBh8E7n0ux/feV6ps1Hx1G0nYSyG8cY3sa9VqxDo8gd4HOsHY9wJcXaaBHLqUGwqzU6DLtDdqvfJw9s5pH/Tc48foBvk2Xmnr5Ze6rBUSlCoGrrzSJqUMhBCJUgxb7r5VRFd6v1tqQ32mXO75ZI0b0JKUo33kwvGSDSy9WISZiaZo1g8nJYwPuCLp2XVqf0ZvwAaahRIhmSSLeOdO0RevmqhB6VRb7oUiqikQ7UFJz4fMA3yP4U8TmwwUpDakxvJTcROYWC6bd3AU9qA3PFiO/5Tz2x/47CMsos4k5+BmA6yUoH4seSAPVz9TrkWmNjwxrOek+GGn9bZL7J0KZ7Ct80eDFja0UH4x2VRTuZVsZzgVDJ+exW0o4229V/HPXk0sMwPnhNYX7qVJv5S7JxJXR2mQ5ig32Rbd7mXKrf9Ykj9/B42C0NqJPlN9jMOd2gi/gcDXm0iJ/BsWL6JS08NLYffLC3Cd3YS5cJwKDN2I1izf6p0UUI2pVpVlde62c5WnN5l5vc+qT5mSzd6JlOZ7Ehqmuw+5sk8rfIyX5+GvBgfvTEp6MRW+PQ9p7zHZ/uGfsONxFOqqvvBF3Y2yndBogalGa5IFnNkh9pwGhn1NxeB6DC5mhnZNIG5jdIhfkpcS5BqlfDRBHKdlL4S2t3CX5pYfrxhRNJhqLTZI/oB7i0YoPnu95PFA2J0UxJLuO8LycZ09+4L8xscFb0l1M/Rx8j9MmBvZ25NlPs3h8l9ebxVX8QcNwmdas+cePNo1P7wBwh+V3a9/9IdWnwntzdnsbz6bgOSuRLTx0ETaTPfWrvmiilI7xXWJl49RHB2PQHYq5zZIj+4rnHzFDrR7S9PaXjn5pkwvwqxYbWhcZW3lp9O1oNX3mJY0Mc4jKy6ZXG1x7feZfxgGUx3xePGkvSiNmqzOpKmfrYI4Hp6OK8GvqeA6ueHVjMXp3JzxxKiyJC1HWd6GSo67V/Vdqbx9d2Z/uw89sexXQnhmp3LIB/g2ODcWK7y15dssJuspRJLlZU9zSMco0ZJ13S29TB/87eedJ1lELrU8OKiK6rarxnWjIdvR8AKLgu3vSMpogBiws9mLsdeKoLVI+pJkxFnM54DmVCanDtNrHvnnTUHNMd6S34UYlTQOZMsNRpFJ8KDnRRoeSM2KnmJ8lKWHzSYmWaBXI/u9C9G0XZPA3h3xL2KdCa99k8nEOjEMq4w0SCWmrx21UabWMdA3yoCpeHKpfqwxg1e5F/a0RJVOUPMlZItOtBJHUGoQDUdREJJKGwORdiv2YhuHqh0MpSa0iUmKLTZvJAcQe0osl1VZJtsKos56XY2lbUrM4QSa3TLDDQQNFofRSKNQ0krGWR16/F7oZTEb6Ghbx2NULrDxkXtAZRFhJYv/1hfhSONAnD3HF1sE2UNS2DNx41Y6ZcY+hJCBm098sU9ONcWOCwX/KWVIB2U+rOWoHIcykIXyKRBCOEHaCtRKSYprK/2/wwAyTIqrfurY1l6YJnbyRjfvLGViDOwUWaS5lCETFeDAwSqKrQJ17lYbGJUp+URBtuMQimtxm/c5rQl+R8FUqlmHsq7IC2Rc4UYySsQgEC9Vh3AATiBfG6H3jvr8dTMVoh649qO9nXit2htFk4usykQ3wyeOKqCmzMb5MJZBDJjWMUJKupIGqQ3yqegVb/mh+yfGhseN/Ed0UOYyz0EdSC1ZT/Qj9dbwsICBqLQ5GHsO+Gaxy1SpVahnLrgi0zU7MGAeuncljjT8l9oxmotYb66qavHXtahrT3zg7oR1DvXfce9EwZcFywlXSYHiP76uXcFgY7QKDwguVA7vfGF6VjCT8wiKR3GqjrbKZnKRoxzd2L0dBbJHy2RRbVJhYijNJrOvLupE2T6wPMrfakOcHjnKClrfLL7UvicYqXp0leCPDQ65IhscYXiReSawJ7oztMI/OqXseGvP7XY3L/eoMTdWPC7CmdtqyFr7FW4LkbOLTbB6PSt3uiDBafc907/u7tRaVOqZHpPpL9KGe1WO6UF/E+byVmtVfMq4aS3BagtVdME7vK+Qm0a5lmwViuVSaLAeripdQg62qNvKw4kXxLSqj700UVixgHzKjTPElZa2dAflXkACmQa6Wv04Oqa8Q8osFvarSP8E68BMBLXMoYldIH/5EQcl86k0u6kTTE2uqWhhsc+VbW6Tlra7IeBC3kEhJnQ/jFqxF7YrSd6qRX4Im0fHnwmhHHgUuj/IAZzUi/RUIprYe46RSjNSuvj+RS7HEbwz/vzAkGGRVnkp6hV6LZ0BwipEDuUIMqqCeYv+LUO7h/n82nI+WO5pNKf5Unwg1QATmuKQtWPtR+Du2jcdouu7bUuJ+8d2ZMUOITNysIb1t0IY05zLO3nfQ8UeSR5OaxNa3bbZ6ew0I/arhxFC5tbFVZqWYPCw7jbDn06teGLwHzkUgMZX9gPqUvYGRodL6XnMhbQbla1d6m3EsYH6NRun3hNvg8pRltoYxyttsIQfWvGwHo7tcwAtVWlaXF9chjNPRVIXaOB6AoLFJ5+a+X8sp99tZltdunrW5yrxscMg5fOunUE2Lzm9wAvuy7DDOjQSmUdddYjR4JHI9gbqPPMYhSdPRdkn5NxPfTKGvGkfspXbnUJyDh011sVj05Bs/xwwFoXqW+Jh9v2qbtSmuEf6fWoLcD0v9KDHVxcXmU5THdtFtNq54WMOOrv6fpHu6cbH/RdpT1q0S6/qReDoAO9DN0o+PUR/xeY7g0cP26N4A195hDAZhSF+VayjYzZiRwLQs/OMbZY8liXiZmOj3GxuKk+ct2RoG035JzCMRyoDhRB2GoZy+VkVO+z8Req0krr6xrxMv58uvZm3a+Yx/kvOgtJFkQyNa86PE+5cuHz77f0cf47TeWSiW8bL0QsduQ9dLxdu7Xr3hTXhMoekLGQ172E0pfKn87pSNz9xCITADEkXvk7hsTsR2s0AOMnYkBpD7XykZsLSwvPdYpPw/Z6L8HZs6Vgg065+bi6S1bwfkAYJsnmQdJSX3F2rvzCFfXeT7/52FUa9wRUqPGsvHXA8oPPwiWuQdgxM+iHuiXiF5+aYGsl37tlSpEvDGrLS+1AcReKjT+GzI3E0Y3LZhLlxB6wUbaRvpnnrZcySXiKhMUXlY9hLXbp4ZyR44pxpWwhOhNKG7mO9lVtyMVFoxLplHc//CJj8Tr3wmFQ+VLR4e5L/V9hfvFKx5UTLKSXeo+VEzeDbX2pexBZoG214iQHNSnKiBbVI5klUXt6dQMAepXOay+Te4c+Voy2/N21Z4ZLc2TMbM/dPcb2J5fHnkZK1zPLE4J9HRxGaoPHLodcc1UUrpG52qJILQaJGZxuLaop5epanaoi3aIi2rXmqwMWJ6EvJMi7FqvGn0K5VOOLFzxX4h+Pw0mq8lmIxTavRg2C/satR4lxrCfvsMBfQNPZO88UNgeKhl0+pjHcoJNpoANzSGFQf/rimbfcSz1dYqYuPpy37pg9WEjWnxtIqnE8UdJfNHJ6G0PUe0Nz59Xk3LHm0KjMEcKjwym87cypwxeBvsycs9E8976Ht9rzf0hl6QC5axd3x+vrNo5B0a6xBpslS2J7t2juTM1OUhs6Hj4qiutxQdXkiJlwysClZrznR/yf4f9RylBoGNXe080rs4PKKA2jB5ZFqpDRLenGaNprH7/h4crg2anNIiKt4isnRtCN4GN5rvj96rrfDi0nxEc0HMdyfVQogpYSb4WGI+fGIGtTDJGp7hrtfPacrYGt6QNkl1ZixQtttQlfmNa2NOT7a4UuOV/lZCGDx3sAuHMEwWdXAkQkdjSWpXsTL3DGVwtqTXgKHADqL/ilHLmpX+qNoj3X9jQ+qau8fzEEE6f+6tPAc5AkNPwUFxvd2074GoL0KX6UJIrgnp+rZMTRHpmkbjbWsIu0lDTf/JmAnWemEa3l4s7rXm40MUb9OxLr6TdI6Wp3ouL5Hh6yoYnAxuZBQkmXf6EoT0gmKKkhkNnzN5BiFxJSm2dYvt075RWEJZKhN8zYatRCRVpFlotWmRexkzCit9GvlXGR0bn5icWonLd4cslnEyKLZ4MwYOAYnY1NDDrUvEaqZ5J9Tvv3RsZgVAcFRbvQUTl5CUklbp1z+lZ6dBS0GgcfVWLDwiMio6BsZ/lWiirFEealn+Vy5OwtDslz7D5eTDVapk3qqddJApCAEFUyo9onVAtRkyYxMOH4hEpk7cePJFrIP+1zKZhniM5NXB9L/ULNNcBejK1Xy4/rGjRNr6BAeCdnWGzWLaKdlP6FdiCGiYUuYJg4pMhSb9MPmHRmSGY8OeI9cThCevDm9AFDwV/hQxSJLL9H/ud8AoCpSoUn+wvYW4zPpMYpasp3eqchhe6FLi6cuTI6jQpN+YTP8KBRxb+I5rv0jw5IvYBE2/2UKIx0jPpnwYtJlnylXQ0JuqXI36svUZeSXe5bfJavGcL0ok54em9OuDehD0HzrAl0A+vlwoyrxCe9NXspqF2HRVdQk7JlygLPTH9pat+Lq8ZTkxUz66wxA60J3A+LLVTlQJzdw/sQYXPHm8pvU6j3AJY5WtzqNxNIhBXz75KTeYQF/8ks+A/LKywP5LI8ABzGAOi7kKVIK2ZOA39CGESMeW9/6s+JQarGBy+ZCBQ9DOrOPEsumRALF46cmnzGAOo8v/fZyU3/qsarXud1Svx0lVK2AkkXywJFBAA72Ms8abfmMNWSVbKFBKmjKXgwgiMZ0FrGK7RsXUgZFQCWvYzPZ2N9HhJildBapSu0fN9EGQMIloxCz2cQ8x4SE53QWucntGw8xBkVwS1YDfaFUfs0i/dol9/AgftcVbCQP4Tv0llf6GE8AWuIcsg+Rx/PM0CPLpgPjVC6mQxQPwoJw6c9b3Msjra/KE6zJIpl2g0myjS+r9t9X68sPHPJ9IBbjbTRNzAPwvaJYst+7oA0jQUEJLtiAaDCs3HqVQAcPeLwyXiWkFBZHKedJh5/BiZW2zKAXjedHwU0vFYmQLqgsQ1CnDDiNvB3TlBozCgsa8yr+swbAXFV/fbz1W1IGjEtpUyYCpsWrMiPViR7Gz2HX+UQ2meBMWjBuBoPE+5Oug7jX80xoMexJ5sdBDWzwaBPsU+TioNxlh7D711oQgP9r9oq0F7CvRt+5XbxPXIIX2KNe8rYm+I2Fn2DPps6tn3typK5aYdrgVAKABO2EJBQSb9+3yw19No7ym32tvuTcHvZRsWvdjtl5ZMaouaCMTWkSTqLVQ87Fnvo8K7LIJvRqANa9F++raNjGnr/4vAdqZwmFnC6ddI2ft+g8Il93ZzYDs3u7GxR7qv7jbQQBFreKyIE6uPkIQ9jwGH0GOs2JPxrPmIwWWgjIyRahBp3gRLnsEiOmv8Jzh4kUQCRAHmQx1sJVQEnK150QpqKvx8ea3niOYrafIHMVpPUezWZ81plEoiQ1a4qM5iUFPcrQlNVhJ3ziZzM5L4MxKKfNSxuKiIL6tNATJBi1Bs41g2RUctzYEz/53cSpy6lCqcjWD9VzDXb2o3TgVIseSOl5IPa+ExBsh804ovBcqH6SBTzLOf++cCb6yk+X8gJWV/OJfJvkzBGWPRyL6GkFKSVBSejgtZdNdSMorXZfC2MlBc2M1J7dkfsBaPb2R3+Srnh8yVc+POKrnx+zUv9aTRQ6e24seIvt7MkwO9nz43N/LVeXhXo+Yx0uVPB1Znu29HC9zaZ5zUR/zohd5uTx5tXx5vQJ5M+p75O1oG8y7lWws71exqXxsZFDKRtXqJUmI2MJCfwOuapfDTe3GNrW3BXc1aTrb1bTBQx3CLnUEu9UM9qgTXw1PNScYd3VGORBRqoGKMxIvScaAkKYFH1kGXzlAKwTGUmA1LgHHe38DeCsAUTtIVoNsLSg6EWc94m1Egs0tJNrjKEmOG7KcRLZTyHEGuc61kOeih8j3iAHiVkDdDpg7AXc3EO4F0v1AeRBoDwPjURo9TpMnafb0XbV4dqcd9I+dc8xrBvbGYYh3dwXl7b9Bu2+hw/fY/YjxM9avOL/j/UHwH6K/DpYCxM9gX8dGBTgkF4CjcgOOzgO2PFER7L2pDJ4/9pAdoDpMYdRGKAZn8aXQWH18Mu1fl85yg7AoeApGQqdhLHxRjCetkOWNtsBKSx3nZBx+getpx0A7+nKX/8ZnPW/XshrskmN3/J1XRPLrFGCDiZoP2LBOy+M8c84I8HVhHl5vNtvcFWHO0XmOFp2LFNV82U/opGCuQHcygxcSMLRf0sc6HS2sXPffBR56CMeLOpKCbySQkOhhMNweLP6yEBoUWGkUZt2yxeuK+ydT2V9nWlat0zETVp7kbtnQ8dtcB975Rq/hYKLbtg/MDRyJSyScfCMD5720C74Nwxd+ab7o2+iLv02+5NvsS78tvuzb6su/9HaOJkn2h0smIF7Pajfa0mYVeg7Q/l2lfldFev9od3vVkn0uQSwaIU+BgQYZ2qdd8Lx0GXBkyenPEvp7t71lPTbnGf3QWZwhWGHPnY/+T5AvHMEXtStmUEcZSMpR/lY6LLDaWp0iREGBRjN02mBZZbU11kq0znpJJ3CQ8zzowc7r4I5IzX+ZJluks2qO7XbYaZfd9jnsqONOOu28i/60wSZbbLXNdjvsstd+/jnqmONOOOmU084MLjZaN6RE0RZXp7qIWcYaxx/ccMsdWe57sKghXgA/4hxX8vKqRhzVSlnNWuUVxVK1nPL/zddvedffhNIIwcpVG2lMiA4UVlQxJZRUSulllVdBRRUHSZGmqNEerJ++W2pZQj+QsV/BzXk6jbhYNM+gjHiHa/I1K4T5b+xAllUJCu4K7QrvRCo6fKYCYYbPTiQmTCAutnfhgKRIW+bGtUhWkmBmOXkFxUobByrXaBf6Cn2dAMJEiBItRqwEiZIkS5EqTboMmbJkA4PIIdPyfB/Iv8EFaPAk0M48dXYwXdZ9gwroOZZ74wYd0HHQqa6DbnropY9+BjToQ+C0fJtNOg4w7ZWAmdO1gDOcZdxTUlHTAIAgsJHTMKiYDAFdhgZBpgOBr6IJEFRkPxBda0CJsipOA6rUcHDlCQ3k2wwUqAwIiYhJqBPDY6CfEoOTZ70HXt5EivaeivpJkyFTlv5y5StUZIjhfdL5LpWpM8XGy1WgWAkFtlvhkHM+NxQppZq1WWWNDutEWi5ajFhx4iVIscFGm22VyTonOM8vuumz0AFHHHPCKWdckGG9jTbv8sSTTOqb9tjngEPOueiyK65N3X0L9kc33XbXPf95KFvOjLy6mtWPMtqaR1/bey4ei8fjyRe67a+oRKUixUqU+ga+6Bf/+r0BL+8NfGUv6sW9pGwlInMPXXjcyEWUExDpyQiwzGUTONmWQ1DDIKrwp0rNC3kddUo14Hsln1ATu/XV+mnLV/WNDmpdPX0DQyNjE1Mz8xNIyOHHUJYF0IJCIhgxcQkcKCUtIysnr6CopKyCV1Wvwfk0W6WWto6uXn3CBoZGVqwSrBlbPxvtTluApGjGB1iOF0RJVk6dreF1We49SMwoy9kWVEFWJH1IZZJo3uy1RhTjQffaJjeZ0V/tao/ehGdqShPDuP8UabF/utLVrnXdS4r6i7eBAAcFBjx8JOg1aaWLSqqppQ4SVBppgUE7nUwxwxwLMMxmDTPO0UEXvRbYzz2GGWWcSaaZZZ5FlmGyyjobbNnNLnscjCda79LQI89vdB7M8AXFkvLYUpmq1MSR+iCDTUWqUxdyGtKU1jDTkc50pzf9Gcr4yq9kEYtZwlIu4HwPd5TzP+4JT3rIwx7/MUW3oEzsy+5XQJMoiEUqbawHSGynWtGMD7AcL4iSrKiabrk9SMw8Mi5AKq9Uxnj+5AbOf2qdU6cyD5xr+7CZpiG3q6UgaEmcVKqjQw5rG+OhpPYH1z+L3CuhKcMDiaEcf1Sxc2XonQHOnBSxupT9r5qJ8Njgj/QoTHnLX7jbeKkuf9Fo0dyurJ8voswTv3zVTDKZOn3yhWo4PcVT8qVu/hGZ87x+zemKD/E9PHFr/b2MX9CJ+8t1PUgmn77DX00JzQwecxgW8FnCWglnZcRYAo8Tti6x1idqQ+JtRGJHSe4yUjtBeleQ2Umy+47cfiB/QIDCeb2A4uEOr3TKQ6mc9nCpmPNlImHh3LgK52hzAnjmAjDmB/Dtj/XoEu6m1gKQnD8nLmwHyG4kuY0hf7YAhSNSPBal41A+wZWSKn/37Ldt0rfKXsR5eXhH18HiTBoqaDml/E6BIiXKVKihVnUj5CnXMbrY7KpNLk1cBHJ3AsYs8Fi0S9Wt99R7tYXsb+YlQSpKJGlBlIy5SDZVhCvBSh0Bto0QWn4UmX1Wx4lsqUTIiNTh6Z7XSJnuboycwacK3a9Q7OFQ6pWh3Ks6Ku2TwVp6csHUY3I3JiI/cqiixpXx1DlHWzS4yK9ocZnu6PDII3o8j+jzMmMAuoR8JRLI39sj4tdgZLy/JMu8ElZY69QAY7P6tMQxYhtcEtaSVDg8QRUCqRAZhMQiZOVCYROqSqGpErqatwpD09DxMzpKgkyMlhALa0uYVZMIh5YmUqlURK0uxDvrdHDgIyUm6HEuwU/+4Nw9QmSsx4hNxQkSYz9FaqovUZLaDFR2uJWaOotdGoRKo2WjmfanlAdVZVYVxwOCscqa4CRKDIFhqkxVqbquOWImtRvrQ3RNUucNqffOC4XkPYdC9oGzofrS5TDAJlbT6Sdknf/Jer/KBr/LRn/KJv9vyWb/zSHay2eo5D3/ACp9JV6flL0yLzrl1qa3qXw134BUvbovLzWv4RuS2tfyheXW643cef2W5q4mKl8f3yXWq7n5KsOeR59D+7NogtBJAKg6sjf7vJohAdpZTJHhKEDjPN5MuO3azofXbuhS+O3mrscDyWp4f/ZfEIv/GoCPjMSyf7UkIYRFunEkR2UmqolINKpIDJpMLBvF2ZcUv61OoJjSJMmVpEEFTWlplaTtVJIOm9JlTBE9JjL6hDAoQ2aIXGVtxggP1zDGRKalvdqMUzTFHBKWWG+17Sl9se95RBx6EXHs/YhTH2acmZVLnxJx7VXGjRzu5dFXZDwbFi+8MctCkVjFmZUqvn8iYrUzyW2y0SWEuOMhwlJfnuv8a1pcV0lTq5QfZiyUUY5VNnFSVahXJF9TpqCfjlOoa4QU6VtNSgytPjCilB6OWNOag1rr6EFzLew6IoNHS4UI1iQqVTUzqLrzVLvUFxFwpaikTBrjeqsqnZC9on/e9SIfyOTjcbI0NiTZmhmeHK2EZpk9qxzicB3VzyPHDNgjmwbJy3FDrZOThivJKZWSnXVzzj215YL5RC5ZmLlcEFypq0YRWTI6smzsvawYh1ZLgR1usKubDT3entkyc8sCe3PHrw7krvSI3LMkcmhZ5MjyyH0rMw+qpB5aQ+SRtZHHMjJPyoWn9cxmMscVs/q53fbkRdH4KweGXzvrXE7cK2siBJKv8FW+xtf5RjOXfkdikqjKEKVq6fRqd4OUiwBOt4A4PR7PQtYQbBa7meOGw6k61UjKCOgB/fyL86ITCeENP/27txKGJhJSMnIKSipqGlpcPDg+ASERMQkp2SVfmfzc6a9ayoPyHhcoSdtGMws4iLAg2uwOx7wn2AIIdhr+HFBcFSSkyfoaAip0ScDAwsEjRGxq29XYqU6DRrtKxl0B64o6WrFSRmZlWduZTSW7fgMGDRu13wEHHXLYEVg4eBUIqlA0adaiFR0DU5sZ66y3wSZbbLPDLhdcclnI28H9qcvWW4pBpbKU5YLCHv4v4WFKAuzNf2cAJTgWVF8M6w8uoAVy0rdNXCEB3TAF7MAR3MAL/CEIwuAxT0kkjUzyoFFGDY14G+/hM3yDX/ArHQAGQcLHSD2eu8Z3T6r/B+j/6U/il78SNP0MJlpD/w//zMqvzwtQNR5jDosIVIMa0Bj0P4ghBjKBTCEzSBsyhy1gS9gKtoZtjNzDb8b+fgKEiEyL5YtHK/pNwWBxL+9tlvDWlAgkcilvBpVGZ8RksTlcXnyBUCSWLEm3a9RpgOm3coVSlVqd5vu39l6nf4ZkMZpqJs1rIS2trG2ytbN3cGyntX42H8JQOI/xX2XKfjzoi/mvrj/97dVgzVZeBCzTp0Tddrp796CWT+HIvn9XxrJSVMrKRJli/ltOcoVSpU6j1ekNxqxM1jZm1SgSSmeAmN+RBbsf+Fl6dYFGTa3ZCIpsaMwVc0EcyuC0n/8Pyz/KhW8p2ILJVauvGYCXWbyCKXXmVKp0llXe02yplJwwx0Vy0zmSl86R/GTOHRAZIPEnysN4b8Bq123I4bogCIUUUUwJpZSl5Sqkwc3jWbFxqghzwHJomuDgaFhBJVVUU0MtddTTjLHcgZM6uSZYakFLSYRvSVi4FcEXWiLVVu3VUazqrK7qrp7qrb5tTCqtwmMrtcKiFLnqi1TUaihaNVZTNVfd66pP20WerIToDBm80/du/b5avTkgbtCk0bJt6GA6+9MlFGY+lbDhKxnSZPvDvSFMFu1U1egZtVdlM660fNkfPUIZgzeCkaNDxcRRSpaSKHiRhMDhFj7CAjsgm3gErF/d7F6Pe9HbPvWVH/mNv5lhkTW2OUDpNOGETTTTQit0GDBpo50OWHTSRTc99NJHPwMMJkP65u8kcUpR8ITD0jBHHwmSN5XCFE61KCVTL4FHLtZjZZQuNm2USOo1Q/htTaFh5SDedDvD7kKSedYe5fOxjbR3rgOGXHA7uzenfg3TD4l2/HoL9epukoHOdjdePxmNOGDHNOEycG4PwMe6HLVg86JSBfWze07Ac5FK4Ekv0AB6ifiIFe4Ce5pXL/UDJH+yolF72rq6I5Qnv4G0hzFb7dYdEIsa+5cvb8IFB8Sixv4KRAsOiEWNxae+fryQi5s8Crr5rwfOp/Ph4FUgqFKjFlGdeiRkFFQNaBo1adaiFR0DU5t2HVg6denWo1effgMGDRk2YtSYcRMqVS+dCO5Mh/RQY7sS9L3U+8KizooBCbKXmCrY/0gT/3xEJ9lPx6hGnVJlEJBQyiXS0itlYGJmUaaclU2FSnZVqtVycELDMH9qLpftUUK/pjVENYnO90MYLwBtvR2LygswwOKC/68W37+l8JcZ6OiwyOrtMWHU3L/DNERigBOkRCqTQwVFMyynJApNNNVMe2ZpzNnGCodpU9va1RWJfpKnjql04iAG84z0FpiZ2DnYSPWdFDx0j1yvJDQk8FrkRvBbFgBBwcAhYeEQEFHRcXDJyBVxeYaBJSTKs7tMUFhEFCMmjsVJQUBBw8AjYWBiYePhE1NSURMQEpG6umbMOQDrVE5ORM36QFe6Xtkb3tTou36g2a/9Wru/m6vDSiuNt9pqE6y1VrcNNuixySa9ttiiz37/c7GDNi5xxGwYiiA/PyFXKMrYBo+ytsOnnJ0QytuNkIo8EVHJvjwA+/ME+QSD+AWHBeSNCAqJCs4XExoGFx6OEBmBFB2JEhuFFh+VkRidlVeQEiIECBUKggkDw4VDECKgSJEwlCg4WjQCIwaJFYvCiUPjxWMIErBEiTiSJDxZMoEihUidWqJNKyupRFFaqZoxo4Y5s1ZZZTrWrHoVVRjYsxtVV21SW62ZszxRX9HWVIVqiWPaqnGdNYXu2qC3rtRfX1XRClN3xIXXoAydmtqL7c3f4ZMaYsuOmwQ/OnDizD13qUxHWZu38tLk1vyDTfpD4p8K5NXPyW31BRb8mwVbdl+Oqwcv6041dNmyJ0edf2k+mJdmbugnjTQ7UYOCMUXMEnF7JJyRdAfrEZ53+PnOHuQP4XJDWe4oZwfK24UK9qCivajEC8AbyBfEHywQ4gBUCEwYXARCFFIMShxaAkYSVj4lJBAaBAuGhyBCkWGocHQEJhIbhYvGxxBiiXGkeHICZYhIdGR6CgM1Ew0LrXI6NnqVDKoY1TBxMKtDNLA1o1ox7bguQg/QRxqgCmR5FXX5TfTeXcEvYtNrF9UUZEfvuDsHG5Syn/OVamnOJQXc05J2H9t6zO78BhKbOQs+pPiGE67Knw+xzZNac4CjprBm5cFJQg72ClbZPQzsPyrr9PF8fu97f21k/TGuhHPhMa2XHdp/UM8wBAqDI5AoNKa7kAceXyAUiSVAUHfjzNL4tR6HJxBJZAp138kHljvvz8oVROtSqbMtFxfmkcMYsO2LuqWP1fwgi9cWPvLnoRxlvGka9p678MT9mO1VuCJjZdrr6Zpse4M5J6yiuxToUm2DwQjb7cU0XaFr46OadeXM4EwxmmX5T5SaUWpZq/Xxszq8/tRyI4hgqRJJZYKFEaAgtJLa21cj/sO3KS8Op79coVSpNVoA0AYEhuj0BqPJzBxqYQmDI5AoKzQGi8MTiCQyhUqjM5gsNofL4wuE1iKxJM5qnpcBBCGBqHsh0WIZ/1LL0VpZ6YCDRDxlsUlTovlzLGe6guilTPqJu9zit3dL8BefRNpth0QYGfWRLEWkvFXKSJu2kg56rlHawfD1y63OdU2wkkyFtVpFo/dPFJvURl0PZuDe+tOmD/wADqT6YvvXUgj/vnOqZ2QwWWwOl8cX7PSfv1KIMZCU0YRxYhghaFTAAxqZQq5SqkGdntWKhLjnU6Iv/T82avCHs54qRH458LRZkj8y+jiTk4eRVEGJtCqRzS1x2OHFWfhxB0E8g3muB4m5EXFeQa3zExa74F0BTHemXKZRumC9kFL+G4z1GoDZUwBrV1wK+L95DS+vGEW5w/cekR2XGrN5XFR103bLg2aC/uivXhoyTS25QqVmUaltW1LzSNSRC6w2bI3ZEyyz1MrH/rmnMIPX2t3vQ3viFGygS+widpCzmJbCpcxULk+/ZjApG009YlMVnUC7u46eNrbaI9KvhUupf/A2po8HctxNreM2f5HF8fYgKeomL+E58ccrb7zzwSdffPOT/mrqOjMj/3+nqOpEjbypwqKuVi5uHO3v+ruwrrrrrb/BeuproKGGG8mBxL2hqR1lllFWo9tBeeVflja78f+EcUB1JZXUVmPGE4HMyjRDy9Euj52eQQOkTBblWmDk6pCvSrUatRyc4BmJcJsXRrp1mNWrT785A+ja2gOPWuY50qjp4L56K6Z5LJ26MPjvvkFDhjMJv6XrYlc1YcpM1pTl9DuyYtyk6b8AQjS9f7Yt4yK/GnJTwmsthFDpJsDLSHfqji5XclAaisQSqUyuUKqOW3uD/3l/Q1Ui89BXe2RIhMAA0XuGicX2AkpuP4CVr/MFCSNopMUQEwkNGXvDNocyDJqKwLXEs3sCum5q8QJ1eFn79KA2WVO/eNWADjtxcK3d7+RoGlicQ0oplpywQh6GD43c8xnk4siSZKqr3UHzHBlSNvy+GhcGQVAXhEfL04otwQJXCykPAMAKjxEhJgqOEVN+C8Cpa8lssqp+xJADUV2sCg4y2cAETaqoReXI3Y0GmTrZzwCNZ13LVjgw7/fIVyY3bYx3OsMXER7FToaudJAq1qSJC1g4lVngVlEPRLKUowzVOZQlpu84eAOULWMUuQA4Qwm7+0qclQENWg/hGb2zhgA5ktC9FgV2ySy3+2ePqf2gKR4YKNMBlPhtkqwonZmRjysW0qq3BhQKu8xqYUJaThXwDuBzAIY/QHeHL9J1QlhYm5EqpjjgVsdi5HwkE0tVyq9I4UGkCw7ekRkO2XL5QwRvSxEOkJbD3NkyZ2M0maO1Zg+oZEnZNkkyVRnYcntQnNBRsuVSdmWSE1xEUbJv8cdKNGj2LGne0ciODMNYap3kW7K7DZrg4GdmlUe/WWbYGdPbuXYH0Npg9NH+aLg+uxQCHmO543tsOuWKCk4yy2oXZVKOQf2w3Wwcv/U4ilsZEPpH1y9E2WhCQlLEXM7ZTLNmtrwx44CrVlhh0A5UjNYcfVHiJMnRCvPhx5QV+ta3NQI+5FBffpja2zQznAivA2cOGW0WyKOzPGVD6Xov6lQOc5UhikNkwKeu84gtCix33mG/pdfBIihLDcEPRId3LI+WAAtR80dnbB3r6c2R7vkU/CQNbcx/soEa5AkAbBJ3mEqyAR+xbOSITg3Wf1v5DfLcakMhGKP4k8obQcyknVyOs8pyJvIMceHAsEBixWfsWxNcHlcCKOcUA1imjbBseXgMEXHYRNpqWNSqkiaGSSGiZHswZFXNLZswf9zEKM8SWbjp6K58ix/jmbjdTEYnjDx68zPPh3PYyqqbi61OqnNwV6bCIDyVV+Gt3RHf3mY2n/KOO+p8WD1M2Z9Uk3MzT1mveBeKVX67JSUad+4bLRLGdPAq+6Tap9q2GRa7Y+ocGC/BI9kXxcVmQ+FSpUJH+VJ0G3CLIE/5bV90JuhQsjHUMUF7vvhUzIUWRQp7tKqMq1t5zcwVJDX37wRlagVWF/MFckVHayRn9Xgg6YdXedHCLe+CeXDmFvVfaoL6v2De6JmrIvUw+LZ/htm2MyOGuQWky4/U4eFD7kNsAcaQHdpvKIMR+ZUL7KKd38jHKnlAuMZZ8B36KJnK3bKGA7USaGaSSeVKBXIJsdDOFkkpKRCOslgfyDtNSfVVPD4jYo1Xe/CnQxMP2SGu2sVfiLshOc8rUetMKJwNRRhyfSe+FOj37asIQbGJMRLQkZScIotuX/DimTwqyzLgV1as/9rhfRyTV8TUh4bulv/e78/RchQdeBPj2indsM+lRB2uEuxcqHA/6+iqCDMCqgKXlVFRr+2+XSB/iEd8RFI4tQPuv+LSM/lsq63Mg0fu7V2bWTZHW+j+kSAy4+4aKKPLk2x58j7LULH/gNJ3rMIuL46RVZGVrfFoSDM8YuRVy9J9H1IerieiEMF1n0QIy83y6AGV6nUVfYeZAh8XBc2S+dNM+r3MR/DxiwECAEDtv1ttI6LkML0/Ow6f03vA9AQCIICfpYJNAdIjEoCqKexJTctXpfGGOkty/L/y2hypYukaV7ae0IxoQA1lxjRuXl8AniGXEomhBDUlFTIq5xVCSzFUSWr5ObGUm5pZzVULW5f2MiuHtbMbz1Jb785c3fkscQpOFFKlTLV5C01SaamyUlu3sUlY2lrZWWt3879FsvjuHLF3ausSOLg66p08nPPFLgRXoo7UHgdg6iBgIeGg4ItGqIVBgkWGQxn8NQioiOhIGMiYpWBVo2Kj4ZSOW4WBh4mPRbjscogqcUmWVz5ZBQE5IcUrooSYioTmVwpktJXTlVHQUyqlYqiasZSGiZaZjqUlykvoWbeUgY1R5ZguZla1FmWqW66miFUtG+dU3JNK9WtXpVG1ptZozqvVwqG1TpicOlj18BpUfDYiZDV9L80q3xZVaFXz1yZ+TKbq13Woa6f6tC4k3Sh6UKf3lD4N+tEMaOqg5qQhLYa1GkHvKEbCGKZxbSa0d1JH3EEsU8ZETElMdaopDQ0wT8j1EMwj2qEHZsCNhGnkHWWmLTXWlplF56K9cCl2Jem1NMmNzK1Bd4bn/kQPRjwa82S8zyYSvJjcV/9ND3A8EA8iLFyEGAclwyhwaglaLJKOYqCZZVgxWM5yeG4FXjRRQBKSRVXEUVQJTUqX1ZBHMhUsFVs9zhFcLU+3fgMDXGh8RmYwscRcaiGzlFtPcajSVmW39bNxgGh1TvqZ4WDj1k5mi86XCVkMlqPV1PWcoM3admO33f1uAg579+gUM2DddJugLq4I/A9EGs/gIAUs5JGAdvZ0UYWSt4Nv+64fOV4kfdQv74QPdjaX8ySClaxzLzcu8XmZpi53a6Bw8eFwQ1eLb+Y23+/2vr/b9/3P7Z/vf29brNV3X9X/aijTqnU7fuuSpugfvLHNe2j/2lcfQreiOVKPXqaXjOXvxfWlvcbD8SdaVatrDW1Xa2qDbaHVY3uxI9g17NalPiWCozADp+AcLMAK2HAd7oRX4W34AH6GP1mG5dk4O8pm2ByrMpddY8+wt9l7jNpuo5WzFXFF8hXf9B0/8TP/wl/5t/4FP+5D+pMCJ3JDaYPSNqV9SgeUTihuK+4qHiq+VIqkyChKisGvlqln2lgxLD8Wi/Wb3zn977rqTHY7qUNuDb7slwBdjWtCU5rFLN6H8L/44+7nNvcj7LenFgCEzlXdwb4tmdxElYLPOthhjhFJCcpWl3eDguHjmbiIVacXe6XP8iK0dHV9APjAnWyMY4zjFZ4c0Oe8OeDPj+Q4f47McfmcL8et2C3G7RE/zkPs0esx87ae72WP/xCPvD18LqMB6EJ0FfoG+n8MANNqjz2D+QkLwHpjcVg1ltytKsI6saewt7A3sfexD953HIDdqTguLggX+rMKcUZcGa4XNxOGD0bhaXjerXsp5Bf0IWD6xQT5dZnkNXqO3qZpVPEurUwx08RyoY/O53K77JJ4qVrDV/2nS4CP0rogIzudpaxko94It3mXkDEY2c85LfJJgqjrd1KGB2k+zDjHiqPEnh2dz/C8NYy51ZbKUl5K/WzvZXltazx9JbIXwQO635igYGmWc4EMVfuf/9NJ+lMB0dEsS2Oz9/4Z2fX/+Ie8cofEvFSTl3+LcoarIdOnvn3Thg88nI/73Xaznqex75pa1X9WC/lMuvcTnxNdLX8/AQC/b/yj7mTQJBMYebv7Z9eXtrrJpYPJE0sZdTNr79aWx5evFlfGFwDA6+sAAPi/7cF962D10+OeEeD1tEXZ9zEAAH6eNAeVQ9IZAZ4eIE2CiQDfP5kd/SM25QogwNtZ06umm2a0h2ULN/xv67/u/3sAtj4LQONrAGh4guyQ7bIN4KzR447yHX4rMUbSaURgK/DWkXsx9QymLy17V+revUpoicc0IfcTIuYicl3RH/BvsEymwYctkmltt6UE170c9Yce5Il9diafku5vTFnKlett8nNoT0blwQJkVC6cHKZWOC/vPR28Hj5ZPC4eyV64nlbcCvbu5OOkzA2YIuH5PMvaABMCcoPj1UHjAuA16tIGCzdWiCU+/58gIiBDWzZ2V5NuX0ipm3ptakIVJVq1GFt8bGjVqV2HXxb5uqVLt6/iffDKvl59/LzF9EySRMlSpUjTIl2mDFmyQYDlyPVGiAL5ChUrMqEVVAkYuHdWVA7NiQ6ZKzQ8GPrXt1joMGH9/A8LBwI7fISIkSLngQAhYjgjqrtHED1GzFix48SNFz9BwkSJkyT11OFbwWUmT5EyVZ6I4/o07QuSZ1A9fQWbVwXp8gtRSEXpK82QMVMB+Wh96UJVkaXg0GHCVlW5l7eRvkEPHyFiNdmqqDJ7VVVXU3TkKPnVnCNnhYqV/HmiRY9hpu9wYcE3NEXoipUoVeabchUqfVelWs3r8F/tj6gDgSFQGByBRKEx2PcuyHsTTyCSyBQqjc5gst6HYNf0Pfnivqffsy/+FMSaWto6unr6BoaIxMhYamJqZm4hs7TTut1+82hnZm1XbjOQPVAwcAjIPnnRfYWGgYWDR0BEQl7xNoP89aaKSkrLyisqq6Ky/n8FQjCCYjhBUjSDU+d8rGMf57jHO/4JTvjezDLYrLOtYpWzr2rVq1ntHHN66JHHZB5ePn4BQaEhP9LoXnjmubCIqJi4hKSUtIzsGEVzOLt38gqKSsoqqmrqGhQjRo0ZN7EuhQgZKnSYsOHCR4gYKXKUqNGiP+RDkZKRU1BSUT84DS2dEnqlDIxMzCzKlLOyqVDJrkq1GrUcnPNhl8sjZqzYceLGi983rbTaWuubMJHDc3rOaJtq6mmmnW4l0690hhlnmnnlf3Tkt3/OJ6VK7acBQBhBMdw7VpCUj0eG5XitTm8wmsy+aqvN7nC6TM20MnMLuZGllbWNLWuns+fqDa8nFAIpOhgcnZxd4O/weS7JvvJ1z7i/tdVex3vIY0YZY5wJS/nBMqZMM8OsxWau165Tt14v3W5rs2GkpGfeanxrAO3Pd0Omi95NuvQ41u7rabzTz3MvvOyIu4dnfxnxe9HoDCWmsgqrf7XeBhttsjmsmrpG/22rbbYnyeHy+AKhSLxffK81rb39ozZ09qs/2Tep6ekbGCISI2OpiamZuYXM0o6VtV25DUgP7coSDBwCEgoaBhYOHmH9ml4K0nm8nvWub/0bCI+CioaOgYmFjYOLh09ACNomlMIH4aPwKayxsbn+f3ETQ6xjAyOMMcEUM1zF34kXcR2buIGbuIUtbGMHu9hDv30+ugqFhQkXofcK+sf+G3rY4YYfYcSRRjNIlL6ixWAvN+Ee1ePorHNOXOBCF3ORi7sEEDyBAsMLOAi88QEJCl/QYMCCM0KZKHGSiIAAERJkKPhBhQYdBkxY+BMAGw5ceATSjGPkUUZdyfQrnWHGmbD1WX93qMMd6WjHOt6JTuKPa3QLOkDMwYKTUhBm0wwaDFiC6YRAFTVYMkg9ZBpoohUm1iwTyhrd9NBLH/0MMEgYmwwzwihjjGPHGSaZZpZ5FvlJPc200A6Rh/TQzwA2PGOIEcaYwJZPmGGOBZb4wwpr/GWTy/zKDqz+ZR8HxMiQ8y9sOMYLYVGi3YnbJr6IBBJz16BCc4FUba8kqJ7XPAcdbF6DDzHv+Qw51HyHHmbY4YYfwTeTn3lMSJChQIUGHQZMWLAXPcqoY461+JlXNusqZl/1audc2VArH3qY4Va52pFGXeNaxlj7WOtaz/o2sJGNbmzeRvEc69jGLg5whBNc4AZv8A63+IjPuMdP8IvjUgsVFM2wnJKumWjZKqutJ6t2SdNxJ4zzOjktNOMDLMcLoiQrqqYbpmU7bn+3drFQ813qcj7j9O3vOHEEAQcq0IEXmOT/7dnA2j+3vg1tjMB30cxkKMN/DL4TDFKW8aw8yRnJaFZbndIspfwUjnTko5zfUY92IGp8zJ6wHnoMvyPq6nEe9oPWFUp/c7a0tfQyynyuFlv/MN7+DnSwQx3+3Pr0fvryTcpn/zPwGH1ufX5/hj7Dmf3c/4x+xj7jn4k6l1V2OV/YDO/Gf8a+DDP8PAo1pw9Iuak93SR2/gwf8QN5oJeTijOd7Iq/0/pqi1va8v6MuZWtbm3r+7uNbZ7VwQ9xyP2y7e1sd6ztbX//7vShD3PYw+2fHf5+z0IWf6t+Z+/JTR3pKpreiV5V5GoTdVe/NvkoR72Go13jNbW/41xr20zB9V2/mHZDN3wjjd3YswYMOASL6LEYsPVY2UC9KEiWg7eALgsZFEGdSIKtgG8lJa7UYAt4Yn4dNCBLCWCIo04JaBFL3RIAt+vr/3akUwJ9Eum1ln7rCLUHu/N0l95eN+AxQG7i4EUcvcQrG1i0kRnrmJXBZR+ybZfd9uAAATFmJEj7Yzcc9Dc+KFGh5gMreGTlAKjlcPq/QaIVPBswWg3bsYHRyh2RMFrvopcV//eXHH0gfyB/Qf6G/AP5F/KBFAJkkIP8QH4hQl7QieDA+2p+00wx5VRsd9b+Ex77D3ijZpztv0A6tgdVxNX+HVTU2vMq4273gZbaC6oCkd6LquPZP/pLDaC90i6PAeu19qiJlwHAZYM4F1c4V1eU0+vqgpTXG+qDUtCbGuJrYB9rBNoggw0BY6hhhoPt0053Bpm+6FznkdPU111CXnO/LhMFLf1WZ2Kw9jssoBjX73UlTmt/0I34fvGSAhJMIbF/o95v3fIKW5y2g+AZjaD/9N+Vn3TqYpgkALNc/Nj2VGFoH0EW3zMxa6tX9aWu94C/8py5alfyURRV7x9dPBmgzYv58Eath0AQ8ziGUTiX2hWcA2UCOoOiMFDSnoP9MQLjgp7kw88Sw9RuXMDJicIIivneaViW+5fAE5UxJhPDCC7ySb7+/LEH8DFrHlAmpuDg6hfwEEZRjkbsyAj87tXD2z/wUYy46Vsjfdg4DE70odkLo2bzNDoA9B6QC0h9qnYKxxDA5OlViW5wuPCNYthMnkB7japE/K8a4XHMYQRD6AhZLBXEClhawyhasRcZIrQ9Fy3w4f49vBvgRO33YoA7oggQwou7iVpsQzs6UDnXf3TwMcIW1/iG2GbmsrIAW7EIK977800qykGA/69+N7977/GLzlJmpmaYr/dg2TAMD6Zxx5385J/H9FY9oXMTEcYEJl7so4KCqkLuxDbR1LrG0zgOyOlB97zfgSnU4wOcRQXasPAWMYSvBJcHjWfA35rbO616rcpXyvPWp08eP+qul/PpeGj3u+1mvVo2dVUWeZYmcRQGPvdcx56mCHbNxQPHXjZwBGYD/zVMPHnoBE5YntjDSUuiym2uAarVP2MkOZ3xLJwt+bMF1kbMGEjyDo7UvZiYZR/7jGnMKqYK2t/sZsxtHQSmC6sF3wpCPN706rbXftKzSL+dwSkrQzCpUgoruZnGAVYSIARaHe1EWzgQ5I2edUlvXIIgE+kLohmHHP6M675ReFD7hPSA1JUqjbRYnbRsJCMxUb9CN5qHGZC9qSU8bqBS0KSYqoWUkI78jXmko9tIcuhRmSEF+NeKcI9TBl2ctEIpT8WfCcMgMrqmlz37k1Js28EvbcfDQxa3dodOfKIjsTMsqGEQHxG/I6bqCl1oFVUsbAwZUGVpzNFKiefoPTRfkl+G20zj2Wbye0p65JgkdwKXfCaj4GbYZ2F/KaGLZoDkpSoufhiVRCM3pKGGPAyueJgKLm3GJOUUHRcPOvVL53a1CsJzW3ZA1dK+AcVVQUROJKGYLcHMmPcy7uKwsytNpEplaObPGLS859mHz5yce4jArIEHln0OPPSLnorERBc+t6Loedz1fsPLEOzV9vX3nJgtQiS46Eh7tij2KurwSjqhlhhuhoq5zHwpAHzixp7dNYOXbf8IizT7/9FhGlSDpZgY26Hco9fZe+SkP12IXtptpvEySLaqQ0LYz1Cq4uaR7Dy84JInOlzUZj5w+HebVKEahG2cNOJ2FAn6WkFYOVB6zWSCdegON9ENikrBQtN9C4kr/yqI00Jg+yk9CHvLaSKF3yAq/I3YX3g+M8chwkb6T44YGvs0b384rHOanrB1zquo8Ics/zah/+anDtZrdKLcjkq/CQj2rrS407AAr/NSl27r9RWtm3VYlGEk3xnfnbHG12QU2RasRer+IOkdAMPNNB7FqhrdISR0eofmqq+t175rL/uoyQ5dmC2CrfWvNR3MNy6rZmUNOoGj+IBVzso6y/rZE9UPsS72a9G0sK8Vab9uG1C1PKbDmms5lvRAoJWnNpzITqSR2+0VXzYESFoeKnonqaZ81ui2hFMhy1jA57mNPYCgYqH7nHwpMcmNQxWfSNN1AvvoN4lZMnxU5PzWDw+P7tz6BC/bkpwNH8aE07LntC33RVmeg3kPxVzta4b4YdtJD+FAWdUkv5DSleXtip66dMjgGizhuFEK5PGLweNGpHH4kaNmYMbyPtSXfNCySHJ0cjaqBPWglVLwFfWbZ5ARDekSirF9NgkldefzqfHyBTecLohIiiijScz5X0fY4css1zS+uIq2szn+IL91Z8xLB4W1blTXWRJv+XiLL65Y8WsEyib6/YBUCiEbixgEdBTdQ5A2s9aCvquV9HwBLs/2IjisdJOuWGA72842ybqNA+TJamcBj6N5ks3d80hlR2m4noRQR5ZbEpvNiDpnoQQl25Ts1xz3TrKK7l8jbEyfGOd7uGZMddqtS9RtVEBuuokgRyAoQHZToJ8w6RH6NrYZbc7Bz/iP6g8NJRevkErM6QuN2KQvtC55+xoh8ILr3VSoYsmKH0/nzQwBwwwpEMGnEAwShzpNPVB0RN8364wn9MYk2cBorEhsX7Ux6dFV52n0xLgVQPAlVXc6G48Nu/RG8UZnkB/YqvuziqAPIbxX4iF1vOoL3FMO7LVDOVbDNGk98c7fM6V5mjSMtRP2Zpaq09bG41bPl3mEegIRIf2jIl9VPqBl1uoTbsuTo2IOfEbQAWKyGzpq5jUJE3AtosuWR5yG4JFn2VYOYRappdfrZsiHbyXgVHCWqTNO3pOMogYX2W3VhUTM1uo/LQ4ZOOQVuWJoXsV15vq0O83wjVf30LcoyZSlvaXi1jTKjuslGns6VE0plaNS8qLtSd5QHSWxGu4QH5UGwOqfPi8OeFl1KuikZq7/L5KXKtDMDad/Q85Odl9kcXBGmBjEcww67CSvyjYW+ZRfGuGOZxGnygof+4hp5F3ux9bw1xw4wjHqbG1yHcQkwF3Os6YyYyFsUSbqhBrZoqqMa6mxrCodROWtS9/5GDAVGSREw3dUF83qem8pcjKRd5TQwNvzxscbW3GTubl2eNBvqPSkoRn9pzpYA03QiKz4qarqAFK3srp48PPvlHcn1EWzn5+STtJCXlZVTCKKVnhCr3LQ5EI7TMLlV3yDeWchHUEfBdFR25FE2nvZld16+CpBZppYxBHKfWhjxg8eIuAsG41xTguMIsfbmUZc65Lj6A2VAExnDcosotfB70jO2WJkwORhnDjbSn3sjEgxvGYlut9Ui1+h1gGhFAuqDd9t1RHsw0YW4fAxunGsaLqgkZB7mGeCD/JE8cJCYFBOTo9Xc/kNldzsN1j7035/Ocbflylm4x/cuEjN1PZTB2K/9GFyntaliGrWrTeDPRBdvNu5dlisivnWf8FQQ18i2zbSvchUtk0lbJ50Xy4BllNiAasyXG4maYNC9W4h5fyB16eCn6rdzXXlDV9u4RxDW0NrfnUer2UcPE9S0zolrvJp9M2pXGRLLSvsJycxUuy8XuK9Nu9kreR7Bd4TPp3Pzo4RGfTeuGXstRKgvbTveoedUC/z+yiWrew9jrUK8yG+EzNSN6fJVxts9GQFzqtpY9kTeLkyO8KOAabrVO2Cgj8Sc1s53JwnxANabnkYWsqFTAPK7VWf9vR8Yu19lxo/OSX604Ljrb94DpHxmxJbMWp+bB611pCyqZEETp8OJa+hLyE2E4yyviaAy65BKLkZacU78g4zkbsSmj+Qt/TSS+Vt83Z9jRiQoABM9X630Rn5frzslEO9/TvBlVA6aOqLVBnJt+YPvrmtHdvyaptOFvOsJAzfcLm70/pzFnfUe5bT892hC8598DGzMO2gZiktH3B0QsrNFf8hUhNv0g0xCdMOVW8vfeBsTTcED2YoIFs08OHc/3Gsv6Dq+1rMYbvQoQcE04MTJ5GXjsrv9gUebaV6uuCTFXCdVZYnaZkAKizyTAREfzEJWjeUrnY5aLF5fmrkscVwxGhJKioR3pKH+9IgOpDjki4E3IpacGwwucl8g5ZqthoBQQKSaTnHCDIN7JsMxLAGASPcKN8TFL7GpAcYUmuQiDpZ75rcjSj0+WWHQBQdRMSodc2Q5VWHzhDmrInqIU3a5uEIhJpSEig0IO1gJhnLANuAEQA3ZpYIEuSplEt808oIrKxMAGikpTCP0TC2DKS7zQ/cSooap7JShSdzYxOrBghappWpIIG6V/gRuXwYIoxci1u4NSjRyCPIAyiYr5BKaoc+GSEptTN/NDRNc73UoWBAT4xWzEcMOStFLTlGMGhwCJRUsSyl4HO+2CYS4mHMASmSRtpALy9DlkEWdI2Uh9FgllHpSoUG6qsnTkhD+rISCBhPgXr/0EtrL7TZS85xCqXvuzafkuTaXghIaCJw0wCBCJXFywG7Ihpu/oT+9sDwKpsawMoIDGVQhgEE/YjZNpDpEQVRrDbGssyTlBwhZhJIER35nAgbhcsyiEKRQtAyazlwRWQMbDFy/roBIh6B9OxIdPhbjxtRn6lbaiYps8mmk4UjfvNO2Sx+drXLk/+rL8z2OteNlWgRg7zsXMj461ldb2EheI3Yl3Goj5CN2ZZt5DyrwoWDmNV+eW1DunDxWNHX68OHkN4jT+v6OI6RhIjGt15K5wZXmL0M+JLnVDGljLWnmmzXy2FTpZRImqyUbXwg8sii8LpmPj3xzic5Nzu+qPerOtWKGN0zdl7Kzn/VUEPbp+WTb/AY0sfnYdjv6ulhOo0nVjgbh6dCIXyVAga5rqRIRYNsxsVB9uKvTiFriTlGa9Mny7+nQeeeelqZnOMvmGB9QDhK0FBqS/nifUihsbbWn+L37jiInHtoMclFlnEoUFQvO4NFjXzd13mahmEcUwKSJQlq+ilpLxBI+9ySn12kBMB+RGqarpU12V14zlLzgUZ0I2yPMEeBECEE7mSYNPhXSqNWqLRcvvIVLFK4AhIBL40I6v6y0auSahkKT5ipA64oNdvVkBeytzNmvOKMZaecIMA1g0LvNFPLonQz2A4OIyMyvMTQDizaZqJ8sp5IrmStkUqysCEQrf1N0LEtzmIpg5QijMj5Kr0XrEpaeglMTcpItmZX59YI/Hn2LMtgAHkuRNna1kQfZqohxF5nnBihMXKTD++of32vAAI78+Uq5VKgc1OC0v84dNH97FcUovYNz9ZOFQY/x9KMRJi1ftXqZgame4aiVZCLWo/W5FlNZknJExJFj0iNuM1GziiVgXgpmWestidt/pFGSIeRx7dlMrIH/G82AbC268GSQdLU02WhKdQZUHjWGuCjeADS4N09ODk8zhV69twF59Ye4MKabxEaY5q54PDS7SgjZFtN2IRSY5xG+CDbiksKQlT54ShiBqrmi1cds9hG4Jbu0yl12AohV0YIOTJqGKimxwrGzQqx3Uperw0rDK064esF4b2MMgN9oOOwZLNZAbKj6DU7P9SdRDzePHxMNCZJdsfoG7gBHUPJf9Dn/j/IXbYs0mv1srljAaVsn9jaybAkELL8/01/GclC/zO6+Pd5ELY7eIaDJqVAayVIQDbOZQT4kKrDMuyqgQffsQQE3nQQopOygaeMEWKOhEGmRNXO7WYGjwPWIqXE0zegc2zoMhRRuhVDiie0PuIB/ZGbaJ0oUftWgJOh9hAhVL58XxB33eurAgYOWbeWQtxhOmAVkPSWUYrH6y31AFv/BPH2QuYrKCn09WFPJ/qLNyul67mfCD+bs4Wim5SoB6QsC19YYQHXdBdjXRyEOJBakXknvpj/zr340vWdiyW4Rgnvout1WZ3rSmzk7IJSzoZLWLMO8otkTt7n1PaG3jonMTU5saxfEIjZfPeHyyacztn7+Rq+f2LRszYBV8gU4P9dJQr98Xg/l8PelqACKNo1aQDAkuuy2WG7zOiemgEpaTloVutd6we0q4HubDttljGsHpaT/zaZ2gQrmWtp3yrvn6J7bVtV3Tqa3n7jXET3mzyXY3r0vvgf7Ucck1KZiFZjbAMzvMm1S9x1gXXil469+CY779OYtjaa+BGe1reu9/EeHpO4D0xkrioS6ePxuH3xgmBNc3+WJqkw2UZJnKhB3V8Mlo5k1rqncQlxtmWlZsOkdwIfxGWIrlGDK+Y7zO5enHawOFsNtappf4hwd0IoiM6qTk7NzPVlnu5KdYFa49T8MUgdZXK1JVHQqGl0k8F5VgDTpukZgZBEMkZsbAhLSLekQhMYSbVUSLylyCt5ghSEXEAr7+urF6yjEfNYxnIrLWhJMjqMmd2UkGBYIGQoUKwMaObJM4G5OjRlIHBmL1fK4ZX1T1+FaHw1heIDgnTMdMiby4AO0k/ckh1Sb44OmnsyR3tYjlJlpPX+r6CQhndo87CkOzoxnPW25lzWbNmtxGLFAM6iLJnqfKFMlfF/DIBEdsGBryMlwIRnri4PzFFm44ocACaCFWuDRTadcZAn4CdDyVnrMEZjMpjAFJopeABFALcKgI4gB2uMYJkDWkAsQgkICFENCMFvJCO3DEJ0Xou+CCtB0KXAl3wJyEwwshL6E3jZWQKSwAkyaKEHCKGFC2yA4Bg4PJLgKMITUYJXEmQiPB+J0MCA6G7lKKk/4QTUkWkGUECt35VAJNEZiRQo3IcQAED6UgiF42vYb4RHPcb5+aPfXE7VBmCiSdyuq1rWNNd9JIaNiJ8o1JFWIsr0yOTs8fCa+E5LGbOmb7QQam7QGo9bllu4Q96i2ocmlVe96zrQTUOnweBGlNcdzA8NUentjpd5su9Tb4LboElRKvCkvFyrYetWMQA0ASxTWhhZh5c+Dz7XAmY2OlTfaHkOPw9f129Coqs2hXQQDm5aIo0tZ8IXtKN6Fa5iStBBBqxGUTj359v+9vqwe19KtyT68iUpmYARGDvVYaaIDidTeCT3x4VzluczAa6scSRygkf1fu11CvQk3QlmS1M9Bs997IMU1LaIN4jt2w82tKI978fXX2zbP04reJl9e7/GmGKZnx+n3yZFLgsdMR6XCovdq5nfkIeBb4UOiFWBb/3MCeCqvsW5jOaI8VPZah4kwBO+b/B9gy/a5ngV6LXYl3pJ89VvGaJMujXDq7ADY7ehQtFEUwAyU7Q0VEgbmbNY64IM1rFI68IYm3KI8TgB3CX0c0UMy4RxlBIEmIQktkjjjbvUuQxQzEoJpTtt90TjXIdov1dU5gC7/uZk6NTuy7IU3iH13LrvVWoRMft+FODwrihYOyUW525s9dhp0BVlely0L2VkQ3Y1eX9tqAvkvlwUA9KsLX5GFVRGnjI8XRFpVf0r9iT8LWTuwr9wkxn+zudT+NdNuyxr8rRtibzIpTEuSCa09NFIEqZlQ/aRjkG92FCNEenpJWWB0wc1TazH/0sqm3YNNRS9+15eMb1XlmGUddUh6GAVrQgWW/oFLGwgUcEMpYLGvMr7hC7EepwaZgmRZrxIimgi3zYS1GmsiwDQrWASnzqalVHVpOOiCvpR75s8aIAerxZ+17AbWW5T2zHRMUw4q4NZK8QrU15lD0wZ139zXUdQBoNreTqtZhyPbNKP8cAHnfv0aB8SLLStGj7k+a66jwiYVOMnaQq9721q03dvtSGTNcrkffKBTNCkoldhh56mp2hRnibOmZhG1DDYyxuIsBuVF6EYr+FWfQFQvoW4AqmZVRsScIbiFQB4/43kdamsctOawSjxpbLO5w1DXePWuqAuhL8pBqkeA2Oxb5rAbdEDyNqewgSpu4vCqOzTkS7E2g77AhlqHiBORPPBm/rppmlVGnfRbIOfN/cVaYAuHiW3VaV3ld/uSQI8t2s6vvMhqAKLjBPnOWw10o+1xUf6p/vpiR2w+KXRjVmjeCapSywMBmdKYZ7twPgEgQUoAe4PEjAqWhyOf20uzIFxYQQegZGODn9hWnVRtjd2K+vdMS1ud1W4FJPaL056+BkJ+UwjQ8UBN6HrzUNsy3c1kM9NWO5DIz6TcCukbxpf4qnceT6IbE4PKzm1GNI7p+nz0ECsTZEQQNOYYGcrDiD6BhkrgBlW+T83fxkSyd42VD5SkNyAxWmMd1L5thcSmKPVclBZygu/kD4Ymc6FVnYFRiPYOV2AUV4Z+9KJaattZjDx5+jWoqp0kqQXpY61k4w1gAILGGOHITGgYRhCX3GAzFPQxapG/ymY7YWDmHygclvcB1H7OoB2wFXP9wPrgp5AF4jnsHur61A2xMXNddrXnQzg9hRGi/ID6Uk1pv9hMMOdYqNLeWRtr4vkRUGBEMDWjkZquhXyPzdbaqPyBMv5D0BajcMgvvMORRLw3+KG799jC6LN9805waMW7IAIVHq65WQYlEDc6beph21NA8y1OvWTYN2jYCXw2eh+3ZngsbEO88btxjXAqgWGqh3ak4DiOk6whnOPMs2uUjBFUCIYf8VQRmbURqDNTLn/+IFppaHPcV8ofFBhX6QYYIqgrNU1bGqT2ubBDbCTA9dyqvBbrh9KhNn8AXtuvzCfNNj+4qWsDEG6ngvjyIbeCCbHczAjnW1BS+kD0aioJhPOTJVwUsyfe6lj9eQO76eEltDv2IkPYoJIAGKi4CFgPO2D2LbRUoN+SukSXlb/yB2EWPpmCI8SRAM1KOrLeKBdRunGXKVKtPzbepkfgPUsjagpr1ywlAQ9HxHAGMoLil5XSbPxZSssQVkC7Cyl7sM5DRh4yDg9t1KGyV6ChFBouJd518HXwSn/FVwVulJEGwp4dJ3VudTqQNG4ucrt1d6BMSJvuX4kcysLUWSVrJGN5XUnNJpXUWhruXwHl4iDujB4wtJnhw312ft8QZetdL0EqWNIyfxdJZhhDkpbGgMuQuY6uvQ2YHrJNoPmIgwyjDVgucW6DIvAybhw+am47he4JcKIsI8wecBNq1Jht6Df0AnC8wLbFiQkzAkOpdu0vHaNZucbJlP5kbC9Fouxeiq+ir1vRUVTDQ32dZBuOsS10wU4TzN9EHoPSSzdVWBwwref4WVJkbDPmFvrq9wcyhvmKPWev3vQ2UtljdYgUThJFzhBsi9MiQ9m11fSC6JBvvRGA+n7hIo6GtOc2NlgueqfXMc/87Iu6CpwO9Fxc8eAU7ZCqNyuED8NAUMvveccp147ZDzpBUp0QKAhukWjd/BHFZrTve3SQ81T4JkQgjKOzDQrCpH4MqY1hUnhklVJp6eUUgP9MAQ0AymTfRBHgNVtSfef91kHASly4vENTj02tebN9fVSiYVVCxNhFjkSumVs28+/tSxCr4TxUtHw8aFv5snfvAmg2txFeQ0Q5rnL3LGePCVDua4Uxp9WMZYGuRZKhmr30j74KTl54S195HZj8tMnEzTZZwXqjRUYVnEwUhku6KHc+rYWQLoBShJQKh3zdZAG+hwbwA4NRt8TuTyanxxHmUkufw8w02ucz6cgy9JNYQXIlyR5bhYySoOph3pPkE0fV03St0kYWLofGhyyq/JM/W7Q0x5khgYYkUrQ9CnPk+3Had3f7kmaSjd93rygyXOzqZhAant00siSE5qpN5hiXST1eEijOKkWySoB85h+n3S3oipUp5DHyNLIil1Il64oePt5T0iyVoGxD8AFM/ttbr1atvhogFHuUuJ8RrEJ0X/Q3Ans5mfPS0WrXBJDZbM4ypCskLZidF7HKCnUEV0S1NCaKaMjIA6ab3FJ4BTfjtJMVA7GtwPMxDAkCkJGOtMALvKzBcTy89JdzUaJ/bBWHQMmgEVgQCiB0lpj7BKy8aabysP4tqAWOJAUFyh4vA+WtyOtFDLSoZK8g5kzdAJkVTDR7jj+DS6R09Sxi9JlEoZtTtleLv1UsgVAP315Du02PljH9jOmJqI1hbs6H+S4sSvGUxWQd+1w/zbF+X5tsnZCwCKrHSargqAaOLQ4CFbxZz4QU35xwhHPuPViXZ3xFAz3+XO9TGEU7UxGYZqQZRCalo5xqJj0UwGFbu6KRvkM9+6+5wBbWjlY1rFesArVUU50KpMn4XwZQjhIAJafrRd8JbsS3FV1pOJL1oSfKUayei9YEW2t16OxRbEBdfgsfMWVwXjCJ7zhdggMpDkrXytr5pvRvpBRmoHf7pE4JdcLYWF6d+cExmWvGJO0sWz3+XV6Btm+YLLF7AUQ3q2eB0CvIJAueXgML1JguxAgWcZ1xRW5JWREqTBptku0XswNPcgbc3PHWONECoXCDG+snAuQ6tZryqYN2eMBqaeCnr757c22Qu0QgdvyHeAe41zHYPpW+SR6HPM79SUTtDpCq6APKgZ3OcHnNcGq4AuAHpT6L2UgpxXTXGAyoMm28hMk6VYQ279nDEHJv/uN4KEZaXT4100I3g7QZeSCurr/Dp+/pT4G8L11ewqVnHIo4Vht7uIpeNjgFS2xbuLfgH1NUh0d0A/9OBN0SC1ZxfeMfVDiNJc97SYgK4rD+iTUHGCL7RnvhljKbHejgLkbtwNi6Cnhd/mLKpeOInr0eR39gwABqDcmXztwT3TnyklL3bKDUDCA5BpnDiw3+jbeayAdL0/KQk9eG29/ItqCo2R6ftgH2waCRRZcADCxCoeNMp1MV4DTDeXiPpyqYn8vU5qTYzSJeE/cpe2RW6VKoFi6q1tR7oRv5XYXjCx4qA80HXQ0hqhABBg+4d4SFTPxmzVkgL64YbhPT2iZXUG+jjbS90/83mYoEaXtx2iUCqnunW8xyM1vL9Q1M26/ao04TYgEBmWFJ4O4Sp94/cu/W40Cfc+f/4IknFuPHJrfcj/9Yzj/KZ7tRGAc9kG9lgGQxT2RBx6iVRuVgTdNglPZ3f8MexKPJ/e47Wu6OkvsbOtofwuhNRy0MV6kVeEExaa1qryimo7Tgna1Ho0T187TwxaQR58GGmYYkK3Cts9lc46hU6z82RtUx2C5Xm+cZLuS9jKqNMzlaTeWyjq7IX4SjANhEJcWz7EhO6k1TYGLaTUuagOyBftKpHrgJDoT4AH9lX2wrkXmUGyKIlFxwlFRK9o3FPOyDzNbe0EBstKa9t85sZctfWDistuDL2vDqIQdlGwbqhBVKDgyb8HpynGaN7MVuh9CFfDIvpFWsaq79QGAQC7UmHHxfo+hARieIV3FaBDgq1Ct8IcgkGGdSlZUC7Tm+FgtcqctCt7A3hkrHtqBQ5BVBWUZduZoqGaWGDjAKnFk20Cctxvh3iJJZSTedj3kM5p+cU/3vlWGZtmTqdIYfsuq0jLlSlT2x4HuzzgQMMhhK6BkI6LbmVhdBxBv0kVbj5OmzqBuYlsUhjuYHVTAOU3RIG5WARu9LMhIWfRBJmrAvnDo06ZcZr2AJZTUQxzjsqR/2/x8PvfB+EwsYotbUaiLLshepfu27/sQlDDMSfTz6hkA0McRKkphP9vW5FTpDbZUYepGHandDSMRJOURSvr80somzqbAeHiHW742DJGOWsIEYAJ6fWFEu0GNol2IpzOUCFswnqojlVewINSweaPLO0n1znTSEC+eysI42Rhc0r8uz5Ouu5cASvhbiofmQv3QQBYYHmzuZzjAKUmc+pyTTKaC03MutpEXfTElTcy8BL2T4btEn5z09FzEvCz1s9/lxHxLKARvFKnPdKTW+9oBsyOqPwnJ8QYXWOITZpHPA6eGMNkYDut5EeZrunRzqXEVPvwu/6ESlPFM0iFJFi2I6BnRjpuYpGWRVoIxHreJnddfwRgHJt5Kq9IBwbhhwEueWhECzFPIXVCQw2lvk56Aeys5mRKJp5Gi5fwGKhyVNM5VAVqVf3hi54QaFrRULDKOy+ZXn3jjwqyWCOTCRpvBJrmgiuBDXUClZp6CJWytIrfdWEvB7q22N5KSKLyoPWe1w9C8Qs96UpYa8KJyjolvhvwXcv3Mdc6TwUrC3WA+4D3+gnJoYCKyxYsRodz+HM7dP4/ouRWOJvk1120Dwaw2y3+OAahXUD4nMjWs/et3b2uo6wDtkOLJAZ/o0o+SGdidF92kBpTL1Niv3qEphMLbp9RJttdZwL8qJEwwKwfSuAbWxiAJBIXyT6dpvHssKEC4YN6WRrlm9wzU4BO40K8k5ChSWrZB0sGIoVzgk27xNLg2DctWCXwEkzIcZUSNfqmq7TVXHFD3IjN0sV6EzEkElWYSdkoSaMxgNCFC3bMVEE6RCc9QHtkBk0BVIhH1VMFYxMiT5E/wO7gtHVyPam4W3UT/fjNI6gDm7gYDBnulQ5L+dK82kjtEn8ImKcbl2gpw23Ejv/g8Q/MEB2lPJBLIEJzUaw31v0SamGoYAh1yqqfANhJ6mZvcMkTY5gviAgCEJImPvAB0DkdQPIYuog16rXID98SieQRaBGApqaRLyDqhI+bLxGBqkLdSsZ0topZa7jo1ZHNFbc7pNzljCaJhnVOfdSMToOOHHTuNAs0RtL/tyPsyXJKKCS6HfnUuGXF1pQWgch5FgHzsNDSwctcugDPdagjrhvxZKi5sP6Ek0Xefntg0aAtVAjw70B2dyW3D52tEm3aA++0jNDJbBzK4FYFGjLU45xOwiK4GgqcziJBlsSH8YbfPikiygkEe13pGBiIMvsWqgX7aEZg6LTQFBex9tkVapNNhOg3kQbJ5EcAWyCllZGwQAK6Kuos0tqXRfQ02GgSYxh5qLjVK6OwuC+VOYo+bBEmwizgywgr3DSZ/0DYQiCkdNgpfTAScbm/IbYyCoreVlPsJ4k9HG8hDWcQiGTAIvwQgVTW9mogiVLAkYC7letAjXNmogkj2nUh2hwDpH1+59YpW1edWLDkIGoz4AZWeNgMvF21XB4Lm1Zwlrcql4TT3d/Uf5vlxGgNQne4z3HDRmPGbRO0nCwcGOwU0qDZAw2o8PPCavObywq3OIAFX8NKuaTTFCmwxvhf+2CNt9vlP/Wyme1+e8kLiKdhTnAR67WbjwlJ88MK4RqcCmGvPe79namlAWOgolFfbsKI5VLcgwgFd8tQAPKp0xRNeEmx6YC5a/wa3SF/LHYcm+6PuKNgcEFhCJGm9fItnLwvh4dMxKDIdz7goKo48Qr5n2FaU2n/mg5+Ltk9WEFg7SXqxCmh6CdrHxeg3iw1IYHkt07GajFp7RZxclhBHxRZU3s7AgqSzr8SyYR8xZ3/LAYELi4Al0ag7eGlD+oQB1Q+QUefaR30bsVdDWaQCGpthcd5rXzjTZDWHEVwJZtjgMtzJeA2IXiogyEBjheG9+7LMOY8PRikCCrMm2d7laDa91bOxciMLsC1xTpKRM5SoZiQArgno5YBzjMdnAG5sBoVDW1CxcIUc0aHh1jshC305JHuCcLgb4VyGnGBn+WxET4RmGJjPFHRHIpdxPx+0P4QUGoEIIAwjs+9vrq4/b/AeUL9RN9phKfomTxG1hKdCR2A9hIXIpBvcGSw7gQ9aqdvhbRB02WB+jsvoY7lCgtAhR0IKjiKPDaM13nKb2XbE20Nh5bgWg2PMzArOm1FpSaqGBjL0QLpDpj+TiyfZGxakq4HWucq7cTLojU3J7mPgpgGIT8/lhUDk02q+QxeqDYM5g0HAorMTXE8EolgDhoOKJfDydh9BSUMbH4kLh/Wg4StcOnuQ8ga80kZgEY80mpLmYPnQOFbAKFJOBWklgUGcUq8qHUph9xtHPnK/Tv6xN3RU8lExEWwDptnZ/37w6Dr4CioMd6uVgVVTahjINXljPk3ufx1PQqt6WSkjWOLQ9I4NeXVorM5zEJME+RiuUVehxMg1geYTZQDLyEDVmoNmopWwPOFVpRjBmijhbwadZvrhrKHRUAxGm8E0bshx2qyOAw/aUIf8EHmWkqghYG1x4mPLdMKwTDip0QCo388XtDQG1jNOSZk8HdJREI1NvOuPqKSMv1yMD8Wn4tjlPqYNGbAiHOkcZaEKFc7BlCepXkG+6CUqSorBgx7DV2i76W00BicYdeAyHjQausWSZi4uiz3lXt8HIzcjYeHcV2xwPAaPwED4U1MPW18Ykw4ctIrsJR11UNB1Gz5DC6LlUHa5+r72UNFyaSmxRlUSi6EVurq4TNjXLS25oU+dUnql4hnHjUiOB+lg4VaBOpYeLc2wocccjXfVZkBfEgpOHYWRed8H4O0MPbWt9DHDkflyR+6bbA/DO1uPREQzFd8KE9v9t36IsB8u2NPDnns41ph73cEH6HNjEkCboUSOASj9zcRpu55+uCkVHbRo6en7lg1uiWI/45yD8nRDEbiEAA3frqKPekmbTj5W6bjSQVzUrJVA7l0YIk5AXdqgFb1DsOHR8DmLIEHGireY5gRbgMd7VrbQD2YoN+n1SJgIPqqAfTvY3xrx+AoSjFhbBUWD+sbJSQL7+bH43FReevh9ZEXRcohJkINRUYbaTYkTlpExBwP3HD8eoiR2BqmK5HV3bIiKpsGo4UB8wBkSX7I4GXn221X0pDrvmNIyoKxIKw+WbKh/0XRnaEltRS+JvwBezOkunGzV4xey4PdctjFqfVTTufjGID+fBsYsE2aBXLlnXsL7NAqbJk3vOUSLpjFsrommWbUmmLg8lHxHQxKWzNJ8876QbEt96zS6C5zfrDnB0W0EHcwDQVAxMNKu/VjAmkIWuhG48QCkTW14uGQDU1fsDEE/Qmj6T9Wrq4IdZ4fm3SFDQniFhxHcSVlE6F/q8mbUmIvb6m6KjajcQR+r8DaMHq9yhkwuUAA7NRfJ5cbnY9sx34GtwgeThw7SvAmS205aiMACkKbq7fpCt2QDFB9JDkJtfagrHoB0JP8aG9YxqSZlHMzmnijNuP5S9rEFWS3Wc0zS9kKHVzbbHZfjK6cy89F275bUz01nggoL5DhoDdc362trRLNfEzzJ5pz8N0jCG4s00SuqmHgaDGQty90Zr1c4m/AtV94FBKxpxfuPEjSBS8aRj04huNwvvPLSnfguPUudXoIyeWFjfVtD/YMKWqb8+RGz2Kn+fwiv0W/+OpE4N0IiHdjaJ2QSZcBPH9kyNe1RtNeIknAjFKFVGisE44C8YMPVZ2tvGhR/W+LsZkLiqrRLGRnJVs1XrULP6lK+9B1MPAmf80KKVjkk72900CLzkl+fBeAIfm5400H/+J8T08YkicCdoAcGkvKiTm6Vi6g1ixbozhSRs9Sp1RIyG/zYHVj8pTN3g2gaX8jr+MGEtZleN+cLgiIswiUFokNir3eSiJm/KmEMlQ2c2bXf9AA5cCI/QJiW5L1ZCCiO1JDrVvreXfCEXJwxpPicFVY6VReG5CIaPnatkYpySFoorNIqhZkZ587902ErbUsi5AWyCe0NLS2lTCuclmJr5P5o36Up3YSmSazn9HHuufC9ZcZc7fm7gAg4AsVAaSV2bX+XMOql5JAUiRSM2cMPichYAIeySzG5S8LlAO9FrmzgmtqerECA+p4mA/RDAxHSzKpjcOmGHmOYlv+8g+BiKx78S0bJHRTnRxEsv0nhgHQgteFSoCb2mzPhf7pYap7lBwZIpno9uXyUAtGAEsqzQJvyEGugi/IJUCYb1BJLWOeGczHAHd0sfYLAPN82k5BeYti3J1Y4xc1carQvp9l8y6GDUmVPhWyjX9zvOmLamusmuBykI32VwO/SO3MFuJjXB286JPmDXWb/ikvJYqCcZclExBSfv/57e1FesJFj8oOywllhic+2f8EFURV6Lw6gXEicoPqMRYwjYBzXUuBANhe6Oe+Hwb47dQ1Xo2Ypsg/5iceAo7/LBcs+XAsU0SVIaQK72FDJcp5kKKpLy+wIFN76BDaDfeY6LjLfw8+kWySUCd9yf7UaHYR6D92ndFndRZVq0mXKmdfNsvKibRW0bwhXOFzh8BaumvPXrjqvx3K33q5qvxWEu94WYV9mv3mNvwrwY/ATl/M6MCnRO4eb4U38DW5qT5/AN/nsYptvKSIEleQPvtHbQXsmF0WDd752IVctNPyO+MGcLouB/NMhWqwlrGCsgCPCcZ63c/RrIcuLXIBxSZANrqfy1hXO1IovILaolPld//r37L6r6Vw1+2swjn7zIk8LN2sVnDzddMmphIbjHMhraE7MJFHJ5ZmJMCFjDgKucr6pBrstfIIu36rEw1PaHikJxjpTZraaBBhHAc1rrK2VVIIG9YDVVLKncGak+LiENAg2dhu5PbcR5qMwWWoZvZK1QQFKzOrF8X54ZwF3Ed9K85T7EBuJH06xApZkB0yzH7aa4uiF7jrnxR5nOxmwM/HIgx3AaL1l8pVD/h4HXqqxANo6WobeBUZyt0ej3+3Bf6jlGenh+XelkJVtjUib3SmjiTtH0sjj28gW8ZQHl4+80lgpo6bH7AxnXRpwM9flA+gs5pLS0hk8ZOq34SAAGaHW0sUVm+FtK45Q8FVIMmHJuEYWqtW21aneYE2sMQKEJS/VwW8U6fKG4avjYYA4p3yxC+TjLeWKX3b94+BsHSBkHRs6Oi+LYkHSLdYT0G2+tFKsuhPkb2YfUxoD1oAzT4ZikPsdUUfII5PVJRnJYACyBIycKimYjYlawHuamCyagaSvPEaZr3RdwH2laKggSuF9BX1JlW89jgKHdrqd8W+GZvTW/HqHsEarWMJ83nCUeIv0DA42wF19NEiPVjqafWD01fckLaXLfu6Nqv3M3jnmfbFdTr0jBKoMabNS1gY+nC2eG+o7u83fH6QMg/Zx+pQkteWsdNiSs0sFS8qCQL6JZ3iTDsQ0mHhgHRr2+jRzaMDLOOnRewQc0KODgAZjQ4drodyj/oKjagWf+jhYBN9CtSfbKqq9mPOH97SqFg+Rx1vTGvYuNQURMyfRVDGvM+gfaJ/3wZvkyhJI/EFx5W0rRS6FzDftAJFZlftLSuZicD4qI20TGtM7YDycQ5TG+kQE/kp0b+TSwD9/tCjllCLxRrdUKLic14waw6WDpGmv+2Sp3Ooxz6fSTuGYp95WEb5BD6BY8lP1yj4pbNLbo8ImCehbfm2dwH40mZiZiWOLSr7uC72jRn9jIm2xeJRZbrwAnktiu3SGXpOXNZ0Zdiiq5VwB4BczRWbgJvwQ0/lAOnQPC4kZYdE+hATreZuOHW1vIxciHFkGHedHm6fldFvfNGPpTjSxeRUllixn+pPsXzIdHfYraUwyAyajg23gUNOYvsLjc4ipnR6ZgsZkLrTCOTSnsb77l1AYerDkA/t5jhy1qEUlcbikbM5Brp1mTb4v1o72TAFiE7XZHntj+Wn7kim7Gru7DE1HLZH4MJRE1HFkLQ6tSNHtyOIfslyk29fatsE58Um8I4dzTqobz7vt7aFAO7C6oac/IoarIt1tXd5D+kVrSXZpkyPcjrSmVZzMQ0myn50qJdtFl0mfQrLUdkz5KHhe2b0PQrg3QhwOYQBnhLuaZG2rbDwE3th4cofjOO1eXjVrlbuS5/BZ7GRodPzZ0bih0m5s6Z577y+JIYQwEEe7sYUVJ1w13DvcO3ynw9rLPnyV+tIL/X2ryhsbTzbO0l+0qtKbg8PDE7M+AUw0bqj2lkZZOhk/gutjhgZqpNWg3Vjho6J5SCJFYSBEHd7CW+YEYxhkhYchOjCGByG3pCa3GhtPNs4iKwPE5/AedlWsahmemH3vfL2NFwsfWDhN9RetcvWMNboHPjuEAA6AtKg4tfp7A8zWs+AF4aNbKZ8YQhgIcaoyhID1C7j33m7v8HYdDuGu2V16h8LDdmXkotLdjw4rDAQQDhBnubpolTkLDxo3VOpgBXtISXc/AvHEenN8dlQ11Go3MVbRrgB7/cDwU4aG1TXeVVNMjKp7OBrO0ebJCqakFwaMtG2lfubJTJ3cpMjrKfLBAWd2DKNxueaBk360p4yzc1iABJjqZT1DqhYKZ25+zv8ADdHC1EP9U4c0BRkm0BgiedoiPCUsukmyQ1wT98gOGAskGDC9bR0njM2LSNsa/kkANi5e1TjK6pDSDENtvKPU9J3Gv0sbJ0iVFzpGZ7vFTeR7cPEtSY0VuGR785cWPDTUiG+OS70kpFmsiAQLbSfe7guJw83+55xSdSzH+ESXNKYPOLRrVQwk8g4waVjTsp0uXQOpC08pKdo2IWdMnvmpkdkdkZuS8rHXGHQAly11Fa8so05DZbKEEtiHMDg6Jlllvwuz2gtUrajBND4DIiJcMXCkgiN8UUqL7oPFdRHD8n10zoPcUO108w769JNc9TOfbvhUDOZSnYHK/ugasM62735VbRN1g9QYM11sLxGdyS4LC4jg0gfyNsYBN3EvPcx3WlZST83Z1FzCzue95umSqCgQSZrE7tYck0A75ieKaFDVIKO6cCbGXH+dQuTrpt8dTIPKHr3M/yAKgCXIFAdrModJcAhG1KwiV0/1yEgvMbLyvsO91TI0GhUB/mIYBCP+EuQxm6Lln4Ty9e1xUn+GflpqXNG56zeqBfnuPDRYCCNM0pOJMBtuS4Z/A5ATXz5oS9XxYDfN7PZvu0TKhLX9MmKOrbj1LmwmuM8wTd7Sa+bsVo5wm/RFnT/jaaF0vonqLFpXpWPNBy5Z47BOSVN6uohKT0TCjQXdmJfB9igbaGVkLDMK+/EDEB6Cvh28y0pOx+DZOGXO0F0vBPO1qdMpQMsvB6+k64o7IEIxcnvKGF0HT3HgdYrwGMsuc/1B+a6uqxbsKexYzFa65zqjeh0UTDkQCPXgrilwUK/mmKQ+MeD7DcD6oViYjV5iXJuLgRZbyUSj8i5NrY4TQj9u4L4alnC3TWzmaujHcpx64AbjOTCWxexdtA5gsYvaAOqcTzbScur44QS9MvGgEnmFeFFWdYqrBTjdd+yt3C4KT3WCLe1ukkR5x0PvlOpPAHrH9FoTwqOGODEql3ejXkg7klD/BZJDSOr+m2ic9UEBdJzZlsU2+jER1ppPkZM1XJ9pW9iVvHwg46F6t3ZvaQYM2D5tVGURNamZfoDE3AbAnSBSa/EFtDuqXLixKDP6mMrMMpIrwbHB0BwZOE/PiudsgjjKb3rfi4YIfrLgAuPLK4rFNoCJt7z30NSk+7oJICy5g9XpiUtrY8VRfrukzAOLoLTCfJBVZFGEqSlOu++ldDxQjde0prOXCwP5sTWKccZG+AjOAoRxu7FPV5fa7V0N5Gk8UV+dvn8Q8+ZLQWA4cUcgD0sd74k62QrMe5JDdLGysOC7bSqc2IombtLVuE04naH9cgX38QwfxK9/+lxS695SPn2KOy+qn4sWDR0FrqsvSQcgubq2VO37/ImwFY0xjChXWZBvKpeNMRHNSJSUMGnQjTBUjxr6Xf/7gPooor+hNeAs3gFBD+FmIGyc2QrpOKzTAZ6Hw5P6fdLTiYnS6jpaQR4e+fhGf9ITd7wkBKvdSMdXYR2Ikn4VQ2rAr00x0bJvFiNAiFeRgKPkbBRkHH7VDDFxxJPWHHG5IWQxs7cAo/aazLVbJ2cNwnnFdcf2hcrGgPPSZAfeyo4wDOELX7IKI9MXKR+jtYv9dBVjGraZEyZLaIbLocRUpTIKsMxuZOVC+AozFvZRxqczoiCNNPrhfLMVafiLmKKqLtb1+TrqTBfMvXJq5Fhd+P1iaRPVtc/nCQ9nw8gbCAE8YvQ69EwcetzXeCFXb02pJP9q9jxVxcups0VnV+l5UMNNlqz/8/4Cf/wrfX6PTuFFRbXSXB6Cp56BEmFUcAAuY3bfHyPA9YDLjMMTraPoMG/oaD2SEe3Ga580tT0M4qC9oQrBva2C8YYVCf/0XNWdjAoNV7JvwrTyIHvX0BYiNe/FANFsU15/+inZq00j64J7uuCUm9rojwYSxA7wB0TxExWSldSgr2voNrpSsCvHvbmwLiDaMwjw25EGPvPtdSkp7rQsDDdGu04fndwxTjgFv/pPjya2T9GvzM0FKD5XKl34/WUziCDDEA3ZC0TqVi5hzAxhe3sMctnBNzok+1fxVPpz0CV9RVWc9rdyq1mvIM3Rc2RZU+O3HXSncs5AQRioS2neJFbp+sFoDeh81q1PVdRiPsBrd6z/FQol1bkz8EwCAM2AfEkuUIyqWRh7GXVO450odb/HCfV43PF5cjGT4fmLCqAQhOygJG7F1NqFZ7xKdRH2hod2obFkAGMSorhk1p9o8uDDWArvI5Y4uQURUq5G2bobucBI1moyawTFLTy/ghPojgquSnmi1ypUMa6SRvLqjAvAmvHKxyWgKmcz10KsFK/k2OBsNERFq7RqgCW5UHrdYya/Uv2WbR5X7Lm5OxDL0wg+X21zL63/B4qjCZfFcFBou9AAyhV3EqTsc2dmlYYsClgI9voI5L3OKnSVjtlz3Rvvb8gaRGBIsqZhwONfmBfemFL1LIVY3NlxVAucX+HtLAZAdO3o9kg2xJPGg0AjQxtGLMLuxMzp+RGk53pBck5+kyFkn+TbCt48MCLZGMVv+xLwBun6Dmi/efmkE4HT0Asfb5BcEa322m62YG1Ure3QjmRe/Zwuj7JG8lWUZHGk4n/ezxHJ3IJSs35deddyHbCrs099q414CMgQPrctNG+HTDR5+sAgYOjWM1SVnxUSwlCLWlXQGgOsJie9Cp43fBEbOFLz0mGxBqK9Qx/whznmVZ3JFd/wsG00Tz+8PIhrkApB6/NtWdSAuTBOs39MdYla8nAoVo+Fw3wU/JUC0ZfK2RZwDmyAfdSsmkFClVbXqDDHyMXfuSv3p/mcN4ipB8oH3IY++N1D2T8vZGcSrNA/vLrj6cnZiy/sWZIBd0SF/yb35X7An1+P7G+MvFKhPNIkKA/Va6J9h7uY3iZq3hXDxW1S0w9Oiid2x7iGAD7kEPlNhGHAb15CBjQ1F3B4g1xjfKapHdJhBQQokEzUXU42OhH9G2niWlFrsCbcFm1jOs3g6pee3q/XQH8u/bJrr04cgueLTh598tf83rSIXjIyGjwYddI1uJGPAbtp3H7+SHbJ2lOMe+bf/r8HmjQlFAlth4/IH3cF/TrKKEEO8paNv84SL3FopxKwgVXk/oMH/9vU/xTTf/jlvwqPg5akevDF/ay5aVfQkPm9L07vCCl0+ZBcsSjsTbkewe2PKn7M3DAbhDpqGuRsgISAM0KcyvndOBw/J4YgSeNqFMfG5pYqrK9Y1bBi3+RtoVJS5Zgp1MjRaElookwVmzQ6bfVlmxg58q+WItYduYOK8xbKHmIq/nFPsiIGkOReAF47pDgwmIJLj0TWMjkxPlGiPCCiEn4zpTwVI2tdIZm81t8tWpGrwSkcW2Nk8lV1utBvWnVsCcwntZx6G2FoLhsbtAHK8Hihdbs1guy1Pzj1mTs7t5Iuv61U3nfyq0Wb/FDaMjJRscAYL/ifIbunYckDyVanf7ojBBcdBFy+sSR/eX+CRYyrkKk2LKStzAzYPMeuT3dB0XmeKkQ8lwaAE/wuCSIFX1M7tD7wGhxwKw+mDxXbHE9BqhEM+RqGAwCXHAsMlTX5keiGf185fFyJwBktr4pFZ//1Key7bZ2owHDyabHIwZzvGPs1G7onCJT1QzunsSgj/75XCpj/u7D+wxT/xs1/tR4dlrK1yMw6DMxXXTualqIZvfObDCuia4yEoyI96lD6QUdscS/9sKsQYb5x7Am8MZb8Sbq7fcIFAr51skNX7uEdKYOK7MuH6tvKfSszuXDsP7fw5GNoxKwlCQ7Yq1Gtm0hsN0nEBSWhbYTjJcEmcygL0bOknstypTYcG/FxXQQtWSTZ3Ky2GiDqUFK/mKUIL7/M50x8viN/efg171LDhIoMVyAkPXc7YBhX5AA/JNuHASU22oAnmMouovBT4TZb6tQIfbcPiLVekgow3X79qxl09Ew8+MUEywDrI8k3v1ngTbUMQo1iKUzCPRmFu4lPa2pZd/aQerOXw5Y/5yMkgqN/S/rG2MNdJeScYEZE4NU4qkxbTC9I6CKhz2LcnX6MDgcWegnUTeDxiYoR2L08WqMndj3XHWMAM9U78eRgqZ7nbiMBoYDfNzJ5PyAP+3Q6/LBaGHQ5ZulSUY06SZlM08l08jZZJkjK6enjz6nWZmgzCfFl0ndrhF3tuAJeVwa6njzp8q74wnurq71dR1VC0e6WxK2kx0VveDrgsEztYCniXpR5wuMzwychMlJre03hbWRDRueeRun2C9vVGUiHpxXceBeZUKIyGJsTPwPcgfP51DUNkUum8nsxeQn7I4DLVcK+aaiv16/5uL1VDMBj2fl5pWXOZrF/gN7AbzyQPev1QqRAx34k2V+kIrogfJx1YWFzmihnSWFazHXfgpIQ0J7JgA2Vp7bJ7EdaVoELictSHtOKZ2dQulQgzAh+2vnzR2Fof41+keUvd7+1qeCZfv7AHQOWj+s5dLVoOi2ykWOlIhjN/tqo7oSaFwPmiayRoYmkBUrRw9xk9gajGv0yH1z8VphQlA6A9xCg8i+ZzjlaRowWnLqgFhsxEDp5ADnnfWltfnlvxU6gMnQtJgQNR2rXo8MD03gSRyW1igt2FKVmCYfzZHQaqyMzqjblVbTsTNKTcUUfS4bL+jzDOMk0YJJivlqzpOI6ruH/LvSG1HbuaW89n53c5Xjh+7nUT9whRX1G0NtyM2A44/yi2VHS4XypuCOHPRq4x+0rAAKtwZo8NDOyfI3Glnb+r6igPSqfdBXS5HVISXksime5UDQlvjrN1qbelDOlbyzdOjr7vlUIeOhMZpXpz2DVc7HFFtRx/KQtxcq+Qh3rByaqA8tw7UvaXc3sO7TusZbed56dc6EsZ++GCP+HuCEKdLICSJtkxPrxl6vb9MRJ1VkNqm1XJ5PyXGnnJ/u76qwRKHZPLU28tYirYeedLLImua6IXZn9CzxJ8B5cyhcQw65qwXd1wJUH36OnNHbyLSfwRVdNVhSk74RUprzC19Kp3B1tpAw8NbbmAv2U0udB6Wm/aH7ZOdW1epG5H46nhFs6/5QisRr3ztJQBtf4cfZ0+dbUoP6dl2ddEI8HTZeoijwQ6UHtgD9rZPyGxp84Z+lZjkjMR2XGnmywpljgRyuE53IV3qGkbBqTe0TKa/TzQFK7daEM3/fvFI4X6KeOxImfWUAjyg0njcOq4IaLaQI/hehai70rPXl0+VUO21fICUUgGjHdNyHd4TwzdVKlYG0Mqu+4D3nT+rG+Ti68APCteASsvt7kF9F2TrVBT53ml9dtjGS/Ma+baebFPNpUhpLC8+9LY+AdO32PUps++Bq3O2JF2LNepHN0Pgu560xJLAK1z++CsEp6n8dQ8nMFPOYxdcVclaLwMhnYRLmzjxALUO2/Df7IPqEmdoyanNOAhxBFI22QgZQWHKlYHsfH6zuwh9Km9uPcJ0FrUougg6lLAgpn3yR8J2+leiMPGmJfTS+7k/TbsVrMTVOlf8WEQ2XJgx/jA4XuDAPhcDo7dZeKWjX5l53HqLlVi9sSQdAafVUeUX2n8sAJ43Tvn58/QUlZ2nocvhEt49wb6BtkR4s9HAmPPI8n228PdwBlzZubVZKWxeQK7vf5SRD1q6qK6e3SXx26lQYNWU6dxHhO1oXvY4ufKQ1iAhlLUHNMntwSHUV0Z6FcHUDsBjbye8fE/GC7vlH7tyi9R8vqYnD7tWi9rCirEPCuOAtE42V9+wq7gNv7hQ2XXGkRcbuntT2tdwdDgk5kUokbXlEw27DoJmHrsl/B5Ad2HcRKgVU4AUTbK75UiCDZ3blyYBTRyUdRoYuUKgs4e1uAg7N1j7w8xu3D8yf9b38Rfy7q+7ewJGhN4jKmqT7ygU+uiladvIZbync776smAquf3/2Xj4qK3y4x2S2rpjekiVwxzASrfqG295uixk1pcbekt2Mdo1e2lGM6gAponlNSMKhjLip1SZhZtD0CxHvJDUVEjbuUNZvuwUP0nrtVnNvj+lgJX5IDNt0u8o2VMKBXjFXZ7qv7T7CZ5mSKLsto+aV+1J9ly+LamzLXZ7ypcGsXvz8oL9RJ84+6+MtgwgM3UB2dVTumc44LAE+X61dNtXFqv4UPvIfWpsbGkrccEfe7y8htMvLB/XF88NLqITlHqlBf/Vm+xeNhwLRoX/r7oNzc9u+AVLsqE09HP7FjXCqasTBpxSPe5TuN8lDY6jKObMd8q6b9AdyMkZUIk9PI4vLvq7oXiWchX0ewTH4gt5dq5eeP0uwmSMAeAaTgrSDFdqAIoO8I9FRjD8ufdgsU+ZsZdgryfe+bt9D4Q1twstfhNVL0gLPWUEstqssrxuLcaF3PjuB7Pz54NJ7sUIy/NdjjqZt8HS/mPcheuZIMaGtoPXGym4GZ56U+KBebDhbDLpFjc2MfK+WSya2baq3pp69NTe11zzxxblOjfEMWlu3tEBv5I4OGzt3cEVV+VH4y72x+mDZG4pwSMdGiiLxHpmjljNKViINjSq1iZA8Ppib7J1p8jsY388M/oSBlb1aBigIh/4VcMBoDfY2j/S2bgbNa3s3u84An16lL6s+iC88LkSuKqznV92qA6m+1u7obSntDyeR6nkvJsidjXXtGiyji1EQJ5alsStDvuRd72EhgP5AeGX3nFGJ7oKennH1IXuVCZtwjIwfe6M+8mjutnMS+isFiMusfdnLQGhw7Kyzx6B7ahz6KJAZcZzx+m3gQYHNqjJrEee9M1jWDDlnnb/JSuHY1VfftX3Oz6bGzVALOioWvIpfroefAAV/pKSarICm8YA/tYvBogvfs6iDWnwhDc5H2Y1yBEWtsdZsSJCZZB7sTnpRFqXz1mtWSPzAxPXvhNPWry6dPaF4DZr9rrXsOiBhu3f+jebmpnj9KxQilxSY/bE8OkH+chtMm8+wOldZitgZlhX369ApcgJTD+AC99WX2ZuHq6aJgIlJqVAmz1PR0OpviWdjUPfph7MLs3RMNowPmRpnZePlS2pvfd/Q55FQ2TrEyKRYAKZdsdpvkOAJskZEVWbjw6BFv5jT1Fye1E8jrI5ro85fZ00BHmlKAthCdmosxwoGnl5fGN9Dp+fVLyt+4WpAL0/6cgMxi+8xXebWCSb35eAsvJxdUWkspizBbYAdzx/q55/a3bRbgNJ7YTrMDb2cHebhEQqeVBrm50IjypwzSuLp9QmJD1ES6Tj5fI5+NUxx4T4ElfWnV8a0vMNbSiZmXjsCUFR01oWAXtb7qa2/fVeloGJ/OsHXwdzI0n8/RgDW1rqYaKARJneUB43lFjWzuyJaQJxYmnLLdzvi4BqeHPfUmUi+u+J7Vf7UGIqMXjjyS9NenXFieH44/f36Xm+RVF4Z26titVCvJsyZwsdWow8AkOpFpDoAajQyzVK6DLQVa41i1687jM6hPDY0emdeiLs2hyy1xRrWXlMsAN7Y+0xjpya0zARN6DAWsXgrAaukF8H3rUK5ptaGLUodd7oNXHy91exJDs1WOhfLhwFwGorPB9lgxkJimJlmc5fUz+FGU+n8DPDcQLjub77UuiJ6qHqeJI0bDN9PYTaqENwilEez784rYW5MueE10nd6dWbxPRFFvKLSp79niOtUxdH8ZWa9JSrRHeF+uJ4QedqCxq9ln0Q4p0qhX7oqwDV2s97CwhFfWS7SrkGA+CHhk7jFrMI+zDwONW//+nr6SiErVAZtlQQJIJGEMwZp+WUq3RmSXObScOMNHlbHx4NRWwFDaEIoM6eVzMaPQm0ZSgNdwiT1m9bToGIOW91vZDWlprXLucLyC6DilBBbwM96j4YOe3fDXm/LQpZ30CHRTj3cp/vzKy0VjZwaRwo696uCNDkmQgwOTq23V4YqSGOssgGjoONKXxwhTCOBVp9VY4xqWbtTijlY1KYHMPsDe0gf7pq9y5hAsta+wx7NnrvGDi9qCzeotHnHCi6SakxYUVvKPUClM2gASWEKY7CaPsr5VX2sPOq5joAgWSZxMoqIDEPUCKGdK7PS0+WU2mt0+++RsMrtT4gbgAF7OY6gv20Vwc9iXSWzf7hXdwdAENAknaxL8MLstagU5BQVwB6sApLxJvQy2nY9BIt3YCiMN9Mvlvn0sLYrAUnWAueAAyedz0/9VCxNCIzhKi5aQOH/6zbd12per1mBmbd+M9rzEXxPDy3S3LcTIxkXYcKbaocYL/afCllGSw+6UewlUTceLpV7sXvcdrEjHOmv32Tf092D3wvrk1d5eKLdKi01bM7lBwMi4+4/bu0t7SUNNdgRSFIIdwSd2IvczVGQnCMEooUm5rdikLovJYtXKQ5h3nbEPx2HV5fAbTZFFM1aSMlO3+v57rUXC2FvkiR6P/Yswe13hXKgUm2w/ReHms1vto+1ED+SKjpJw78NugTGoRJoH616U+wmxejkz5iPf3QbKFFIOlBIFyLKwVlbD4lHADBXw7cv9+PHFHkULmYVUrbT/XgSwmWEJDyHi05yE49H63BExdFyJIR9IiHv6+qs0p3hCGGMxfGnID5ApeYSk4GNbYuqS5mhPZU67D7x56Dmp1jiMVmA5S1iOce0RP3yzeS1ufjvORs8uxXssTVIW9M+pJJmDvFit0/tcKpbvjCy9AIan5GSBwyKAVXETm3hwuag4V0qX7IJL/+iIkwK1hPj0MXSpOQL6AUNA68YEPSo6E53F+P1+DHt4ypNax8zmRcauIsinaXNOWmn3sRJtOMIkdWRd4LEd/CEi+uagMD4wwWo6a4BC0kBQTP5mnSyjCJvjAz3gi7bNM26aoxBZKbuzuefjAkmblwXqxEHLDaajvYrKuCVqJzzqgPh9VfjViyvC9A1huP94qIi4AGn1ae43Lkj2Nr6LIuRdJmCqrxRmprfPQGP1wponH4TWFtyFE1doKC6Q7l4hYVKR9cBvRly5zBYU8d70mxzk/y7Wn73wniiSNmENBeDcncv1Dzz3PvNfrcdyV+7ERpdUKo8zsuCOD5VmeShRBRnepfTLyQksvA7Uvev2WDEBfGbiWa/4Vw5dOklrDMnm4aEI3tz1w+AVF6J2hSC8PuYovUpjbLrPvOuJ1CYdFsmhkDJEbj2bXZjpm/xj1F/ogujkf+fcYZRiTgrdTXgQpKnrsz9xyuulk6Ma5DHkS6bRPMwKyCTxB66VF/H7fYXB1ixJP1A1dwp9Z0dqD0reUgT9CL5xBdrBgq7iIvQxvKNQ1/EaYXAnLBcdpy4FTutFwfboWvQxEJ+zXcM70ddvNIcmZc706J9smnjb0OtmQKem1bvrgU7bgj6i+5/ZdRg1gDwqEQ6MVpAkxFGsnVF9VXFmka90KrzvpzvQd0FQ4qNlDSMOMzagA6Pig5YnK6+MOhgMSAFWg4+BeTgepIEZJ75BeDowJp1c8xJYlQpfFDQaI7URChHB1oTUQgLn3wiKYHxQQkUz5sloQ4Cnyyxs40uhe5zgxEEkhUiZeaWglchUJya0rETnuuffIgaodSmSBIxe1NK0Vrjz6vdDv9oEQm1mrSTwzFXkh4KpBbfxJGvqtNJqp5e+AHFJRxMnN/LzeHtUyqoCndDHuAVN2JEaLS1UlySgw3LQTEKEQgwxxmCHQYcHUrkCf0gmhpEK4LtUvpfgq3YrwCWGtX6GJemJpIXfCIRsZ9cOzSTZqGZAb0lHx7dlWUBeC2drMq/8hfyfsAtGCHhE/Bcak1owQAcvsVWy0pA2UO2ZLPyOBgXY9F/xJJhvRpwaW3vEV/MSRvEBbwsVNMcGzsDAVA3FIt0zCINynk++spOHrbtryNET791fZ1fqrW00eJeOUnq0pcD/b1RwLk8g86ZSiyEH3LzTZM54QkMIw6t1SAe0ie42EV+N8TlD0R5DVUmSfgEnXZhA6cCyq777phB1S6fsG+HinltOaucGxVCzGs3jqhYreC0Nubwk1tjYQ49Pj8iY02DwcdOSMwoSQWcO67w0oAma1x4x9ZpPgO69xXxns/wzq8Vu/c0nFR9kVhaaLzilcSovAsYya8Y8J4JcC7dVYXK4QwGqnUYnjTr/lhvZDuZPfc8P2/BIg59LNeKKSIShTjnDyRwyyuZFdbANi1i05ojUAsXmiofw83155jH52ervy+mrEbpKIEYcT+2GXBbhSS2hKdW0EzwhHT7+VUjuSAcZHQNFrChTJkIpHk5OqGauixeQvgbAhWobdYY0hGdYLZTzLZd9r7J0X28HiP9pVNIJidvcElhSH2dsLL2cbI+PlsmxLsaQnz50BhZEG2P+pauhVcaC70g5OjtLSHjG4a63IAsbFGlz901dhM7X081WeGvplgb1JEaKLW1mjRmr0QRn4Ye48D1Z1UkULVbhaF6WSl/oCilbkSt1l4EQQhuDTXO7PuUAUVAPSlHnVRDU0maHB29sBScBWyceUpvjq0kHxg4AfU/gtF6kxf2ye1LNjVMBSLUGEgrMoA8FmIdkMer5OMgJztLlap9Jwn8q1cM2Wzju9A4/L0Sl4ouCWCLGQlAeEZFTLDrHXh08XFaNZFi1Iy+EKA5vIj81koUVUFM/+DR38vnLVbJSlKX4CjfxgntWkACO5yxLyM8Gy4DH8/Brp/ALw7axnTsUrlVfdr6nkaImn9L7KjDM0VLdfF0KJnKR4aGsuLfspNKUy7DSGb9lp5IiLFlnoR9JciiyRoiGmVZXgFomqvwA3S5ebJSgz2z2Ld6TkeVyqucDfM5j9ZqL3FJJRahWtFFogtf8mD2zUAQMacxLRU5zYi5mjqoszWTGboHlFL1xnyqLEFfvuLMd0e5JluGcRYTuT1OE9RMMDN4pZ9OGHgoBB1Bwt7kFH+r4Qf3EpR76yZfZnTyP7vJTsbpcSW8BHYN6bpOEXDblJSeZF80hmjKsKMoOjC/C9grKmdzoHAIm2XHYjrTwfI05ZaUGdpk5BA25btU63FPlHV1buldwAOtz0QEmHAOiBxZJno5u4xxcXYAo5qqByYmZOIE9RQLDudh5cq+vTk4QbdMs9agXPfCrIlKQTo+j9AgzA7ZpmMMU3nvB9pGQ7CjGRYgtcV0hhLAPLCK5xveSBqfYIa2np5jceqoAvqoSyc4MzlyQagnzSQLd8X2EtkCTgQd3gtDmiyzRvR/olkRfTmQakzYAfYVFNk8zkzZVDlv3gPr5emZIBvzoQsdt152SUdTpwLYiFM+wNaKoXLgdbyMDdq0lpCA98vPKErzUIwrLSEV2Z4kUE7IYkSfEJp6Q9/ayOBo4xlJp/Naj/Y8ciDqoGNNNZDAK22VW4fOtHS2/l//QzJQiykbmFA0qKEWdT8TN1/bPEnKC+hZKvc+f5wcDAdqn6vxjIQmSuSLnxSTbR0HN0AXejhLz1YJciakiZgWGp9KcNoNyuG20EfZZOmz+LBPR9+a7/qwveztelniMGfLUPjiBKCXK1QHh2VkHzxwOXmfFQRGF8xneIinV8IFPI/djUZ/CU3g42tRs5fuxYgrSb5ngcncadun8b6v4HOk3WF06fgkIchBVB6XeuUusI0NoY92u49hsi1MmLJRQJFt4wMeIyOzjiWnmIPnWkbaJlxjw0RbirrAliiONc5gf9FI6Q6fmhrZF5hrmBIARtqcIVooQsJyITxaAxQj8CU0UECiqO7WoQkKI66j5deLCmnuGYd8w/1KFYnptSJKvoXJZKt9rODB4Bh1SGVfVwBia/0sPsjv1oW1/Q/fQHmHT17VX4ZJdYBEhG27viXsBg2T8GzYoM7t/O0hgQ0nukxvUmVjfLZKgQRZI+pAI1Nua8BQkjJro0tkzKBThkoP7be/bVnTDEbYDqROugxXTkKgAFkww2X6HAlVY3baDy2RSTqXRYZy36SJXy6VqP48S4Ae6gjKfMXmOOElFQLE5DVX5CATdN/Y8zGfw9YLMHL0sqecNerFrLB9nEdnw2OlN9sYP0lCAGY4MBLCL3q5xb5JqyGDTkLoyW4die3eLZkA3X+iVQP4cQYwwqWcTzWmbvD+bfxQBan1G8sKV4GTxEz3PRWH43WQZ5Xjto26YBcZPvE91F+li8oJ82SuNj7Tnk5ndyk59uCEa3ierQ7QU8FA8sD/9z0TYVHnh9bFXgqhQFgZKWsBkefrLEHuSTpVCpuGYLFJp/r4UTAP6W2e0zMvPgHhHUM5R7JmMCsEWnOb0W181cARv8cr/Kw7wQtepbi9WOVGcf0/JT5GuPZaAO1EWeDNIv3eS5PpCkYEMhstEQh3H4w+F1VsIcAMSC2PrB2+IhSVq/qVuhq5h6+kNlvSukSrQsxxMXOkji6eKlxzQRzdm0DKkq31iMlabR8P7eVw2TO+TnuzWIh4mfwLHbIq24MlXj4M9qUez4K5RDuZxoeDRbJwR2tIRC+xwlGUcQjH9tC146teBiUasCz/e7UkJCMtSZHeQoArODxGma3YmAC/Qay6rL8IKi09t3Tiq8X+UK7jOs31bAPa5F4N4J9N61zA5zcphVmD+2IaHuDktGvtf/Ifu1KE0o6UEdU1Jv9LSrT5aEiYfUnmnnW+pVybt9wHnQahJMyTPBNAsKoOBg2eNHFdSsgU11RntpgYpJedKRCXkbsgp4CkH+t1BIdmDJKVSzNzcU9CYkbp0HbwH+IbGWmSVa2nPqJvz+5Q8p28pgR615MTGPBNEg6fOlElxWN7arhrXeZEQ2BBz2GUp8Qhqj3J/L2SkYHK5qv5z3a6rPt+cQ3HYTTncq0l7wWvGV8VtcCS/CIfnLT+L45t87oicwKzFNGJosAZLviMN9HZaCmTBLj+y/MGIVQe5jufy5tjqbIQkDcyGYhU4tSEnZzzdroHuBfwHHdp6d0OqKvRpRZLAqxDYolmd5ECmoWqMwT25D+SSEfLGi6Z6Ezo1b5gO7sV0JPrrss1kNmXgUseYOXJ0QIDjfLqzd/SLu4AScZzn3WIFL891YFgZKa348pWBV8qdOqzdIv6/vArsYSVBI2zMOZmXqSnpvG+gmcTMRHPGlVDjcE3rq37TQSkbdoWiY0LxCCxnsIB+FC2Xz28ObMA1n/j/MuVjJn4HM2e5aDj8Pwl3J3o2VyCDhsNJF86/acgclqCat0FbrrZzVYVleghdGfokeC7PNdAPv5vvL0a+NaVwE6qsCyLi3BFaR4sU/k2R59Tcg70MdnqroefpWB3RP32WtjH8aDSF9y3Y4GKEvmEbA+oG+e93XMfNBdPVdJMu/q/RDhX442PXtmqKsS/qYxSMX6gTdklfaj3TnTLu1C31qRtNzfzPCFaPFUnG+tSDzmzN1FNatvUwzS8u//3EtRd4E2rGTTwnoQEdw2TPdVTXilDgqAkKgDNEzMJldPERXcZ+cosLAIbfTYJZN4zg8rNt0FZgI6HsD/TQdtVImDu34WznidJA4vQkLYhDXj5On/A2M0CDXaujuPRZQpfLc9C4++wwSK97vOojT7X79pIHGONTC1okolTacWJtSWg8geNuXElbbKziob0z6SnV3Ozim88N9HSQOKPRqtwb4KNFBzHbWp++qR/KtZbc3cxAzbvXFhQxiOb+ixyMX2BsY93mk/aTG61+OjNbZmBUJ65EYkpvIzfDeBTrIfoSx5rUrO9+xO3cS+z67mPd72CJ6/o50iJZCxug+CXhFLfSB2Pm6h9fSaA6e/dCwejVKT1s8zOZKeXLaxtxckV5EnoQ2enz6LaW98x69wmmtuQP9c+vcm3RMUP0GSGtgJt7iTYQ8SEemOHBkIVoCGNYW9ma7t+8I2EstK5vqZSpgUI+hTsIVNVI0ZZRZUIi6AMDhf+qtu4x0Ny/4hINgHWKxnEC6BpEPclSpi/FqujpC/EgBF+kCxEsHe34xoRVq+ZT++xTiMnmFLOp1tORdpy+r5WZGZmJt9g3Hq1srfztZDfjbA5H+xRwVMxOGL8xSA0R/cY5xXWP/9FOX9FboxRh0l86DGh+Jt+AoiSKlueqPaNg3WSzCYRgwefUbEkIl4PWBQldo/6iX6UXN70Xd7ajyracLO4Lbozq4eXGR6WIbNYdaEv9i1IOx6m/atbBUXS1NY2Dlpz9MVQ1HupcOYML5ewvk9iz9YqnfMJidauSDM+QgRCmrA1LKv4XbBIhx/t8HDs0516qPgUx0OfRpw2YTCRYIzTRMlJwwpLGCnX25Gsm2TZkU/2xv5feJR2mM4sOhDMjIiXqj6LGd+QoIDhHRk3LlVdQmjMsNbH8N0wh3yMg7R3bEgSzzryW/A/3KdtRrt93w0PfK7CweJcvc2v2/OOteLKmuMjJc+KmeipE8c3rOkPusGhf0siSfH6ZDHRtmo1baknjtvpTTyLRiveMKlu46jICLrRT7Gk8Goi2eyIvlmr5IjXs1/oYTcZfYEQyN8B+ikHDl8I42k4XKq6GT7K1ONxGnalUJY8xtweOWsFx0fh/WNY4AlvqGD57BqgoLp7qorl5rXJp6V788QB6LHvdct3RtQbVj+vzRCAgzssfCBcMgFfQ5FzTmDszVgY3Ph+Kzbn3OcyjC6P9j1cp5w+I8JH7JcPx43NLMgyHO/Qw6xzoAX4Vh9cATSH3LesOc44zkSiAaaUuDYnOjv6FgR8UEB+7WYlZFh+skDn9ssO19HPZ3axUXlbIDnLszITnomulwdpzkdmJoH7jOLk9dr/ixgfueMV9/YPXZQQ3PJsVYd9n3pWBJpgKjMt6XzONwPnnB+X4mym5/Ec+XBWQ16gNVWj2jeFJjzTju4rORJkU0wKkc1r0q3OJOeq197gDSOpBVE69guu6s2e8Xj3V8yBxUqz+ozQIsk25qVLiEL05Oz7rAfmnK+8oeEtVAGBSAxCWQyqdvmBJrp8bmFZ8S4F6ER8c9rWB23DUq59nRmKFq3NEKnVlN0K1cLeJAK9jEC52KFeHV2LNXz0KTvDYJl5Qm/geAq+NcyiF9ZyKr8eDyuyhvR1NdmOZlTRArepRYDv2OFBtJjA3h5Ee9q60n1f1Jcf5ELeWV+XCzVN1OyCo9Hl44ooRToey9JDglw9jN7ym+BbRfyhhbrRNBa5yIpqrnS6gampjhj1+acoNcq4nXBZHtdTTjq0c4Fg+qUbwZZr2WHSx9CCJxicEUzTk7sC80jWOT9TVeOiie9A1BGd6pL9fsVCV7ZFsHkZltlpk71PGzfRtBwJGjUHWD+3QqSJtCjZVucyB0svzec34zsUV2verqiZEkvflHst7M1vTIMKpJi0H9hQL3plQD8fo0KVRyhCv7jwIUF5gdym/d3OQ2Ar8mA5/bBZIgtO8yj+iyGcwb0C90ZC+pIGMNv8LT7mMq94bB5WeV5hQc1ZYgPO7rmG7q0bFkINdNYo4RDupwnxGI6wxVVL/B/EkJhmIO79KsRfU9nHpPD8MAHM6TPlwpOPalY1KprZ4ULr4cbwko40YpxSWboay0YXo5WFQ4c/51uAef1GCLs13KanCVGPVhqOqwarvRsz1ATkbJLj5Zzn5jH+emMmEUxW/Y0GpiOeUmIVPQ/IrOe5X+E7UGejHf8JSGwal5zCWvpNFXhEFYn1c4RYA62lUfx77pdJ9vGD3qpsYULmiNG8AmDzumaYiA7X6Fji9/KlERfG1N/Utcogvu9CHrzVh2f8/Y3NytEvFKsDWZrn7o4OrnIr5jw6K5agy3G6GJhgduX2r96S1/KmEHrSHfixOecOjPXRD/27KNzuA4bETV4/J8W0yot7jhZJx5bw7GUrVrhy5ClF0ROtR7f5X4lsalr0Q+2u27C+27F2MXJlrly5fuUNGUFI6p8NUPhfW5QUlVOqBQD33078Ck9z9RopJ8Fec59Fl3QEVZyKCgeBuT+gYrBnvAZPl5m5Wkh2orOMN6gTUHPuJX+XGy23vu87NREyQ/lLsY7+AkMhBmo/knomMxxMb2k5A1Svc7S8o/zt/XnHUsCi3yQbTCeKTUTv4KN+RzW6Hc2/HEC+GbClOZF+v6GEXF0bU2OlezmUxp8DmhbY7lPGerthwLrDWnsLffdG7see1f1ybvNtaSra0qcxHFoc/U+VZSM5/ZKBAfgNfff1hmjrRRVV9NDTwruBUtT2onZGC28dZ4+Ptk/2zHiYop1Oy05XqKv8/3K7otbF1f+Mby13nDQAuNPfrAJCnrz/RSMVqANR28aed7GUVYxAWYhEBVgJ1sjP8wRbke3Ab5njBowWB0MTbx+snPibPiGyJmyLw3AklEWyJv+VI64kyioRFsgrasGy1fMl70l9nWYnSx8XbxAsCl9bOXsZktMGmBY2aG3je0lQYjTITD6nHbeqzvMMPiJSOESZ+QupR8kBDnezydG6ty0R3odyV/TNuzH6Gr9aPkzf9gNNeRAquvBYp0/OtmizxBOQ6IMkKCCP/6X65nnfUe0tM8rXhKZTneLKm/E7MYhNhC2hkSAjr7MhwHh1UAM+NGvTQbIbm0TwM/pm64ICmYGDtGeZrZ/AMPPr9TosZe67qPiR04Vb7kqn+XtHlyUedgHGptDyJ2ZA0cQZPuJfdz0q8INDTArJOyjY4yqHeW3TfWMSwHh4fUbLweLI/8OMP6q2g2XXWg0THT6PLiuw7VxScyT4KDf3YCgg7QQ7TkbpLcMcJd2VpMD8RWu1a+Ze89mMeBghtseFvt+PJRGtNNpyAM61n4IeiZIU1OXWxk3jphpUcUIhy6jeetn9dI5JLcE6Jx/l733QGWHzrLjq4IbhhlZiCDpm1WBAxwo5UTk29sbSCup0B8mPAOg7hX76JtSwPeoDBc3K499IlzMPlZSLumF+fbaXrLe+/03xZYF+u3bqR9N8ACyNdfxC95YBFyIhloYeH2Ei9g/jSlTYsqS47c/r1HZPwm+E2cRFQ0qamgzB52i147ofvzHWmTDCnMOhW+ccJH35FkXMJGSz5r9/3Q7D9lsx1qO+ngazvPrqRhZVbTUqX3Jvsxv0FsxzSebLAEQFt6FCBd0wnt4VMMbzeQGkmpzHUPfSB2ps1nZjd80i0MIKmI1IU+zsHMrjgLWPZlyPISdj6AS/l3OHhMvw7Ug+ziXi4Rqd6lGMeknXyrMh0+XI106NhPJxrI2HJxwebqH2zl1aRwvjX4CtuLTcHbLszKOUr9DsWLE8XUqdO1gkfhy3lZvOECErWbBFEnu7INeK4rWlJM02cie6v3iZW4801TL5V2dPSW0XWNoRZPcUzTlvfElLPAP1msPJl1tlAe+TvyDWSveQ2chiX0g9T7B0U90BF5uPXcswHNGJQQObMYMbvdsSiXrfvte5JhiREgBcEIm7PCSeb1JJXz+QCJH9bmcrCSO5YpiXXI1TWCl7Cs/Ayo3qy9ZtyIHqe1k3M/a1SgvvlgBbYdZT+CWZDHg3N9omVqpUX8rW/7G6fCOU2Wre8t8Yii6+qlE/bCnAEanhGdbRsFvOMMStWKs19Wm+j/IBRnRHqVo1dkaQTtGvnH9/WKvHY32wWR8T0rylou3BOpzxnmsjtR54LwrOkVVnwvAqG9qBrRY9JfCGLeN0eWc1tFDbhwDPbsdtbA0yjIHoVzLfMk+XglwQVQyxSzfmK8PDUnyIP3bzR/+Fv2wWWUIwOYCyaXLJTv9wBUYAdrCS6wdXNepBix1yr9n3sljOxRq+jABub8Mem4jYDAhw1EKukkwwTHjdpfPpJ9RvVyc2Ru2xUzba9jbHxerN5L9a2Im9D/pb943Rr6mi973BMe747QmoRxIdqu2ONGUSPBQ6XYyPpxBeafLprvQksg1gMuVzCjsnhQ6242i2lRjfevyiU9d+U87tYW/KbJZHVN49ECBR1ktLwTW0MNDOSNeWvPggKtnB2ksHVXrygo2t309/to7sidnlSZNU3wcxFQ3Mrsag4/bRHgFzJdw9f8gMQOnkCI8UV7LCThrAZUPiURohPlfZWVAvlihZHr7+BqsLtKW9iJThAhuuy5ik19hdjjUUZuJ2HNgJkacOOlmnyC8/TPOSI1eqKs83K29HFq4yAOffFa5FECZGOM3K/k8D6TdoB3zGnaBdyT1y7wws7Q26mPXrvwHtGGvIKYGW9/ZaeYLmhqhtwdTjm1ZziGKUaatY6xGpu4UFCPl429JB4COxLYkOKEvNBOoeg2WRqxl1QLb0Ye8QqhIAjEzJZyOwOIFEv8UDQX6pYy2WOOKY1xI/hUTDML0VBeA44TG4THGJzdo5+k4LwGoanjXAuJ0lROYnTGQcHwGLxFB0XaJuJ4f7mVzggh4NI5oQ3tcM3ZRkHovbLY3Yfic5syU4iZ9KiYxVnEYyyR3N1uJo/DHQXjmgzBbLJ/4pe0pJzAQ2F0181FzRW1wWp+yTRvr5Vx+ncJcr/TmVwzju6L9db39UxpJgfdG/u6Gy2gdnAtAxLdBC6S/4RW3XS2iLcYdO3yGm+69dFkN6xDfma0/k0X01krZbvcBcnaye4QM++4MB6m9vgDzNUD0J6zDOcl8bKVVlnlZR0fLHsACOvK5gZUJtYOWNFK0Iamc5D6Q4ULZKQB5vE/93LLrE+5/O6pKuMFbofei7JZqJu5tsEhiXnkuC0JFcEpbLQ4ZXYJ1cLE/9rtf5h+kV3AvwmNWYPSyt5jEo7T9KBcVNAfDeAAqXhuQMq6Q/oULcQ6cIgtwmtn64bLtE4rTFquL/cXkaoG/hVio6px5RjnpHipWXwBXY7Fr+t1xHJSy6q/CBVaM4DjZaCqk1iUs56bz1o407g3kDrEFvnJRC7aabo20I8HAlyPmXPJOclxLNrH+tC8XybQMsAV4x7nZZOm6DZo7enMly1bMyBKEDIeZkjx4DhBuThE0N9dYUObKxT0pT8Fr13oKJgl9dO1v9tcug+ZIz78rru9Eo/iyTNzulBO1xiTyDlO4AYE17rO3e4VsyqRWQEcr5zKj9rCC1eTHG3S2ClejtysM2OB6tdIEgX8Pl4ZfSVEDcupgYSM5sRSSHiKRRP4xfTX11qhYdkXWIeDcN6ZOAhsdsSsB8oafOqRTrxwr8UnVUKGNRDMcv5VV4+Qp8nG4mR0F7o6oiVOHdFwRqPpyUcU7axKpaDe0+hDSkjsGMl5xZ9YhQanGKkkvKDzhJ2UhVkHYXjLrcbauH0hkJBjcDbme43Z/UDtstZy4wqZtMxzXLWy4LVu8CTB4fz7E4sBDRn35P2QfglP/3c46br2WGb6daQe7nY0o7VUOoFv5QQYdntkMQf62phoMmaa7H1qDY5oHDCB9xCJrZo8AdYS+A9bDlbKydEBCantKLQ51wcfXiQm3S5ngNYyvNRXR7S954cHzuxtW1lppz8RKXCwmDY5zXTgPGJEgydfcKXnXXymDkVfguu+ZojLoRHM9mS8UnXMNGpTTWb5YIluqmueraoUWDZgBFAFn0bD1lNed4qcsOAWhlyyZIZMJ+B3gdmOZYi+7JCt14W8zeS1jsNyiWgSsX1yY8Bfr+wrLG+XgXI6kj2fcE32Je/1jbSkrTYIszXpFf5HpavKd+dEKlxuQcWKcbezErxRX3aVclMXtmGjRIvWp8HWwYVAcK5SqhZkwebEWp/A90r5m1shhU2Q6ny4gWO4lidRx6+vP4LAEuvKZmWK+lt3XTehWUY8lwnkvI7DkFs8+nN27rl9CXw65295f5AICJ8B1z20uGPR9tE/GErCD9o5Tiysy6FxPkXyFKGo/DXf3hkJqIHM6UBp+rhOacfb94u4BImvqeUQwxBHEirXNBk4eURSJZJ8mskwCcdShfCrz1LK1YKt5hktUeJ8D39EeX/zwqRYmIoFWzIg5IiEzTk2xewKJhZ4KxUCXIvg+VIxyCoI5vKcM+jL9Dyfa1+gKPTwMsn91KschNOuXQmhN7IIumfp3dPUbc18iqJjVwDnRknN0O4S5+nzMdFdddB4X4MEu1Zc2q6hdvn+KPPutwPJNKo956LXDq/hGtcDRkRK2hUNmbJA4hobUxi2RSIGcWjME6xFP7hn/szp4DsqKHI8pa7so60VsUr65uput/1hjrfjVIpWeIiJi09KMXbFDw3xrbNDPB1WBR5U6jrd4L2mo2nJn3aHZWFyeuy2zJAdfJmYeegoNsj5CPmDO6JyM8jgHX5/uqISHKRt3fdAXLuVtENfmVmBUdYZUNitHLpCXiRCAzxasUYHY3/c0QojE3A+4PNdGS/gxDrI4uYQsbxvD1/8mc3lJLN5RQ3+xbwpUmupxPL8yEQYiTsaetchYkZzA1sRDYy3QusNR4sYUsJSWcn9fRKGdrn8JbZDSIWEFUO4o9mTJv+qGz10OUle2IIm8cNIWxEVT8YHjz4+NCQYJXfMtlTTrykhWKmd47SZVjf95L+BoQp/Y2MllDgQQFTYnCwrpJxhFSewN820MEaEX5OiRJcW3BQNLNaBbxrWufA6VCHqusaYg0TkMnsrHtTgu0q+eG8VbbNys4DcECt2yIqAikV3z9YuPHBMv6+lBmwVWqDOYRrj+p7C7jgnGpNUUO+IeSt8JYsyUM4gJCe9NNaX7L76FkrB19j4kHzQDiHNiSQtxtPTYlDyDytK/XHsgGy4d7bGjiFtaeTjH8H9yFfPv03f9PEP9V8Ma+Z8LmA3ZrweV0DCt20KMvSsf+Yyh+sBY44PHv2MeDltc0h5nswUOAKYzW5RDsabqivEcQ5xSdXQdYJV6eHMv5sQ6MrhWUJr60zS+Mg/GxWSplilxLbV0igulpDcKw2EKw7xxp0Lk65hQKJR1ouoNnVIDsVkMJUV92nDVt8i6fCxS3Yg5ExBf54hewilnKYiiOPp1/Ic1j3/Z3i4lcMy4D1v0IJBYa8oyhsVa8p9NMP8yOYW9amWEBkl/FRfgB0LGDbkgEoZs1i4RBc6tfwh0310lmwnvChX/Fj6fLflHTRWxIeDPq8IeHguvhQx0vZNz1/7kV1hyA88qJmElJVqUxrLIRZ9HXMYIXNMLS/yfmkPjsOlq9onUcdXupSmsYV1UME2wj4YntXSR0jibZLSP6gTJUo0oDNDd3+gOuRtyI9jS5tbtLuWBbc/pNBYqacH61B0o2rY2/qjQcoMAUAoeScsaCRrcb6S7hMRoes4Hl4rEqHcNWOvhRl1DwdDi90Ks2xR7KCbGjXImuwniZ9MFSWIMOZ336HHpBYThC5vRoz3pQ8CL6rxU5bZZLrH42mdvllApmWxGoGnR6hYgaid7MBYGD724BFyUuzBpRDVz6y2M2sG0z4C/EVs5SXud6gZiiwBlJJma3b+MggZ3mDI3PohlhUa6JBexDzjePBC8YZeffQYMjA8VBwN8MJk4QzfIW47Pgwlegl/pcS5GzkDgA1BdsNFrcjcMbaofePi3ZPahqn5LCae+iD0u+PivYphUze1RCzud1fD/hZFIXl1SopZ41ufQ9DWpyuV2hMXaTksxBzEUISIKlLLIHVGruAJNEt8kOHMbod7IxLRA+vNxGTOwwJM0bX+qFsypD/6TsdFEnaTnUIQdl6YuNlW5XTS4pNFemvHyIFufeA3uZTyAhjKsmcTHNIJ2NhAYT/A0e9HYHzUSIPyFjUwcct8Hzltn7i1qnhP5CdFBwgGtUdb7W0rUdmJnB6/SFb7jtmsU9yOqeVkgEQxZmsgn724yT4brMrgGEaEKOhpqGlxFtmRLTaIzI44lM9FB0GkGnPYC85OKy5Ojgfh/EJYE9Be33e8gsyXvYtLqoeIotu8dlRNJStvWHaxrbPZjDHL+m9J2sGT/YeWEUdo5PWgzobiAZ/urv2kGBsxPxtfwKk3HHi8+dG4nV+bNyZCJ2WmZZw9AbytzQQFjiiiC+ohpDEqSXkolzCg7gQnNdy1M8LDTXMobWih7Bg3WreqsV/+UfCAE3KroEOSEGDYuZz3aPN6p84zXq17t/ub95z+g191niGeO3aq488n1osWtxc4+Wb5sAd7+vdGNZ5jLsIT5Bodn6Ns3MNm2KELBdeuLsFLL+FZBkHt8SzIuAAgbyZr6oKybb9yq82W+AEw76b6Xs8nZGhXpGTVk7Qm9sM7wz4qzsBlTjIpv7ugQOZZysMQFP+xQPD/70A5hPWa/v83nBDr7T/q6OLi/wV43OW8mVcv5Ial/T8C7j4YSg9rj8C6fQOaJdMjaQ1CcG5KlGyKq5Oh+dIibsubI3+BLzDXpxigPdizzVjx+Q/FOH/XyAPyj/JawwzQAM2nrYhnY6EVnj1v+LKE1dfIvpfwrWeeVE17uTyFeXR5/BknWSvZpHxvXL4stqPA8hsaKD1051G2BQT2OhStGVAUh9lX0k1QQJ67HFkCxCgKRoWBP/BCMOUlGCIp0lyZoI7v1tM7ihOPMtspOo5CEsycROrplj9bgypJRpmzxQZVCilJUj3JEp2gUD1AydUENMCgxYsmZoGkWcAKz+hgb4FhHDfpb3g5DcWqG8JPnqOYDoXdHSSUhLjbImEDJpfmQNrqeBdRhqNDwV9cQoT1Fl68Vq6lJmGByENfc0OzfYJ+nhQ+rTCy1MTQUXVZOdQ0FYvFPR9jtKoh40SMTiUjTcU1LwG5eqJOmOM8aTkHZAgMMJt1m5FkV9u7xCgWqFz83Q1TSznKLa8JhrQJ4XXR9ahWGhdfmqa0PhTAngdmIBaSH4oAkysUUsjDj6VhvruPVowVtTHpI7uSmLHiQ2SIJJlQ5d8I5zS2TG8nZozdjCPF5jW8wCqe2P7ntyCBfRrrcqaWuaRU2x8R6yNrPROQJQrPeDHKX6qmaROyX1ZPVjjmIy2zMKc6RMxPPQeEixvoOsNoKX3BFJhTXLFsPVnKUipXDs9eLtpUSUQgJjfsmPX7HDuABHWTegIdkyMytgvgBqLXQTZ+lCi0ijZpef4pdO2PvlNkwD/ShVzZaNJAXeShZ83sYFFTsbJMOHQ2T5sFHiGXe7j5TDywlhSuLHtPt16Ei05Lz5AlWZRTuriB+3bi+kjT6Z7LLEofbIeUXfQQclG1EPuStarZk7/EbgNZEkP9EDr+S77lDS6W0WEaFvfbl0zazTMlU9wJOnvrQhEt663ETMFmmSxUfKrul4KDDUmBZP8XDX76RM3sajJen6ftj69NTVwGeXTeutgwoJTv4VTnnKsCfkH6u9hpVks4abLjK2l01c74e/lRsoyMZHvP0NkX4X1/BiWBFtivr7h5Q1a1ZMbBWfbXmkZYXW2KKvHfBv9xw5PqckTZM7LNVY/Pv+Vtz29L9ch0Rdqo+wNJvhoLnA9xRK9F+L+nrFUiSthHzEgJKYs/r8QreKDnvThfPt9BG8eMqrG+gk3iVO/tmu9ipcOLcKXcleE3EWqb9/tPqKrbYNjGqXKsTII+4v1XEda1WOhk3qBJO721WwmUrr9kWZ9uPh7E7QmCbN5l3amt17ATdcZsJmk4DWfoyTpc2bl0zAMgWa2YnBRCcNJMsWf5DibieK3orPTlpZVP24tyDd6r4lJWl2ZfVx0jW6Zncjsom4aQQ3ffQTmh2WLFEuNOalwxA56AISeSvl9UG35KQnIRVMIZdg07RU9lI0sFAUD4Og8oYz8t8Aw28VQlzyCm4GJVevHTmbcn8kgA7j2XXcJLaqvnc5+OXvN7Fezf579if5Z8HSDUvhGazONXVceHIlp7yMS2JT1WVgQdfR8mtKapDAeMVbyrYasHBGBLLoqNWmOabFeAycEoRUcm4GR4qkj0cuX97UwMjE0IbQgci1oCJeP1WtNjR+4cyx6W2I/EcHrvXB7htL13CP1Uh5IBAWq8eHqFTew6pCxH4QDk1bH/qYleIVbCybyFvOJ8VhN8rWIyE9Jcaz2UoTm912Inl0DtUHQN2op7YX0Y+apWeagvrVRrklW7Q7LWx37Cxa3POfLxTOkX/ohiXhCqWpP7fYfAHQKlyDnhFtsKmVleQ2q6QlBanksM6s768N22Mhlq2qV4rUhsG/eM1e8idmf2txSWb21t8gnQS+bwq63Rri2nbwvKU1olFLP4UJZqVzbQ2XOcVGrDBtjQUnEUI0OzLinEallx7I0qnjl19d+se9CIA/B4UKzlsvWbpvjvbWRhu0c9Km7V8JIwY5d5P8yJAxXDQe4HNiyLn+k/nDCZHWEyahijcpj/lrdcuCW68Y+w/hmzbgputMsOrHbRMpfnEAJXbMTM0vyiKkK5kINl7N/g2biciFrxJcuUER6F3tczQP5L/HGd3C+0Y5DZPzG+ZcfGrndKYvm0hFm/p20ySXtsUj7muBqWxa1kH1dCqUnPbQ253WDAxhzjnA7yS2vNbCXmunQYtG4X2E23lF9zR1RRbb4qFjL2WUFlfCviIP9EdxQNLxUyc63N9zGDqGUEFztiuLw5OGmTxYxBVbHm2cthNx4FiPN0F383bf50FalRfYTddOpGXqupGduqyQKk7x7MmWhP3kpe0ld1G+m3hYAnAikukLwAP4E+uniELjW8LgwdMLhGCyjVy52mZGzSnP2ZPkvTUedFTb3XFhZhVx2FIzqIckuCOKzLPp6ej8Ums/9H3MIke6IITsaYXR7hjGshhJO666x5BWgzy3sXfUVVbNrudFzdOw9i6ryzTTF5aXDXLMS0o+Dq4/yQhezFNpqE59hqZl+aGca3akH5XYx/cQe1u/wZdtFHJc1yquhxcRFXchjzfnaWkxIHv/B0VlmCRgVqgihtjQvR0m0eQDc9zk7cJ8HYElSgGxL1syrs6PPxdsgE2JM5I7uQDptpsWPrNs6W0uDcNi5d2xtngDe5+XPgDHvl6G+4yGBQbVZZWk3odW6qYcKGpVMqVLD4+stA9xfGsAvUd8ywrXLADZ561Aq/ULCskjj1y0ENuxXZkEpzR2qfPx/poWta/t63vu4/YBESMUykMXyoQhbTJmZu2w8eOsI+eCAj0vT5YW3jkSj/Qw++QB7S9mlceDHCNeQA2F+6whZOwyQ6nEClPNbx1BAtI5LFMU0vRwqIY5NJw7d7OwECO015uVP6wokS0iuMCmnsGTSBq0VTbN2DLoHLM5+feLeI+a0/gxxzG1MClE9xqYPj4Mowrk6CjTFEakkFqemSGylSiJyoIqx+er5h+Skgvopl8h1e3N1H2Q+lLWgxLfzlzepmHNzCl8Hmap7wfK9aP0lnfa3b1KhXVyrEn9bqf9XdO3sYcLefoxvX82Grb/L8+vwoYLq1VupIjsSBpY57HTWYt1XOAQ6vcgTOYS5BUEFn6vnBSQVVCZJ/4b0Sq1qO7az9jqxf4kxNLndRGHN9vTM3MDmhOs7C/N1zaFhmo6ifHWzQVl8XhOz8lr1NHvsQKWtZfrQ9A0auXO+t7vbDiSipKMo96NqZ2GBuqE5yMM/LxaDEcENNLua5CgaUbQWHTdoyUOOxVB67zXZ7k9pan25QpKoMpPWohatd6olRWcYFBWtTeircqQhSiii6O1kI2VvnZKTZcZ0hlpAIvm0xQafBk1xQJ5y80uViw+PpJ3Quxp2JbhAw3VCljqnMCWnOSHSiiCEvL5uijcm6bXwdFUs3BLpfe1QV0Gx0E4kMqNK45KjClBdnBdoYlRV3Wxwx7zedv0G6Y7cgpuD1xp/fpV8PmqvVn/76Z0bvFoMOqvVvoEXzDn4OfXMBFcjItVZFlr4OHOOfZRYWq9YgINXMAa6f7AWWVuLqrVOEi1Cnnx4BwF/bTf4Uz5KHvlAWFMsSZViaWqa5Ls7UiWSIOAN8hWHp2/Vnj+VjDjWW2Ipaj80FJVVshKWfdLE6UuVObb+2EgU5HrHaYxCRqkiJQF3nXIg78DmBshpf+cS8oBl4So5GRTClhOgVIkSLArLZSf6MFnkiNgtttZr9oXsId3idFBPqG9sm1u+zUDOk6vqY13Yoezge68hIH5cR3DxYHEykZCjzi5WINX+Bf31kQ5TiIxJs7KLea4bVZnTznkxTFWqQhzYm4vLjNrxBUWOiW1Ge84GVevkWnNrIg+ExAAdzhYacuKAVktWzNjwRP2EJ92TTghNvPyxb5e4oxuAvl78Zs6pFLmT15FabhjaP5YIWkXkT1tl34kwOVIdSnErSmEZUi2Kzumm4QufNo4/1r6USuSWoXwCgTJB203mlIBnzCIeN123OZoLXbSPLFkLzFkx+/L2u5f26L2Du0hioMpEmlFV2phv6qTx/afAqKHnYfUWBVV5sx25zjE2JU2VDA1TsXD6RHUIluZ0Dldng8MV/ihTXFlgMTnEyb0z/nbyf6FQe57zrTTBFq1HGKD0m+h1LzJ2l1ilYF18jVghlUkpX4To6aei3QubkiMHDGPjBq4Wphc0uUXr54L0nl3xhMqizEFC2URB2ppZbs6qWWMJfGIw2SZep8Vp4yERGhpel6iTFsbn6UiaFGi4mo6PTNJy2bzoWDGYEZ3OiSUXi8lMbiYp7rfoAgWxZJAYz1KBrsuv/q87dOfgFpaQrHMwx7olkuyeOHr1YRIweOJ5CMUy3Vo0H50EP1pQsmIXU7Lkl7lk8oXG463W4hyhzgSFZPtjzYllCny8TUfVJkGC5HSsOlEq2LNp1AmxCF7E8Lb+59AtO2d7yhsFhGiU5q9OonVki1D7K1CDqzQTyms6BR4NhBvLNNDXPYgeTdJdUR7TysesK7vqEH21vvhppZVbF4bPSxXMVeo4HCqODuSLACTNJ29M2tpCxAA5nOmCVM7S55XrsRkWvZhHI1IzOMJUL+1a+2Z1rLumlhtwWAOA0tJ0lzZUH2VyOLy/+6x9s/vZS7UZhwzM70Bpbufi1FhwZ25K95sp4cTEzIT2ZiNeWV3e79RzReuOZ1JmxqLTnjy94XOx1u70rXbn/XNW/EXkd/05cS1+Rb3ftgfSPGVdKlOrIwjV0/LZY33c/wVORvXyWAFpjEdeKzMARE6bOhytKSgbzlZyS0RvnCBOnD3e5M8Bd3uwjYj8PeEFH+BzIh1X8DeoyWHBtMn7vW56j2XAwQ7zC7HG2ym+U991/4O5Sxm++v0+HJpW4Ujfpu2ZNZF8duxJd6Wusbz8tAtHfuRc+k3Wvg9PhX/DX8tD2Gqvw0nwQtbGk6FuV6IO8rn0wubbuy502bxtcp7qTT39pHfGSUBS+C0vzLrfeORZ/WdWwktC1Nh5kJcQVn7MhwMBug1n1aiP/5Kf30t4GD+a/la18nkKcCnALh24XyBuvBLXT2O+9ioegEBxWbysyydGFh8TJu5JC5128wodtHf3lQLPWpYXsgCIPC5d9lo36yWn2t1RGejTnkofALqhqVi776LDQxJvhhUyrP7cRx1xFvj+zWdW4R9xnZJ+66DyCWtV7WKbcMuI0EndZ1g7ELen5f0Tfj1hX0eDB5khoUnm7/iXvyfa2zFn1maOXQb6xpqqZWI6/ohr79kY27AOPrc9vWOlcnJ9dN0m/OzWgNASWY5rS6LsdkXdv0h0PJ2bqzsL0/LwJI5SThFFt1PKqOpHmteSzpo5iNOx8LTeqNS/86UgrEmzKhXSHeGcXG2UlMHR+90sbP/WtLmk+N95xHOLJDJBmaQUWwZhFay8a7ckwwLUOA0kZRk5KyUfaLEi7WBkFJZc5xouyLbGSBm9uNAhjeTrEboXS/xvX02FM3hZhpAcanQ0xFyEJeHJbd7xisKqGC21Hx88rpJDkIHjRfiYC5ar7BkAAmcBBE6kHRe4UuH8CI9TqStRk+D4tUxWtptiXE4wNinbQZ2WuB54eedpYKEE3IdeeieHg4q1jK0Kgb33S+3cgBwaYYTnoNRxMbuxSWFYpCcc6MRhK8mFvmXfKgx0+nHWBagnYvGkx/xPtjuOiq8lgSkR3tFvTnRVbNxQ+F53DnjpZDXg5zpGY60NB1VyAC00yy/TS5q3LA+WwdlVl7qXx9ojzJmNR/pkrQA+7Bo7DTh9XFHmEp7MyP0QkI1xPZ1H66lq8N4GyVV26bYPANkYu5+ehskwDjsnuev7D0hlSiGxWXiasZa650LwMSgHiCXTzmwBJo3fpPS0oi4Z/IF0+95JYjGrPnw1sWS+9ptcoHu2hwqnFXLsU11lda61QCIFgJjMFmDe1puGcYFXkD39obYbDj1Q5gC0jnW89aVxsbyydw1vCNCCKOfu80rMHMrqfo7z1VnJdK9v3HjybWRmtxkFCbDsW+gDZq6e1s0LvGdzUOm93AYsYPLYXhgpYnSX1HffXypibuMwXat4syuDvdD8r5PU3qpMKiry0eGuyOEaSqOlZQS60KEPePGkMQ882ybU0aBm7/7LrOCw6SN+HZwN7sf3t7dOTuGcB0usXFh+8KEKELMnvLGgJgMIXn7347XAS659veHOq21AAoWhPVzA7C0kdz9Y/8LcRmN7lod+MB0sv8tjTFTb1nWjrwdCFo/cWvHn22DqI5qa9zQ03mqqvwMNYBQg6OCY+E8retbeKmzMUR36KO4j8+yZELF9frz8+QfGTCP+IrCw72B45Z3TUYUYZ4td9th3JZCKEvvnUQ7MCM0vibiRagcmIJgFTJncS2wAywjLnz5zbD36QbG1/66wZaLimwrLB2YvPsgbvLdD8hR/iZJaAbGyH+eAxV/bMCXX3vam8buzY5N7tOaunbmFrt0y11pgMhOABpkj7dWoceyONN12x4rtgFkOTFr/r25R4D2nV/QeD8KIdJeW/BsYKLH7aL2obaOsqmsFc+W4W4tnYudqNw8TCPYC5W4szgsEh3ByozeQUa33qlTVb3zkt1pJKYVweSQrBC0p1WM7lXQdCRpLGY4DmhoY4oSsyslQ94gomY9OiJPHc8LxUoMB06cQsxwH426+zKdO2IIf+MXQD7AlgVbxCBYFdJX4jEkHxk7eTRuJYTjZ/pFHHqh0Y9aZ7gAkIACzGDngOPSVjGeRG3dk6N53hcFugM36gPyeBxX6QHnM03GKcBZgP58Ne42Rk/rUH867fDZAog2X2CwfFHj1miLABXn+nG921pwCOqjCLzjPhnx15ZlvCPVDu/0znpj5APqAp4vNXuF6aq3Uq8MGPBclz7DLjppgxP85QcdCevD+q3bdSsenAjod9WKenFTqFBtUU3BddTXOveMGN3DfUDTk2kVmnFlSuvVGC/hG45psulLI2uJj8UkyYDlQL+i+1sB9XV2XY/fIb4tDeGnE02R1YLLWVcWlD2dgOnaGCpfecQc7zZ1yvn7VWpI6kRIBBXVy9McBCcnt0CSnf1mgVREmfYu7UaSoLJmcV0ZWhtFq0/PZhhK6UZSlhwH/1w6qAEAkgPTadLuTHadR1j8r9EYhSAlHStwGvAM45OinBau9mOOC8k4X6Y/jQooG1G+UBmfHdG/o3OxWOjh7uikbPNecBfYfyrOGrYJ5EBhHCIEIRFAojwssaN0LN64GzT6cXxB9Lrw7Mqu0oLD/cKuALVJ7Pcbe5i4Y6hzlyMH+mSPVvF1fX76afIooP7T9Mt1Qsfq3auhDISQ8fiLayPBM70SlQmX884Lnumt1c6CjsXGd0VCWfHUK7phH5xELs5TqXpfX+cuMGo9Eaid0ikEpDVCbijGzz1ZdjbHOuT5Kmuoil8QAS9TGkk7zOJkarZafbyUl1FUnxA/VJyT01ZGNakk+mdcKQHr+hGXMNcSulApSNmSwJvkUvM2WaaclKm6pKapfnxoUboMIj7Rlpeitki8MrKeDFu4vVLavztKgdZu5l7eFOomOPfzwLZZyDcDB40/yJvz5A2dWe8GeT1SUr3Z7YiXlKz2etRcM7PUaM+9x1IdU/30QW5UeQVSUcve7rpiX8B9sEzIKQXQgPznPRfbqrrGrB4XwlS2cPU+ovUwIQCmvbe4uA+RL5cl7Fs7sVQ1zQ2/kh2cO+4J6KsaGycSpwSpEqKuYBXNLeQQcfmi6PwYbj6uHPvkAm/nwSGcmak8/nf+mF3+m7C1eLhX0Q5BwLOmYCukKvZaaOKJKq1+ntm4CXcSe4UP5qJpGAoqdMlvIMPsnxmJQ6XqM1MTVhU1XHWLsSEp/BSYAXHbfYC8kLV9ZJdPIWve5U7m/4XeqhsIDnzNsSkmjrpYH5xqX1P2rpmzedsBQra7m7W3j66Bwy4gRWGG2/WHsuWMJkOPjyDodEyzFlFGP3jrh1xcCbuqf/KtD6GbOjTsF9IOX6Sd1AqsEbufu3iloPXiV8SwEUXpm5mZpVW5GS21Cr4B9NNfMrdK6nLTm6qSBAkdoJ5FYRqxD1FluosAGZI+r/ZW/BnV0YxZ3KgUeCYQb+S3N+HrZXxuKSS7Td4j2rsvTyu88DquY8ejKC/Pddt2YpNKCUvz8gN0PCQqpixd+QiYVgC0KTv/+P4BZJ6ZK2+Y9t9xhX+D2MRtApOwsaFtdev5wd7VT+/eZ8wYv/YCSIwqFDaTYiRzLuqUFbvmxqMd8gJO7fqdUgLLweAgUnPeooGX/2q2wjM5I0oG5n252v9xNDVYZ97OTW/64rVKUhx+UOV/Xgn87DxDZbw8Iu0Ivu11vFKRI+ssi/xAQtYypaZzzUO1Ps4JAoJz5z8phXQZNN2/DY4BuOaOpiJzQe99lZqVYJDTE15lmN1FSUVkKSxqWWCNWysNHgI3VlQzm8fGOuY2e0e2tz4zpte6htb0P5UlFPdAia0daor27sKSiWymhD7Dstevfgm1RiT/HsdLfwi7+v5qLeAngfFl7rTw3Nas0q6A/6CQIcNYn8tk+mP91kjJYmUkti3zGH/AcmDj7+S21pVy9GbGNnz74lZrPrA3feG21Dryz/rF1DLbYYWjzMqYhF7zIEOpirFtcPxLPjT4XjtGwubZ5Vr9jTMDycCTm5m9hxZe1D2N7mz1dBxmx6C12cdmP5Q8iZ/t55Rw0rc1jd2cROoni+/8rO+uaGV27c6iVDIh+cy9k6vORXoM8pOd0ljbw5AXDQFgEL2IB3FrS1cOmD3+ioxH/h6CqdPQoKVafSPi+zTT/Nj+PSyhZ5Jm4Qci8z/+HvhJfcfGPXOx0YPm1SXns5kp97pAyMaFR1V4k/QJd2teIstQ1aecXOJOY+5bJEbC7q0xmdEBROWu+FYVCIFQv9+e3YUEezdzilv/Hqr3skFuf7DOHu85iAxuy/gq3cDkB3LVZzwR3Jk8tms5apxtnIi29e2pGM45RIEUmG1ZrGFiM1f6+iZR1egYeY90VvXh/6gdNzXCpf4pYWldFVJ17PyYe8vphM/jbDf2g5TiXLnS+ayS3j5Gu3zrIPmEXxNqZzse+Zd7kwu7ZsGbpomdSznbs8P+egFlZgt3DlzZJ7Z/byyMf8t8+AT5mXniBlGSC4vIflW68Bt57y1N/CJ/u0LV5EdsIzlvqOg9bu9I0fm9+ZHyX1tyzPbvUs/sUx/YLGBAVCfkVCQA8EgB8qg30tNla/Ox08mw9blaBbk+3vjnJF6lEGiPgBamflwQCj2a5CFOWlXxBnbVCM7cw7X6OZw+q57ay+p/qGiESf0VxygTIduvOSrv90nXGL3vzB1fNzQIijvdHMshjBqupVQY7qfwWntxGx7puz5/5pBTzVHZiSWeZ7gcx/lZM8tW5TNfu4qUNpc5PeO6zGZy+XHgW6KZfA96vRf00BViz2nG+qT78iJrRMgQwZmSk1+wfvDt2X1Pj/jGNX5oa/6mbqcqM5lDo2/oUgJh0ygHnMUE/wfgKP4YhjgvGhw0S3gmfav5/8Ada8E4TS4SStIK9ObfxM5DUC+rd97AzuSkXqEdpdQUdQR+2eP2lTH2ydnBmt6GSNdfXPX0DB03pOgvztE2h4eMoX9NoVFGDSypfiWk5QgmRep+JwbXTgKAODcgoYLxgvsi864yUoSu2JYY3eoG4GXh6Yny5UCdy+lnRMjCMbHNVftT00u+bB/yKOXPcGTRsBmQAA8yM2UXNtI2g7bRX2r3FUGGpUYdVaZ2qtJ7zgvVp/llqBrdcx+OYdHR6pYEFBESI2cYyICQCwJFEFHb+c4Upk0Ft0guD3Op4jsdSEthKEj7eCvh66spls6wPZhEXzVyNQ3gve3joZPIDfZdEEtI+Cb2Q0Mm774g4cMyef854LsN8rUCNIFPDn7ByQfeooPUvuGo5ImNjwQDTujOnsTOHj5nRmx/l4wOFRpxL9lYN83Miyh2AtzS0lOC/TTswq8CJLi89GjzeABQLwgod4hndwMnk+MRh3XTX0rsJfeEPnfTEpvAew2RHuI3u03WI3vj4nujGpp3m6ANwC7Hz3vRo2y0ijn4wUnUiLJwZBrqfsmfPFvfHO9rF2NYrpl0Gescbqi/FFOkND9ayn8yWPB2t96+jerSVj9k9Qmk0Cs0KKTSco89lihZSq/ojo8JrwbBYKvpj1qgfpGb+8O5abE5JYL5ODbKmK4a8nUdyMGUplO2l7AZgqWFrPCHO2UzmYcFd931yyDdRuVVhwfAOP93a8qaciJEqAyBNdSWks5aAsT/LDYoT/UUkT2wlreX1vTR8psPmlzsifSahWaagy2uFLZ2bnUeYI2gUmvFM1+REd68OGJCrjBVUT7G7pOcQAw7zdDsCPeiQCCdBQyCgn2YnjoQV7+WcKQS7Zir6K5B+UMw/WP6/BfszgMiLDn/EtUsX2Uk+UrQFmJt6pvsUY+fEA/nSCEpPxNvBSGqZ5LjkBgPcvk3a5pWfOqa/dtiqv1Tf0OrUfmmqfTvkmXwDl6/rq++6cb++4tZRCW+0fiZt+/7h95Ubw+WnLh7bXNTGDUjA1/rgyomL9/chJqOPVut0u4A+HD21X2WHz9BMEcBLGTEXGzbTCKxPQxmE/fyk9ZFrmz+b3z003hHTE5MHz0/LzbOhZ6MmKRFz6W8kBT6MCPAMNtxma/V/X8OA7WLGmDPY1FrRiZGJ+sbJ+VYIYW5Pb0Bsrubxn5MUTCi2PFPE7YKgo9UbfYc0VFmivoiwrz2odW4NLsZcr3E4Y6O96YwPgnUQHFAOCtWApaUPj/9J9o1ApdZ4ebxfl+WkdfWwblRgmm72P8gypc1pSSKADWmLrETRP2X9FmblswadQQvDSXpi74xrrcnXs/W+Eb303bS7kfFnUHNibqfh4tLzQlVvVP5fwsiDn8uNLN4qHam5H18K/yp632jLCn9ni57wbXvkLiwbaI2qzEPWIrZKlwdIThkVjBicy8LoUsGts4d//OX8HUYGBIfIBn80Xy4DVzTdbMA2/GIYsN/Fvx+eLzN5bJWxkRfVRs9SKY7+FnyjqKz+dFVNqavGTLiNGc0CAYMKGQJKp7m2FFtzlECl9/Ebino9I8fPgX0vSVIVY4lvS3ptwly2zyWTgKq/3Sy51u4l6AzVD0IM7YzV57dWNJXPH/9LshzSP5R0uUGtdVml8sX2VRAZiKHH3J+jSQ3o0Qc8OEjJwF7xREsCYRU17crXVvRubTqMnB5jbU5YlkG1BE1cZC9Noqf7m25/mjob+bsacZ9imcAaGdI1ZgGSp2nHwGFviUDvYDJxwc3dLkUuPZL1VOeZMqNAkUQKhO4BwFg5G8Cp4PhL/8Z2huyzOqm6OjF+oDYhrq92Z9EZ66RUYLAyboVRyLFohRLJnQN4dMBK7oy4CI7G+/SG07advXxS80bo+WbdV9zIZ/QVUTsfruW37ZTjupckvReOnsgZEThmGgfYktbyl8V+Sfh+QMLjlxNvQBkXh9Ao9AhzxAXlEuKWu3gvb3B/iyIM/0/rfASKYIGgS2iwf5ubL/85H9j98Ep3cBUeGldNMDAbyK0ijoWFcXuZ6vJmm+uV4oP8fRatUkd8XT6UvYAP8TvYf1fQCrvEAi/ed2vH145GOGGGZZj/9m4Hngf/2bD38j35uCFH/o/1XGsWtfATEosw8mXHMrbZhFHnf2+Kz03E9o8wAlFwUl08UMhJd817DpuY7a0zUxinQb0ZfIQskqa5af5Jkm1fxLnBD46AIjW0O7TbCn4xS5RhcC7rQBZVuDdrL6/jEeWH9p9VGkir6NWK1WLdW5ATJooyMmLJs7ZbJV9VLxQKCHRWbPyzvoBUVcNHRZWn8taf/1KPP/2tJX2nUxVe0NsPKUgodmbqf+9RMUT8lVNyF1uff5hCu/eCr7twJlSu/dFepUWN3qVMH1GlD/OrpHrfYRXabLSaJwzmSOWK+fBdUt783zl7YKORT1bTCdln5LlwU7d9YmYKF0MgbtSfx1tult7q9ruL/Z7BVggu9Yclh5u17aFB3InYAr95721nwyYq7FpByf55oSeSFz8YoxpQ1z6KSz0RoAuVFOQ5V8WlGuo70TBq1t4sINLsx/2nFb1rIy155Jv5l91KJI4N5C5+Wj+ZpvZfdJjAVE/qw1vBhWN4GM4PBa8iorS2GMrFrsH9/Cwb5Xf+uOZfnfkx7TECbNsscl4wB1l1+8g2m9g8+q1ts1Sv32B7pBsBXg1qExzUWTrk/R5YEhtc7gGk7l/SvCpXh02PERXXEdtvgk6KWgbKnRljbxXCZ6U1mW5pKy/c6Dmu/l9Ck4hQTzL7GechmwbXc4ekBA4Na4LY76ObgReL1CcoPdpHuHlumLwR/p69gfVR+9FK8H7gf/jUEAbg3IbQ8ap5GdapaHjfga714oasovHHg4KVIX6ykJMyX1jSen1qvCHM8+D/1gHtJWbH3PWdff6r6+8sGoF2DACaYmQU1FNSwE39eAfGXnuBuNszezVGKstX0O/AlJwH+K/QF29+PxM7nrVVTFFl12VsMSuOcKUV8NWzwkcwNwcKEfSdOsMCX3NbYMblQcZlRwuY0pMwzNrF95RsEEvSqsxCeNpKpny2yn/WUn5fWv2MNBWbkzgFinL7wKB+fyHwaOKI4hTXjvxY3T0p/SqPQNBg1+AhvpK4OpWrd8x0Z6QzG2kHNQgcxezO0SX8DW+hMRnLmW51lA2OBpCGLg4+K6FdbbY1Edm7FqxCFwU9j/+tFZ420MbmywfFD7ReWcIzHvnTYGaBu+Xm+J/xNNvId1g6CXORTt1NSWG9kzKZosNoq1oH7ZoxSU2slge0zXcU2FZxr+PdOas6B6WeIr96dRcJw1eYreQtiXdiBq597XdWmlbTJPYRpySGNt839OW+1LuZB4ybuz57++8k+NDgNMH892Z+Z+rLIOkF6YRnyQWrzf8Ome8qMdwydefwR+uhqBQcCkX8x0U9KStMN7fn4lgU8s/2PAACc8nH5Dsbh9Pwub3axr7SkFZxdUzhQe93Wmm9FonzmAY3U4y30323D4SEEB/DUovOnwoI3JpMDy8V18ry9t360/Fj5fvCUD4AgYusL5AOe97GxUWRBpvUw8OLBjJS4QHXWLzv6lvxxQCNxd6S0SINuhLVFMWKEHh7paO2kTX3G/KR96Qu0J7K8mkBXIhVRiM2FAqbmETTkuTy9ylx6OeuSCps21xFPid6lmpUy41Ndt4QuLvy68fazywEuBI2wQcOb4CfwaVcsnQx58Ycr0k2AIFHE5NK9n77/ibrwWqArMuUdmXhKgejeQm4GKDdc1z1KmbwhmRK/BfAjA9NHKsFkiUXYwYHw01OdRTsN4zVQUXKl+IwzX2YkpReOHSkM6Or0f/G9lJdhri7LbAWvXEatyr+enNzlxMAsZD4NE7ZPE1S7eWiXgA/0wOAwcIpQJ97rcLTLAK9fLzmqBiX3v4Gwn1/vjQZFLrmq0s2tBS5HbyYZTvv8qdUXGOrohgX/udpvY+rZmgz0h+NbD48P371C7aENiLxXV/3FdPI8SMbo0FHav3Os+qRnQeF52x00n3W3XxcNLfz9MuPYNm6Bngw6dDr9B3pgbOQz/NWZ7aXaNKzwi926NOpeFZRai+g+XlANAwavMY7ptmP+a3wBniM9jfIq++Z1dGfjUCADrJdhBdl6+9hdLFWHpCBYmlcRqkvKUVQbahaZ3zLryC3YJ4W/vQump//44PUfMlfUPx3tnJ8ByhmtwzgTcEW5j6tF5TBRrem9L+kG+sTkpQcExAR3+sQLRnQwSQ0xl8vOwbcFkR9MRybP9ARxX3WaTrM89ozDRJnGLf3bxyOO/iph4AEqeXrhPG/DzozO5q53hBoyIKC6YryOpNnLPKLIP4nckPmFRfPNwDv9z7a2hWe/QNKjDDZDsd/uoSf61yz+KR22Sv2iSUBsD1jzBdSlofrYW23DPTcqL1R3g64N7UPCV5fVnsruftwobNSuLIq/LdGMmqIu9vM9/THhsdEjS/Bb8BMQJGdNL18PuQXhATYhfLP/BK6O2L6ekascce5JzzC5VXLHuxX+j7w+s+Rf/wPPnSXPgJO0B4DS8dvj681nJWZRToNn+/JV82eH8FBP5VLUQ/VOVE6zRblCHNKnNEi2wK5MHEJ+Kdta7dfAiZ0EpiE2+NdAJ/yAWXFs+X8GuF+BuRU5WNjEksvaqEc7R50M1as5wfdPjyl6vfy2rOV1prNLhWAF/jeSaiZTodVjg/DvT+Y3TzdTECQwsOkJPxgBvOAmQCKAQ6A9cqmwfqd52y1nRLnkq/LPhGUe70novYMQyVSxV6IqPy7fFTuIaiXKwMfn7w1Oje2T+X5T0LCe2zy7uzw1J3GA4dPkBeQEJc9d3kgTAgJ95hBG44kB6RwF7yeLiV3+j5kRIW4IM8AAJjBZDADTAIzO2JbIZUQL7ILqsZvkGQqIeXED5zb+QAjMjFBJxInuwlyrwjftku6bmR5iF12SZUNsBEF3B6jdoht7T7llhKYPJHtO1w9NHSWXIIfOUcq6iZWJrjOJRr0fuGQgf5FXpx5X5p8U74p/vJB0ecK8L1lZF0Q2EN+un8VuKDo9uENAxZUdUYxWZhoj2nE2bkvJiHF5kibe3FlCnqlaSiOccNmafd9+2aj+PWYRmuF/CUYtawPnPdap7Aa00NIFHKEOeKGcstxS1i8HZPfflT0xpghLAQcy5JPv+ASWwMF5T8/89WZi3bsrx3t560twY+drS8aIdbkBhn8v6Pq07HoxASDWDPVUyH/kvBtp6Rrd5bz4cxDJiCYMlPPrBeZHGmsqR1vr5S/d+7bNpVxg/WXqSd5W0ifrFMqyETBbjmLh270RmHoD6+73ZCo1upMNlbYWrKDCiS7clXd0ZRVTYKZgKuoKs/MayH9Sw/ru1vHKwemDjcaW5c+XU/JG8VffDwmoxDwTHlPTaTs+034QyJnzE8VRtVjDgIzWk5YVwdDhhHDK07/FY4n42PlqQvWzF4LZ3VEL1zyX6MQezS6YGuu77ATaK2zRW2VSMkFxDYmJCNhUrLkHRU49/bQE6DLwU2C/kw7JkPOQY5uU8+ubIY73hnlnUqBlfQ1kYq04ap+yxcdOd5Z4TiSU9ZpSiYDXlfcDkuitLqXOpbIR/PLIFXZYc2CHl1Gxtwm00hRsqXlaJNBJU8gx6B4MIA5BvxJVLCoFZPg3IyOd27DBIe3IZ0zquuck9vKfVx0qks9PNmlHV0uTLlrek0lwYLdAm5qzcycac3KnHOuLraGOPxqw5IdeOzg2CoaU9SBLJAfWVQyYAQ6Uwzv3nGqHcXk6VbA30+UY44cKcPx/3+FKb1arl1p2hdcN1NNiEog5qTeLrk6+4PzqdZUr0zHalrFY67+knqyCCovyGLmBTUrx5x6Ll/DMyYvY7DLaKgivKlZt6jSiC8WQmwMelDCqCptlzJtyDoYFfUlHXv08GseilO+NCxijHxFKZxKUPmPfjVLzWfUttVmHvyM0fR55hbCIqji7s8n/T8DMjBbBkOyQ6Ue01pCRRdiTc26xZUmHFjkZYvqyktAZDRM7ZNTukvPY0PKGDBGNJOUEJ8kfDZmYSCTyRnm9PyI+h9VvPsz9iQfpGvka8fo100oOsflgfzYKNihj1zdBWV1el7107jzyAw6N9L7TGYdBpwxgTN0GeS0UuOV0NCFJBMzvaTCiAcLvWxzPkieyrAS0BkxEb3Sc/xidyKzaKnwIFfaw6rRqvhWM7nNmN3mEtIWQh0NYVH+oVm4ITLRvbwT39yopSwVa8WPaI9nYSCxMNcxpOEic+mzazwHMZhB2d6ORLIwVFfb2lER2baW14OoQU2sphfUF1Gvg3UHwHUXbWPBPeberdhbXddSymZhFJiHbHd7BW+vpryeuL4INggeEiJQqymSUM50gsOoMA+tnv5WGyqzwXOe+HLL+KaYq29gy9YKTGHPIVT1EQFTSH/b8R+/S0IWJMU1DiuMiv+jbvBeTv1dX55jdY/aC/OytvAb/a1LA4f0w4yjguWcDbAdxy6popbRuCMbhADpE7ZTAybTzMyAHtn/PKQ8llhmlSH/l7hqWy2sQP7uZ+GzMgheSK9yVrkj0pHdzWf5i2uQPl4LXi5NLhI3gDircz62CuBXSpxkWKT9kMHftD3cxGemAxJyx9na7tIgtOO4OerP8SskQlTHQrb7l4sZI7Fv8C8tVcuXbov5R0qbhGc98ayWxwwaxELh9Zb99ULp5mndLRGlSJQeqg/8IJsAZwm93C6ZSsVXf06gjvPXpm4s0rM5oqWEHt+ICd39/S6c2ej9zCKlJ9haN6cRoFpu9+R3PvTtJ0xnJ0T0viHeqkfQVylCRj5ey4XZG26qzW3DXHM39VVtSNFNBeC5Nj9HtVrnPcM++hXkvXXzqLjXK3PLZc9F3hwRbBtF8GZ6+r/ik2a6wriaUxmfjuoeaBbrJ2Fp3PSy6Vq9QuTS4Vi0tBr4nXagIba6+AC+xOv/nXqgiBw4ZH5KvqmsRNqx3f3Fw3AQ8U3djFLwdRjZ5PKqSmVEjV5HTRw1jfvOKtP2RtmKbouIihf7wXgeZQL38+Syg57GDuQGzw82je4Xs2eNPeOTXAAl7janDavRu1Roe1Tpw10qu1EThKCMTO0Nuwz3rTLx5PPofebhV7zdl6VSHFqnKnVIlToq1jPylTX2VZrbx8Vnc9pIT4IqWPyIGrXLkBL23xkxwa5h1OhBFXvSXqq021ejlsygGnboUJV0pUSLrVWhd3dd6Vajdat+VpKnfqcdXJNeWlziTHepXZWWUcPECHjB1APtCcTvOTAkHzFn7gUPwLGygT3BsV58Y8YxGuz6Xx4j4FLGuNOaue7A8oC1AdNKo9n80lZErQ07EQZjatG9XPzNFjmzQkgLEgDLg6B0fShLXqpw0kx2sIdA2MEn+q/txKogpdpjEG17+3XVJOleU3WMgA7XG+fLZblsWPb9uuODKQrbdt1HVhA0nvNsRgJe/edts978H08ATFcJVTl74z8dqDFGk7MU6lxWxfKlX2+bkGJxQipyo/CcDTyhLSrMgUo5wPYk//bherzs2p35o2XgsjGETM6NhMQE3ZIaVV1+oHAiRV8ynYoribcxErrjEtfGJ86uqY4kxY+2bHA2K9ztIhTXnJfkLDav/0GIsp+eAxYkUy1MW8OKJUF4OHFJ2w941uX+umHWJ/U8cFQjVGhycm6UJSaULKmhQH6AcEVqyUVaOejD8OWkkalcQJGY3Ufz88Ng6sine+lhMPzTzoMK97UCazKdlvxNF6FfG8E/mrhiEEH6Y/S75woTMqhauP4kF987kVKTlbH1dm+ryTdzc3TfJoprJFN3FHyHWy0TWB92z7jywU6lnCFQCeZE1r74oYTEkYUc8VHJAAdAoVP3Y6A65Wv8WIKhztJQFEFoje/RN1qlxiv5ayXBK844E5AHV2UljyYJCt3dc8le09fyGC/aXmTsO6NEfcjmT2DdSiuuu6mpKnTvc1pqNdCb+x4I+dDO9GW4jPJBzJlFUP0OJfpam4QOxd+35nX8AbN+PWuqZxLpxITP3IJcFMkck5bGLtebR6/HBKaHC9LBOLme6BkL+Hoi7bJZ5Xuz9EtmDEjn7tsa1L5j1qKnQdDOZyhJazzB815UnyVKQ9B+87HIOuXcyHY42OlIc+HgVUYTEpeWYu/ie16Ll/PMTvEiHfPlUqXR4DPnGmJcywcxENM4RmI75GnC1b3xxduT6WPJWXJlPrtsySsuDnj843J81t6EjxNXEuuZWQpVPqt8SWk7WGQwxRtW+xfAlVnJ9fSkPT+cTyBti/6RnhANJVcWsK49pHS1umSbclb86j0OZfMH9uKnl5Mc7sUOzQWJp+PdoQVaba07041ZF2v1WyLg50Ns2Td0AiBWxC5E3n7OKlelmkBQqIlCIZsrjD++mpCJPJn3CN+xlpJE1rboHQ6do1ZfW5v7mf7BzafN1pYZ9eJtO4QCy9kdQxbJKy3Q6cxIiR41bZMIzIRv169HmR0FmY/9k7V+slUJN380+GnckdPXcDQWFjcDxoclslQmnqRcpCnHl2uF5XB/6zUH1L4DdbRSPkdDbNXbnmfsO6GkvGpA5WPozPJBNOHb0yDp3QzQtigTakRADFNfHbkSb1E8dJKJQJdC/507IP7mlzzOULdz7lR7eUYtkPzHNViWe1c4q0KEXLZQSJIrSQSlOlG2akOj7Ked4vnv8/IrOKE36xvkEyBSD2g0sNjMJwrAJiDRA5rhIS1moY0JMj9ZBdLAQeyhIOc1IcqcCU1IF+6Ea9RiZ3wT4nHGzUl2CiuBBmdK+GDh9JWwJMgBUnT+TFzQULeXldrrVUENdGEuQTlVs/ySDjwOqpaPQPzA6SVfntKDJKAvwwM1jO8EVYVbE4Z8kgXHp6A28s7ZIOPaovzkx6oQV/OO+I2hAkRPD9ECy9RRfZY0zaaIk3nGIvf//YU84oJZXYcXzVVStbDRuxCG48wPzGO035eJrxCWimqY+T9dIpi6iLXEryQk7py76Ub8dybW1TSSB8TRE+PLhCWiWiaUBkQzs8zVH+7N8biyfBxaYnjlTCgz2sjjVQJgLqKQgYNKtpzFnvFJhszlvn4GatLIpS9x0slZmasepjP8nEt/KBHgB2A7MDqIqpHj4jl9AUYt2bala7gfXSfPxXMX+Jt05JD01dfok2zzs5Ns9A/FaonwmN2ft2y34sJP8roBIJE+gsQje+g9P/A/EiAFt9IwiX4F7BvctTU/ACN2P1n92riG6dZrLvwAinkb4vmEHOByFrRxqbe13uMDozUjlFoHvbNcswzjBoC+Ji9oECl+IoYH6tA5fkGr/Owe76y0b0XA4N9Oc0XJVgHjV2UJkeW/t1l8JpvpevmEzTHfc9/0tNDtFwWvf6eHLzR5f6tT1mPJnuiwfCBvJr96rWhaburp38EMPP1Jo0bmmxI877ky3awJljk/2X9r2DxMAuAnK8tX1nLh2Yt8amj9rjVDU48mcfXr60kIcu4hz8Vna9jQR2csvbf41VRy4p/YIkhSkFWyHOsL4xO1R4CJNmyN/zPKi08dDAbPi0dLzc7UvzxITv4XwS7sQqYbHcif6dM2vKKH4s05Wf/e6QIqo4Zsek7q6a10Xq9LPnQI1Wcl3c65VTz0rWZXzuPphIjdit/vRatp1ZvZ9ZODNOr0UF2ac9aW+gfZ40tOEufbgJFnuhFiwSL+4VfsvXJk63Klkvs/b6VD4L0hepXdGtn/aEVnsc54r7o7cSR5/nzxIXzbRnswxnWn9uxXeEFkMzKgbTsA1HRbL97yqkzRPOvgaaq+lPzk23ENOOv6CnuQz+PdM4cryyO2RncQ4gE/XXVTjMvGiBLLX6ZFtiKixXXwmKL4qsgxaNhi/vmAt6wdy93OCH3M8gNv11nibdkwOBvuB/cvEwEYuXfLo7XL73dE4yJTsmfnEIxb6NmhyPnUI6wTAML+b1h20a6jJr/J9a6gKhMAN8TdK1oILEIzqRmyApkx8RIqgsmqzunaQH6uZrwYRK4eNRlPNXhnP0QZGsOBPiEmZS08LDZ9V5zO3Z9JK8yVGnwNjUmrNvmIJjhQ6CcLPRH8Mwupc22/ZsS0Z04oQcfG5uzVDnVW488514y/B8KVYlcEkMwcnL4tZ/C508pp3lFb3ESxqncOdZd1qvEXETdSdZdlRw93uelulOSgent3Owrr0rZyrivFTQMol4WxD/IJs1LIXLfSk88/De1v6Yt5P1SB7fkNPHd7y7RlL5cNXh5RmdiF9QUiUZ9NdGr7kf9at3ixLb6+86rxoNzFiJLb0zbJN3bMz0qnPL2gAIHhkmct5twjAEqUzJ8ffltoE+PMiSTyy76f31snkuxIBH1br3Xcz5H3Si4gly/erZ5Y2f2UBjoJCEmoR0wB+uXvybY2LPDD/mOXgVhAcEwoPGoHkUfIg+P4urYOAVafP2kYR78CSglabnqXLAw2erad9aqpEjd6Z6U05I3W7G+a8NNFMnDneTtNFhQJjBUg++UsmC/Gn7VAy36WF4cagzf5oSqYFEzM2a3SyaP2J5ELq3IVbd74GCzJHEaSxJMCCwQGS0YJPPf0I/+LkcCnHkMaHQJGbxQ525oqqHPFxiCJdjEHCWQEl4xkTWhoIGqcMCAk/JdCZegUqV/BoIEa8KB4qw5ekg31iYrGV55UwZ045eiTOmDELCWkNOE6lfRaSCm6IDJODldmw5BbfQhf26r2PqcjomA/LDvcqusI5nLHY2z+M7T7Rp1XK0Pc+M+f2yjaUPHqnsoUZ1VXHQDVnqg2eoRd+jsfKzOxIyn5Tx1BUCushdxUUpizBFTYvEJlj3oaRELvIs70TRU2+InE5l5ZVVoWJOcRc6AT8dCmxR76fQ0MVh4LtaS+Mifwgf5rlsj5iYf1rHi6s2SHq8s+e3DMDT500Ex+oYt6Bg8Z5CT6/1vwXcTn/qQo6ltI4P+nF3xBvK+rDU0FgIyy7LwB6K4OKsvndsChWF/MZwiHf6kugax9D70uqJp/UvrhrLZbdIzUQh9hl487RbHrrQDr8kYm3xknmFY1JW6zQiEDrVeQdvXb1JWSZbGo7uqizyzxtXKpTiOuTsxyOj6Z50ghP1Z111IqzN0u/5CiKb/6dLk2InxJcgK/D0hjDwp03YPOOYCX/czUq+Rz99jBFTzvLSx5gR8XVLPzcfmjN7Lvf2xrPuYNifyFwUtmd/mvV8BPGfA9kOic/Nra1WR7K+n3lTlhW99FWewU+6/QZesIz3/ZLvwdnKctP+S+W1z/FW6ZP9tN8bj3Re9HO+3br0sSPaEZrAUFldAM85nj/PqKw6GulYZI0MG/m9Cgsy2DRYabV7NXGdQUcbgH47q9igLl3/H37JUoE4KHZ+Eli33LNjU6bHlWyZ6ugMJIBqFhqIEY0V8y+qcWkWClTPpW9JTD5wYZPa2lLxaGf9H6m1ab0+blj/SHjVImeioIs7RBXTwwxcFRHjw1KDz4nu4qsCvzxf5caxfqD7PamuO/ZMLZ5XYdi14fY/Ff3G62UN0Z0hkW989R2MT9diLpztxQk7UheqNcOrRcpZmjnQPqw3HHU5W1nSUIPbeidAiBAtAKK+0Ic9yh99ZbYZLXfKKKDu8mL5HWll89Lqxwdyh+jNDJ2CgwVPKn1J1zdOdjH9e6qJiQGvC3E0o5eGVs/EA8c76fP7PXb722x+K7MtpbK90ERKQHHJpgqKyxKAzKQH0K6+qdbOhVcUl917b/66aWaAhI2j3hUDX+EQg4NO6KTv9Dl9IiGHI7ckfzRz/V7pfgxI/v3xMwurVN2VEIwqWjbMZuDAg+8a767bl73zjpDec2qz6PXaptjkWlHm7+Rnr2pxrbV1D0Yq78miG/1cfRRECs9mKoBwftMy3QJ8GZQiIHRYf8DBrHEDMp7HTgkLANuj7k+yL+SPGWqfE5GY/jz0wachdNscqNX+Zc299z99VKR8vQbO9qtf7U0xchyyda9kBa/KyNLO/gCmDZ3tlnb/ckj7H41iW/FX0zW1ojegc3zhDoM+i3mnC4hgVSwAIlEWApp2SZdr857rxfCfAXeJh5vPktyBw2Ygw4LNzZvkjr6GkNXKC4Xvom8oaBpZaDNqjcZdG4JsB4FS31SZKVF+M8cH158TwFHyAI7hR5HQw52hcl7U9vq6/wHEHabqy/rCKtvyKebb8wfQt/GHzBN93g7Wcsf8YCINGz9IWf2BvqR6Hk5Hz0MQb0alcXTffKTHuQ+CjPsHKDsaGhbL4Og22rA1uLLJsMq2revBmK1Bt+G3dw1fnDZ1XAYYKlLX/cV1d3MEhuvj1QX3fYF+UbVZWSpj9ZBFNrmrlsm0cg9SKRxL4KhJJthVqT8+tWOHcT+ZkK5M8JEfAR5T+DJddnGmnrC6TqlflGyvqCk93MF+ZlRKi5/4qraBFS9ee9MCX+Oq2d83H6zaXcgo44ZzUi7WN2Csb7WqLXZpFyDL1YCbIv/r7526xW6rzDXXE6IEBxptT1T4XKaKLygDMma+avO/8h7zpmz78w9IXAz6lzaVpQcj0IErpRsrrk5NT8xQlq/hCkHfbh0Gbl47rJob5Ypuwa+xv7aotX4u4ZJeTVjjNaOBJdWNfizLifcsVuNTFqvEbArZ7qgdu7mgagDxO8Uzh6t+6a4MhM5ejesgbaH4r8Qt+LL84ebbBpLe9g/le7wWatxCa7nl/Pb1pC13FGibhFG62RsnC/fGTmdnNZHm0iFzp1n1/mGRsT8I50WYU4EG0ft4AXqW0YrvzsNPtCLs1O1jY8kzOUx1eeR1GLoo7j0sQWaXZqbHOrP9XrFk4auqS5r9nBrfz8KWNO+CUAzbnZfqUDWDQNiOw702KKQdGgLY7ZARiF9XipgLGDwfZcNzJ68QuyFx6ymCP3K9l6dHgM6/CJtNln9knFKGSOknmC1D7D3nHg9+Qt787FXYl/d4GytxkbocpJ/4ZhWtiwzhTpaElma0HnY/m0ll94lC/U3HuPvD8vnFu1yiRnjjdGXvqIHF+Kl1XhNZGAx9Ay8RhQcm9lck/D7Qk/28+S5ZzRc7st5bsPDYFTFis1d8jM0riU8ZKi6oQSMgzf4V9B7vaKWic6eObm7CKENXDcBOlOrxbi1uXoizwq2wNwg5s5mQWj5pS6uYX6wsUJW7c/ueefHnVO411h1FGClj20wsSgMXgJuYa8c4Nkpm/+I7ws3SGY/koaUvhnLO6SgGLRJz4O0psLdtsLOBf3qm/pVNDn4wGZ9j5vj1o4d59EsP2lxaaSLl1YvPNjbHEvE9wUjl3nsUW9oP6+y1gudMCMrVlv6QD6cf1UBrXPud5T7eeWHGLZAMninZOjnEwfmbOwBSM+/g0UfifDtSbrrOY7bz8u4Vydxsa4PZ4PhRTKARJl4ghY8vkEWVV9tMhGDFdyN3z+jnjpOaR0MeWit+tHi16MDAyRgf3ynnjapWRUz7lEPL3+FNEGNtTMo25Vv4XPZRfzhv7ZZdB3mDtNDh9tfPCfI/UEsNdr1ED4WxQ4MPfokWtr7rwb+OuCtqlK2wVldO4BH4r8i/6zdygwLtQXGt3iVreXh773unDG7tpumOesOzssvbYBmf9q+v/S8L+gybzId4a25T3m/QHcAJVJHfBK3V4R4k59T9mbrjI9Ggj/ge963YX/Xon0KLdtjNjEtjXm4QPRKBViyC6fgfaftzDyQFGvgvO/RQEOMcutW2uzVYwyG4c5/oN5BKCcsVHzgHgts8OJc/N/q9rGvmZA5MjwcTOPRFk4x4w/1vdotKr+EXPHS88BhVYJdWvxiQavO/QZ9s1y8bYN199l/gqwA3fKuX7e49hOAXnGzM81ju15W2LD5a7irQsrlvJwGhd9U0jP+gFlaATn8KQ2MHvhDYz7ePePXNsNyHPXjlDxIAfakmw1BTjatZ4Dpv28qbvbTT9qrAkQ/DT/+yPQK2Jy5rLT+V+85uWGFFEXbrQJjozgqNyNw8NE/YxYAIDcFX6Dxr3ZxDLf64z6+i5oVzMsSAfOwb8Nl6CuWHhSPDJ5n26P+nCQ0+/sdsb4233RrPiUYItm3ydNW7QkO6/sanNQ/tl3bB//ZD0ah7Ldlu7OG8MeiB+en38g8L/swwXopVsi17PvPOL/X+rZDETBtbZapt9r+mFPd/NN4Uywb5/X3OOedvotB4WFO0CvO1OWIWsbnprO9U4epuxr8K2ADM6pf1Y1TX3NAW6GG9MrJ6juWuviYRI2ms3yAhzewVMVek0xjk+XoHXUMopcWYreqkxE9Ij/0J9MJ+YpYui3hBsnCy/uPM73g4UcQN/86Ob/zN41rp8URt8yu7cq3n4G7F3UX8FcYgKotjES4uiNNtALl9u43gQ2ts1qWDEX8QF4fWCZOd7tBf3W0zV63zUXZrsfhAqOINd5NwJgS/ca3fVMIexbNuV1QyabVeBQTGMnoYwPHtW6XGXKiKrO6gfLW2Ocmx3NBeKUJQWm3ktCAoPg2prMgWLT/Kj6xY5OK0FsEz+ocN1HAK6EqTNzlS79tZKFGwLuuOnTswSXPo04chIyf+DS3dIxELIwNlPpPHcJ8kmvUWc8d3p+fjnijbreGOJObbtJNQ5Y8LtZ32QvLfl8jdFjOeozdynQuo/uhl6xmJbyVY6MvTA6uTSxKU+gP15Vrew6RB+fr3A5Jv3OU6WYTUaurDuhe/BXi34aEA+0ykWxqKBjnZURu5kpW7Wdl6vD9/hTfW8AbxZMSsFPmlrJe+T7sBhb+5kjFiMdJCqTyksfNcgmxxN2K8n/yaP0u3hdD57BQ7uPoqWOXrjV2j66NSb17lVCSefEOJrjGIr8vIISfcxtBAICai7QXQNNR4uV4bf9THC9h+71LImvDznpk+w5tTslZ16hYpLdnKRIlOubDZJyAPMCDwA4zadn26GwU/rTH85pPm/gwNUdYtf5FIB0YTmAtfeg0iYKwfNF08elgjKYn7u9Q5ydJxS+LuQGtbjo1YkNAzqJLeEjtNvq/BPAWXTuQi6hdWAcpsJ0BSIU/0/DtIsfrR6XxGtLKZENRzi2GgyIsIVpEpL/MnTgV1C7XUGn/N4pdpVp992mPGtXLl97qHCyE9czHkSvGC+OpGDXr3vYdoNaQLtu+i721VJJrdjmXp1wcpMhFonsxJ5ClfwoHDe8DvljX/OEvpV3CXob+26+CALVfgAzy13Dq3Nlp8en7OhuwTBOy51nU3UadY4+XDQEre2BO4+UWUxee9OUFkycghWQ8KB6Q2LyN9VOwmBBTy4nN728vMxgRs0iTpmn4UZ1PF5lBXEqfOjD9dpklFmq37KmFtu9ED6iQJ+rLTVjpsu7uSXMrIXFqrQSp8NHTjcYr7WzbTBlvpOvv4elONz7vpcXgBeKuY0+di22E6pItSC2Cs63VgdNuLF79NhrAkf3fn05MuOS6zRZO865dcYftSIkAakzkVSS+nJUWrzkYmD2I/LXu/W3HVHOPdts7T+3XHVx7hIRO9HBsjj3tJF+bKnpDZwxXa193jB6KuzzdRvD/FLb+x5743zuIr/9ayRniGlpdm+hYu4mI8FGg6Nb/CugCDj1T7WUGqivyjIB6mHdfFI8UQd/OZVvGGt6om/nHHwhdpGlpczCvLi/mGtfGimAYN+XPqZB8JF8j8LzGlU1Gck+oISuXKH+RC/SCE2DhpeuTymLNHaT9mRkSYKOhHJiNYM7UfvDEcAEH5HkP2oSAB+eRgJTT54ylo6+B9haN3sv8x1+5ImqpZ7Ls86HK8Xtawhc76JRt+vq/NV8Rv4RXF8BeTJBdZYPioAFV5PTNaHV4yfzNnAD+Qv5t3BrPpYOGrWhl4NYYXl8GaqI7xziRwFE/ouNNZyIh2xLeIP5G5I7Hi1nuWFI/mRn/kkCnRG/2Z1Fj9p2qNpJua+fr15NXk/oO9g3i6Xb1lzfywSvl+1qlWcFzwAWz9j1GXvaHC3eKoACVSxBavw5pMZWd6hgQrfuWXlyHET0jQTRyw9u8Q2DCZVblQp/+hxRypIM0+QlIhaDlNpKIOUtj8aPnR/+H2sfJL7aHH3fhG7SnsljayvS2nK0vYloGuyzEKkiiiyx6sxspfMmKEoK90AMbiGd7d52e+SLuBwYjpM6ndguXBRNJfOzOP7aSQFhNQz8keN+iYuVK4R1TR6GXxVfqUNB+vN5qgvIhim2VZOVka7IS4qtE9v4TuCrg9/6XDBja7ab5mnKb4v8oMLmwT7Hk6hhza2T3GMGpyzPn2Jqw9KcPAc3XLk7fjNjDjahWzRm8ljairSOXHV3Ut06s6lInLIkxzR6iU/d3zC4tD2q+WOH9WjbbzOl3RWKXcNLGapnALFPzxV/VA8lj50sr03qgTm5EZ8FVVePlOOSFssUtgn8uMvAJy9Cc9w43CU5i1wK0J3N6wCUaKFMUfTzLr3xAjTXjXNSC/I5X7Iw4L/A6B/nANT/888TV2lPjOyHZa4O5i5/Y3Z0jO4vv5g7PK5qX51oKBnckq1ty/UeWch+f29BqT5hX0N3Zbl2UaT0cysJthvY6ln1eu7+/boLok4fZ35FfOwPzwTTs+vbkot9Wn2d5EZ0PWRqRGWH4GtuJcTl1J6N8oz9J/G7dJhCvqv+NQt9GXd0beOGcxPnsDo19eJlglu8p4vgxmVrFU5DuEJh9nGSTxDTs8zaRT0Fj5XePxru2/uxGz0LjDt4Y/Lmr6H+6CclENZkImrY6xHgMk6r5bO7KQUrqa+Dfrf+DnqRUrhadzfR0cW2nNRUXJyzBFQQpIhFJ1rd5x0NJHprLD8cvUb5SjJj4zf0Z/6C8Z3ySKT3iIJ6Jx7OJ/poFsTQ5Jlxy8sN7zfhnihs103PylqJ+VuMSn3418ssABPP/nH8GA+2ffLWt7Hiwe+Puxe5f3tsttb7OmV5RfSR6G2eMlOjU9IQO5T+6MO9sVxCPeFGw+e3wOekGOlqb5+6f+yVi9KFaajG4WWV5Pbku5pnNR7cJHDMP7zhfKq+z2HjboXPEtJd5wYMPiGAbxP/KAYdV56qtopIrBORJHqxOaIzoA9lnPLsum2Zn5PhOzo6rNQ07Z6zlX9BcTw3P+zICgD5T8i2V5S+/9IXCWSLTvViIv/A/zBbtfXtF/D5WzXVNSVPE/nEjxVuXteRI6/BhkWesUmu9eY+P7AuL8kOM2ZU1j9U3gVLDuefXNV0bxBYnZcI6z3pNYh+DQQv5Z+pekBVwB7rNk+a7mXhJRGHYD/gq/v/ZKHu2L+OIUb31zOmlc9STAfn786cOGHdt4svd2rXfT54oSqs8tmglvNh989yqtPSov+1593EijhJwhSoJAlVuasezM6z+A0zAowiE7jMOebv5wuo/+EpW69bcq6wkbEQ/nXDhkRk6a4SML9ME9DN8C3h6cAFYMOHV1tH2GWVSlSctlJ1Puv6Pgflj+LfZMsv6jeNNwBHV4aJQzPp7SzrXMotRva2su13YiUC1MGwhYZZ65rvZCwWFcxPE2znrXHOkxsv7ay7asCi0vsKzeDyLF8J4M/QOm+Q5rszrqjavhzpdCb3jdv7gs8I+Bah7kZGgqJUJmHlCuffb8zLka7umMubLU0wnSHXt2OTrzo2XC6ViMtHFu7+0ZmpT9cwKJFoaK+EXUMVQLPUXfhVp2c8Yv/ZKux+4/Hre57qyHAwAf+uVl7Bw468yZQY0LQIqJnB185b/h+yz9OV45M6xc/sRmDD9JaFTz1Hxr3ytrRw735b6Cm81Y/xw9Q02n+sNxQJl8zmUgTIBBfyzaumxhLdQeBmtZe2XISsYuHIVXJ1Z0fTGULaBk0nTHbUMD/YpMClJG8fZVzl9kDIE54Hsdmc7OOjw+rJGnVBmUCBlZ187xt5PPL4jZ0KhZazirDgEnGEJ+6Pekw2KkPAF+YgSUl7cPyyypASTPulZwn/r/5ruOcS61bv7q/maUAFIO2xtXkhDxB9/ew3Nc7HDaXZ/8iAOMUL+akiePHOIpAg7ajzyNODnLm7ryrGHzwuGrr7ONjslDsugxTQMKC1fvOMpB2wtffpA87qH1sIv9crgLPlVdmjsji5ndwOI6dH8e0sBc9pHM0t/Tdml4e2GdGbGeWoE4BnQB4A5gXF1yza078KHIAs9h0h/0mwZaIxFTYd70trciTb02gRggXNmlfWw6YqK3EwBsC+NqKbqOyiJGdJoGejJG5O/ZDLN33XzuTaSB0XfS9h+wQVzN6iQAd+3fR6PMRRPId9l79fd1eSP+3FAQ1vtO9XVjXcGL7Gf/JT2un4iwbu9ynSppNuGHZBTFBI3rVraQtuhyoUEBZEJmDjzuKPflTUdV/Vsb8D/7Ingn8PfGDxh86fCp/RfSvnMUqvjp06vgNxwu+CfslDE5gKN3Bgyv/orqjlUEELGQxgtGArPEX3rAj0Rf+o86fFHxcfgr+5EJlqVM2gRWt2beFbVxiWpwDhGED7eOdoJ3GEmlke9F2e5JsuOlWc1Wb7e1KPCi59cs+r7F+B9gx8ZFnUeFTnCj5oPCh/3/WV9rrGXcyD5t1Qi99eGezEm+LN/icWRoyacws8J87RibVTPRVyXxK+OpYUAErtNZ2ifSVfkOfJimnpV2NCeAVnNOUecC30DiUV8jzXO0KmOMUkn7nL+Qt1hDm0AAiOyfrf5fs86t6yCKlpVwDf/68gjB2wbpeO/ns6qvAZecysdA481MMDCFIWVBdOvBP3eYCECy/3G/aT1U5UsKRuAFnin9nvSWkc5UCw2UJ+kI9PKBVvAyvrOMLbmOhNltvC15gxs9Im+J/nfLfWodV/A3DjN+Qnrx1flhfvoPanAUGW/bEOuvhn/+9JqR0U9mCzhfKgED8QNAO4fwMEyTauZN0zOqfh47zIjf4V99q2sbGlt/kN6FusqOtYpPvGRV/2r47DcUdkZbZR22gjZ50I6s0qv5YDLusVXS8FvdNlcOp/lY6+Efms4bzjLWAn4IF1p7wc43IGkJ1NfLz+rzwsPRtGLxfM9DW/AX2PFvXeId62UYFl+9WxM/QHgC2vsNFto41wueCUm8xMj+PS3j1k/Yz08omdl/jkf5fn9Q/LazP27DFLHzvtQkguJRvICH2Uc7GqRRxrbw7au6IVDfGHjAUHzfJOSEciOVDujDwL5BvJHjl6Wi3BsmcV7D3QZsGIxifZSXYS9gNE5xNynUdRqtmP7pfbNkouzRynlAovjQhfnu1Sk/dGuE3bWamq4TrnMZiGEbxTbMuvlJ/mTlz+Q+XhpQyH2Mct3Wk+Kqmtv54pAneQO3h2NlljyZBkOolOgp/KD3HtenyR8Mm4YxLpE0dLWRxlNrfKVBTISwuck7Br6mLvlSLWNo3d0sKX2Auvt0U3PN00/fbad6nWN2HFWZ7udW5gSnL47unPfoolcqCk546Nkp8DrM4BYT/X//4Z7Atb8lryo8P+Mfpw0Su/IQ9XTSod5OvzEYLz9FM+WbU+6+k0MwJC6jjRKTjWpZ3FLuRp+aGEhZwG3Ux2Ll/Fi8Usy/EaPd6Jv8xKbFygnotSQRKqvQeXZiOE1ly6DxF6/Lb54fN7OppVpsPbvaU5gC6vhh2sWIULiqMcgTikg7zStaaPRP530gtgWGJDrZ3TowZKexyFpjGhpkzqC6lIOxBE+sDr5LweHGlzNQ9yaojbW1yY3BVwYq6HAJco89ZGVFDxNosPfa1O8RX6mtRoj2sO6AXq0tt9LOO1+RsA+2sH5ueaPWM+d/bWYvnQToP57MbudKXPFd1DyroguSvgRlZPJVyiMeDkdrZyy/b++8MyExcRfylUlRYU05SDNLYbhUZr0EVJyKimbIKxTehXZHg4KPWpOMDw195X9p/iOVIo85XUD9X/RRLZM/tEaqT+U4k3qEcvRwwSlUjeJZ33x9dEXIWrYuFIbkZqij4ekCOHM6NTzXoOmgy6emFLo2ihC14xrzulT9zUwBcec9q5ebnqfBx7Gz4W/tFHPm24K4fyETMRvpmaOJWunHTBl/Ro3EGSGNAE7DwlG0tLBsA9yw5IOtP8rVyEMSFfXB1jZVWQYTPdEOHndgrzxNKhwPXX5xTfrXNrPIiJSltTo+tr2/cmh6fu9NLhUc6o2d6pvbHJtr2asgT0WlRa04ccmh+YvEovP58XCykoQ8EOuPrESsThHGSuSc7Wi/sq5mmFI95jupAYHh41h4sVXnOt8yJfiFwyAZ12KWGmguxKZM1ItG9VYBW0an1F9dIyMldYBaoejdxWGVhjV7Uyb2Cyf0Ng9f6d7sZYBiXOQrGAo6N30m/gCmBPXyvQaZEDxTJTeqhy3KNIw1az8cMyWNICeXt+nnxPfrS7sUhKoqqk3R6RIFfqZ9xuKJAZNVIygJbdjmy3iFNv1mRBjnxXgdG9STJVLZEY6Z3y5HsKtqOTsH+yAHxqQQFW0FuSbM0mL3JJ37ZdpQaLqstFQx/8/RddETCK+JjRaRYLv+hafzsiWybmCcKnRLwqkSWsCQE7fY0VByTPdV20RuSedp0Di6Q80dAMeIBai2fh6VS6Mfxv5dvN7OUj84eZ9XAkPMiJtAogo/09ZUez8NVn4+JqD0ZBZmbqd/r51wvhoxjKJJTOexI6ZcjV+R87py9nEkyrnhGqW8HdwMxpAHpnegSYff60dobvOLA4z7aRjTetBhofdbZuICv6N8iV0MUemHX1RdczjOTx2c1Hbf2HCn/a0PfxUjI3qSq37JQFeVH/KmldNlkuhs+ACR0dI1Odk4d3a2Q/pwB68bcAlt8vE34OiiA/vLXAufMtYhKHj0eV6wMAcikoOfpTmbc7/PF0HzwJ/RfLNUpIHD4O/XnrM2diA+aanE/wOyljC3S2Vpr6vzsEYNph/6XHOvT8UbZDzRlotNxoXciu/JX818jXzOjVIV5ItGygzdATzBGfZp+Wme7/oCuAJzJHLeSJHvgY1W+98NxHC3kEyx6jLRO3AYo1fcTRzsi+gPoFfLXMr7kw903kR936GMljM9svO3o5qXdtmIsKf04of5ENpdpYXk7U/zS1wya7LEjaQiauu2NklFWlAR7RBH6WUCT93S/k++mY7X/ii34NGxmL99zc5ee3cuv7zRbFuNGnPsKWHV41Y1YvyuE2z6ANo/5myMFcZrvxROgitVn3sUcV2pnBb3Pm9Wo+frIGuSJJt/od4GQjGMvc4+xSSwi2thD4j5v4cGqpsgjAUYekFSHGRKQDQ5nNeOMOhqw6vnXfIJbqr91p04RwuQ4tgN4trhr2MIWMdKEvoqsLqQXJfXRWQi9FY80nYDZhGPxbKNuIBrhaDUah1UXwnPBGVLPLUyvHx0tootbjcmtpiIQRN8Dz2aIocg/CgrdfiHghKXO1cmtlR58s6G+io6+Ylocc9sowiYkcQftpuINzCPxd47rNAqUnpRIpKdY0F/9MkyvHFE6K539+J+AU0mm+/zC3CBeFB2F1l3RVYpnzRrwIytr13Ox1Gjsh54j7uda68CosXy+YIDcFBT4wj/G+CiFA+B8T+NaVzgueBo960COck7CdeAgoOZZHw1Tl5V2QI17o8MFCYKZogwr3vkbB7vIsrupaqZKJLcj3ZKLndGGLhbGYxSpIoxMhFBxQUuin3d5w9uS5yNkuHmmvF84ukGe3oF19kw09kae5bu5AuV6jahcg0hkT6MlGa2sXOXAa+n7L9VDUvnhEU8EzOcEmkbe3/CRVR/1T1jfF7ndc7bip1vkII3l8ZvtN6wCgeGTDbAcgf3uEn0ia/woorl2/9EzszoAw6v3bmLxueUyAIJ4dhbOGzzka7vDk3wSjlsm1w+UIG7yWmFN539IA4nVol5SFOG+HbK/4QI3OIyDV7lOvzUlMbaTn1z2D0STur1TesTL6iJbTwU4WqLgjh9kOLiQCCvXoU0cg3UTlhogcU948xCi7KOon2DFH/eKbcq78Him7Lvht73OEaxTKJftJIMXzsSv5937MNdattPcdTZvlQbLzvBEBiun4OkXF3JqNm1M/EtejEvkVl9/fWl9uY/wd6j6atoYnv3kk9bNL4yu6WzbYb43cROmZQ3BjlU37/Ob9si+uzwqfnT98Jfg2uPgEk8trxmLekZpc0Qan4D586W1b2LJZpKb3b+5N1kw+eAub4BIuGsJhm/twRfo+GPR4F9UED70Y7y8tDtlNx1ns4bz0+IozQ9Iwv3W/1DEP62pohE7Hdka6EUqHtv0Xn+gCDyHYo9Lnf9yXmqymYbNtdyTxIlW7trNEYPUc4feig9EnfqQjIbOeMCQ8nD8znHpRSZ1kt5KI8ft789VTR5/KM55et0uMDxw6J/uMmnjgj6ji2czP5MZWTIWPy2a3HpYN3npQ9jPkbo9xTFeHY8yCf+lYocM6EP++1OSKvfUT6s6t2SoPEv/ex9CtMOtVhJVidiO7Dd6+/80vgRkLHbaB+E1aabbMyG4AtjoqJ6XHodGayxAHg2ftf+Fnbu0jR4CKJdeOZ7i37/BKPUsZzNOTQCtW/nBG4n5//x1CYSudDZ3QIQDWX6Vev7VQPXX/Y0VGdpBlhLNkLvNzubEVY8TcMFBDmyHNEkK+9z8txsRK/SGbMMmgTIwZcwizGfewhJ4EilRE96DZs6o2HbvEuK7EpGE40VPagI2VLDnPui8uyQdk3ltlb/A4z+o6rwx5kbfyk/IITAqsp1Ns1K9OK0AX0cVp+h1znjWZVZ5Q0D/HYjNAxFjFnm9RCa5bW/3RuUQJwFhU3QGtaK6LkZc6IdTALXUl+RTDDlmey9l4gVCgPxwIXeFeLl5WLooYc0tlrqOrJs/s6Cqqaq1Ne+IeohFyeVrywvqaqqvPkBd1Kzel4Ox9XSNltqYQH4uOp3I81gQ1EpK8lMcVqkmwC243PFObCJm1vdR8RECi28qQF3trUFaN2NIOcUJHk7RpFNtQo8FTF0E1F8+8GeitgCPoMpC3rsXO2IooiehI6ncvp63BqcVH9nThJ1bNHHMWJhkeTWUPl2fB4zHRVICXx1ZBYq4pTBOkKVvb8+TptBUlpr0z6e6vFCZuJVZkhuSwQDHjjzW7h7TYSnY1JWik3r5eThgZJg7eyzm0/U/P+NcYnbVhuNVuMwbM23NzqJut809EzOLrFPbiF3FtYYf/7zgTkXG4+D32wLzDMn7ksaqnYO+nfJFBtNO04tuybR/XVARpFJoxos+Dm4pzWhOd/K3BOfUnXhlqZO+BriOVm51WT5hNb9obnVauPNksYiSOTMTh93TyHzGi87yjs5YrOnOD5iEfX27ewQNTdJZs9avOP5DD0o1CS7ZSq/OCcxoYaDlmKOfNHDnwirmRFeeoDCE29CgocvCS/WyDj2sjtHTD402F1kdq4ShpSOdlnV6YCo2WENIbL+EUJjHgLc5yoKiXDJ0sV2hHSdIQQOwwS9TvLknEArHVGol/5Neat8mgi3R5XtEHsnFEUeBbyr020UHvbZ3YPFEMlcIWSISoUM0NpB7nQGzvyFJIGI8tFBIVKiJFqyODvjKGeZ5IkKtJQiGbJwz/+y10h5jIFhfg1dnyLidMokUTwa1sTGVLNSIMjJkWlB2AolNbwzKI0WMqLMWOVk6XaJJMxmW3Z1qouIg02ZHnZpMTLNO6CcA1ba+w36Fc2RQ00g1pR4StNrcVXn2nC0/7bkj4JdhZD0leb81TgGed+cBJtkqt4H1uHu3Vdr4Vt2/ek4Obv4W9+WTrBclVy7tCvmCLKIFtG/J/Q9p6UXSFRVe7vcSxuTBy54sv98N2/vcIluYs0dY6Sh21CXlfDop+C9Z9uD5ICJZ3wieRBG17SIWJURTb/oe393md4Gixd4q+UXO/v9xYEJqfaIUhKBRQTmhO12E/lmg/aj/KrSIjZNJofEL0MwpMzelXtN6ISmNk5h1I04R055RoKyQCFDS4VBKHjS1KT6WoadlRbGSzSEkSRL5VM3F+TLhHMi+IsS+/Fd1WNcPXK9ojOMx2FVh0S7xhHIBk6vHnUoPkvkOjA3ry4k2qHCYcevCj0uEdUFY+EXiDw/Eg9POMMBcFod59qG40JsxntaULK6mvedsBceBQRyTrKPAger1s1Ehqysnrsb1Ir7/nqGGWQeNq+l2QZk/GJiTQx7F57UFUCeqWaH3/Y288SA/yaXgWizda0m3DRZpCgcV/vGuMZgRcACRU8cYavYTIDKecZC6au3GFgR8KjZ7UZSqfbnFDd4Zp0tprQKjuXMYx+JePles+Ig3v+B2ue9JqRNgfkVRuQGVkjmdzyxWQ/uGXcfbITEdPWtmi7D/HFItSinHjyoVyAGbV3UI9k+ZIKRRgD89//7GXFgqMlqJyZMf/ktNG07fXkX3cgEpMGkdwm0k+DVEH5hUahT6VxB89accqJ2xZ+UJDwro3aZBmy1HAnz+0Gb07czxGDUJHpsDMWz8HGyFHzrkOyAkvxgAuyPvaB5eDfjHLEfq05+SMF1xNF/CZty9YsKA8xef6h3KyGnzvirS/k1VFiq850PvaNxgNL2BpASu/QWNSid14ARdy5NwQADu4z3WOiLj6/LM+yAvzSfn5ZNvHZRALslN8gYqkcaTg7chUWhRZW1OxhdkMcz0SD1swnic/kvQyBmmKI1XrYlDxOM4M5B+1NGbbQZZPQ0rKOB1N4r/8wvy9YWwMChoX2iFDxoSBfiJv0gCzHg6qZksWNZioFMg0guPVGACCT96jOb2Opsf+ir3+xIR3aUpxWuqkb+zffrzBQ4DBoJCYwFZc9YSHBCNB99CuyrifHp+P6SZM0jwZ0V3F4SQ7NfikC01ztXfmDQ0gPo3a1IiJJPlYiEFfTocUobpFvWttIZwg9fJkIi8CdZ/eqEEoYK7dqwHOnQzTFxxZdiH5za+FRp6W9JAxCIr8exdgmQidGYTSmj3pM59YlUfQN3Q+zXvVadHowHHpRCn17Mwm+shOibQ/AH4WAvGZvqu+0Cn4ScsD0i2D/47Cfb8BxKF7Iy3wesYHADIRyu4pPqb7ETRN0FRUdyJJ8MIsvGlVQkGOBn/6yB4r04Iy8fwL5akjJ89CbOn70sXQPVF16oiJo6LGR9liC3Vqn1+3bWaJVHnsG7eCYco1XhN1VNPMWm93MJqypkLR6SxASGQ2zTqOd0zVZHB4PRC3W0+iESRroXn7invflDSb2BOpbNTq3eouSIMWM1Fq3qH16Pc/PiqYphlTSCkNgJYn4g8GOQhqr4nLQupp9yPAE2fK+IS3ITgFQVw66Th437UnxDOkJKftPaL5awdlSZIZRZDGyUgGpKzmRjFSjH5W1uzZs/Ox3QStYNb4LYJSq3ijHWVb5XGgvdSATiqBZ5ZFdOXNrfi4dJnX09V7NMJcKW2BeBTkEmj9C61ojuYWaPlj1aBlkyGjdK1joDfqf4BKdySiVtrntj6I2R1UgA4sJL2yVWyBv0SfBGWBj1FAlJefytn6W0RXYc35UaxcFNx/vMwdsraJVNpXhE3yLL2A/mjR6MDQDwzsQDfAjASiNAeeqILm2fv2HTvUHUc+PAOS887cFZoTGAmHHzg4OFRtpQYybYoPDnqJVcWZJuM6F2E/g3T9NdBcccfViz4d0Mlk/UwWsexwiZCy4AvAdA+HaHaTzb8/FoOw5upi/mFa+MAiEJxK3r3PqQxHKYlEYZU11Xy+Nn5kpH1ER123ASaiWwNjGfrp9rIbXU4ChMJy+muBRZTAt80fHb/UBLi+J5Bont4vjZdPqghNpSrKIMQK06SVzCsgzSnMtZXdxLi3Yp+r+NNqmlsrsqRSvRXBAQhS0otvizZiZ2QlHL8yjp6jeb5IJAp5luZ6la14lTcfJUfdAyBCBJMIs9xKUbY+YZ9JNbKCBQtemXYm/o8Y4PrnaFRY+HgpdFb+RqRqzpY4PGLcuB1Q7u/CWRFSrwc6aZFGGqWb+I+1b9xZMKkoyegTrVgw9GT97UgaJbuZqXNg4FdQjSlrfmIz1/WDYDRahKbKC0iE941+DGRTGXc0KLbbryEyC+b/OLEPpz+jMOym6HagvCHxUz9yaWGUyGH9gdWxUjHZa1P5JSeOmKYonLwmXMamnhCYDneBVsXcJDKOmxDn73tVikF7Vc3+iSHeWFLGZlp8uF43N7QKppkB9iW0GKXhoz7oZydxYdo1+ni90B5lH9TxIblKTHf3SwIltOjW8Gm3TNFAgqkkEKTmnZ1AHx8OCi/N60fjQc98RrgeMiEwLhWmAb8bGLIUlr0HOUnT6fVj/Me7jMG3KXQyWydAvPkiiG585EbTmJTvCXlTsDcs/aKvlTkMSGk/MZnEnqqval3uskoy5STj4yTbbFF8hgsnPDKnK8CgJdtcWqQXVOugiNyJIv47Gx9g0pGtrdbXAcIfN3nY3MLvxfrdYymyONsJKg+ytROAXtcLgXPsI+kdYL5ottiZ4fXy4Xki+bBpHCL3++CN2v/Z2/aP3OL54c+kTnmCDrLaIDzhfInDcOD0EY++yoxKdf8TkseFk5T0WXopCM58MzrAfGGtsaFnL7N+tZ2HLtke5kQRJF3xI/T7wdn20fROy3KnT1h/TyX/F0vSP2CWk9BPxOcYzGgP3u4ADMgWil8T6mt0qOUNnkFzKs1NUIRzRwyi709HrxqOpOPimTv8Az9cTrZEpie0UV6SHx0vQBzP9N+hW43ef/t4WRmtO8Ahu+37KVcDM7V0VnlpZyEiu5ER/kG7nIvEAEA5p+HJRo99BXX2AzuRXmp7hXZfICQ3z16p9QoaVu3zKqi3B5ydv66Rf/JHw3Wds/QgTsIIZf3msY7/wtal3FaRKav/G3PecZK8Vr4arfU/keG/M2gbk+yqVBHxCk2HG3sT7kUuGunPBtBauyMaD/HDCfH1AY8/U4wIbQvbDBDACthOTZHNGm3SCfEM0SHLnknuqgJ17mFOVKoi09eAOzmA5EefZJudb0qBs/patKVLvU5SZ7J3oIj/5tzYCf8tY75btojTAcs75Z04Ua8oR83PcpzpKzv2lLlsU/KZgC58tXrZAjBgBbPlOfrnHMH02KTasyJeOds+PbkKzDr5SW2+zV2nXv+2eXIeAvGPv9nVrPXaVnSBG8GB95SwzumxYq4L2TZ/hbPOvJOZF3H+UVJ2Rct1WnfS/QRcwlrY2Agmo1yUP4MJCd1Al5FRzRPdLItzzygudo4cvQTYKPvbHzXML57sqteVmILSpksb58Cd4HMp0bIqdvJl4NRvSCeafa0FpY0WP9gB9MIeAdz75rwdv7tkRml8Pb0PriPgJhHrhBr+0jJsSh89e6MZfdNcPQWY4+C4w7yn6f+nBuudhv9b+auBKBDYMihTtMHlCFPaLaxKltMuy3OhMz+UEz6gbC7YcfzHdcXNS3uH5cPbdz8Q0hFDhfnjn4viX6/p8t/E6Fc4flaCPVtQdvv0UeFzKh7uCuq9e6NU+l7v7PjtkYbWvb5LCMBYDajyUPfBVunw4e6nNntHn1VXw0dN6lumGu4VVRWbloHStpdhox86NzQHwBGwcJu2MlwB6BR/N19re+te32xpjHGKvC4AXpwTfg0Gec2zdAf2PD6m1A29jG58XgiUAalPDNLvYZL4j8pQ00wL68b0UtcurXni3vzoxI2KD6o2FWWN4IpFVkBx7WqnBfsDuJXScDGzRqvX12iZ4APwKUlE5FSHhyqmcnnc3J/Ntu612uxY24JLbP14rko5nVtT15Cvlk3lFiMJLqyZib3W5omDMdbpRdqrBQE8Wklw+ZBQX80L4r/rzLYLqFLjHCBv5EYLhXx7dqLYta7586WyQ+VfWe0BUDIo0ljnfbJLP6PMGO/2nH4rbpXRZzz7pg35ZpuDQQv+OWMhYuHVs20ZrNhLdB6FKtnk2QvlaRKSPjNHww7FzYYBfvpLz5q6qLAu8Bp/Du5pQwvOnaHDgJSkawOnN/rVlmk1vtPbjhYQwYFkNwdPdvq1p/YnNlATGugJvQkJ9TQH3TZTmu6E+HqN4gkd2F2fWG44X4MFzEmmPA8YxtcAHs5VeGBb0IX08rXw2Lc97+ROmpMQw5qCfntXLOeqQliYve06PM5+P22h0Ox8Uf+HiTWM2e88Pvd9lWuCsA2fNUBwI4WgxePruKzeRscJStLbR7n2DnxOPb2soeRccXQ9BZ/fkT8Ij8OvpGrLxBLa65fblNE9WkPv9bbfL+e8vOUmjbLg1KbASyEvSJS99sf3Q9sW/0GXB3zFVE3EIfGgqaBDXuKqubTvuM9mTcXsdH5dQnd5RgeP8boPaM3GTnT+vihR1ST2WN5Tu/m20ubiFdDBXpn/hxUee8kl9LlZdUdHEIM+JQ/MAXbPklv/7bz4Lk8K6K7/5ovRe3dHWe1jgM/E+eJWla2dEtPq0bzG1O7NIGycrNM/9/Nb9ZnlM/5JUR/9fePYGcPZzZ/8Uo36/NYdeaPialZsmJqJt+tSK6dj7GOAH9Lzjz3dr71GuCTvqatEnJNk0Uc3ALdnBj9DZDjdZsn+DsIzkp/L0+2Wb/lKm3vXg62Gh3Z3S8dfPi/PFcTWSXLKGyZbS5H4+lyMbpOWFUZ+RUG4qYkNgDFrNbTR8V+KLI2Y75N8LJwMzmqsmFCv2nVSpnB5jPVa+8UoLKcwz8W7/WiYVB6PN+OjR9cAY1XKkSEZY2VvTBz87Uu/7Stm3Lo0vMcOGFFwvRAwu/pdpxHo+uToZpkyIGOswvVvtxkgW8mrYkAt6Ee3GQ724kfFqkl28ZfsafYXw6Z/w1ABGHzClgq8z1J+Iqoebm3fvEcbv/Xkc8fmQdHo3rOsgZSmRkQZnJpS0kQrK4PTNPbcaQFnlgs6agQ5DQebykwwrf55xoq8g6A5+1lqTc1QXf6M/c74IjYOq+ew2KUsPNrM4+99MsNbBvgu/BzYUoUKrRemryMgmQbzY/XBj1XTtOCMBhdYj85SrPTKbY2lsoWzXycQ8yy91tFNCR++LK18lGmewtr+1MkkOeJqzNY+bWB/K/oK1DK+9u8sgY8o4+Y8QDzfdOPfKYRsU8L2i5ffybZ2KQ1lukvsqJP3RY/WkrcGptXQhGzcxKL0Cl9zqZwNMlkA1gcHD2FaFe5FrvoYYSEuSuKZmWIulbNAJhPA+uiAAPPYKkyrpYp46Ikl6eVFNvcit6gYUT4uCiRJHSshu0rSrGpnPQxR0ZVmzKTZyZprYlKVBh64d2mMYE0RQKJd3aoDm9NJQFW01uzoL4BVbF9ECyFkGjTJlmEbrZu0oD2gVID0fvKOgv/YsAUVq68egDatak7mVlTrIqErxZyV7a+M4YH7lsYqbCgiSFCAhp/E6ydoFeZRtJbKnYuovk6rKrmiuaseDa9uyzLVVRXZw7Zg8ip29bi5tR/mcfU1BExrm9NLvj6jazsyzHW1hbbQ/yD4gjL8C4ZDEPsXM73ygFsslqN2UEoJvyXcd8yEoDp0ZfwpPKbV971gMdhKYByGq3F66A18O7VlXNDyRCrGIYjzLzOdLjqvAs3ARFTGATiHZ7S3pEeJX1BKFevdFOh6HZ5MxOMiGaMtO3zsbq1qTjf2o/+lPzyjGTQ1DjPpUaeDa6nLVtyhBhYbFBnO6Frj1sCMCltcaWjpnM3jQPdF/kMMdfuo7OU4bfytYGKyy2Tp3wqjNEJbWlsRMGpTSSu9pfiFo5+EyWRJ0B+22ExRStFkBQJBFSUKy5GQMS0Z8EjmnOEmGI7RgPZIjftSAK+gMCbjOhHMJngpueUy4r8eSmGU5jKYJ+M39otR8FprkJMcpTMAUq0QBK+c4wop4DuhUQv1SfV/wxxDjyIQY2GtK9ygwFF9HtwIznFmF+126o6W5NKU4GwHyRG5NTFcE1+l1qbmScfW/0Be0IIezQ76O3Ml0KmKoh/aUFh2S6HXZvpO0V7HJrf8QMX2KUcxIZ8YzFNCEiulucXClhptk7/eIuDrjMzGXH2fIeS706M2dijMPr8abGwq5NeVpLrRNAZU/ah87I6ajBBoDCK/ut4x195qD6Ug8sGpOLKMVD8s3eqROgjaNi7YV/au0WkYeHpQjdLqHvHa0O35SsdsosLEkYlECeXJubyEgphFrHuFtKzZmjI4lZA+c9a4i+Z0YFCwM1RDVBL+E/QL2AsMkNKAwvo2oEJtvTNtHIq7zyXUUUsRjY0XQ8xhkoBcNXVhe2T6wZ9yEh0sjqtcbjbs+X7Y9agKj+G9tuSMipZnD+2r/hu/mRn3mWauv79faKjiMz9+hU4kz9G58HS+6SEPlXRXPPxXDtOSUsX6mOg7di7HKM3F9j5KsWqqtiSL0mv+zn3PMmiaTxfS9XT4Z92w3t5RSk9V+hgm6rZy2SvV7L1lFfDRmAUn2H9FlUNE+4XC6oHppbvcz9fob6lCUvJMc80i7Z/gnGq1W9d5Wzstzmjs6DcwxBWvInh1QO6GFmgM1NJkzi1K66fho5xoqR6EAb+sjr4Sz8pQhiX2Bn1yTq3bApj9+Sewbeqf8PVHVgeoAQSQGopCy4Y8MIEkCNOJnxDt76ctj7QMpwJXTfj/Kzxo/99O9dzat7L2COKTPBj4NKpdz+Fx3IQKLi+ijahf+PAPr0Cr9w20vS3bl5S4jWTVIKNXi0DscNZYAXi3g9ezv/292KbJgO1TPTFBG3c/3MKpI4E/O3nbIiEB/0u5/fI3BTnm7D/FRMceRnXEqr6VWHIReCmtRUcOWfo1LICxu/M/IMH9NCP3lXMY1jS045G0J/VfmdtfKigVuyWaX1okiwoT0WWh5wUvqKl7b+omofGBOVEPzSpSMqbCO7fqbRo72Vr/c/mEdEKroKFpeBrfEpDX7DrMR8FT0JSH5XfRktqu8zZdW+U2rmkrw/v/m+JIHQxoCr/aTgZubOl3PVbhwrq9yQjhQU1TanEx4usIShMKsxcYg4bMl5HhdtSooHtuk/fh34nUhm9JC7uP+q6uRoj5+WIEPiCLlRiLqI4jBZmhV7M19dgi0qUv5ZIR+RtGTSBeMn9IWER0YDohOQbToC5RNMhw54Vt9XCNcp9awYuPDZNxe+0XvJHselgxHPa6MvA1X+hLRMBrNr+XFcGv5yoOJbp+DG6TbHkeXt4k3vJQqGtTosX5bR9pa6sFkjwSSFcDU+6ygC62RDdfwk3iG8qZMxoXBVSt3a90kf7WSrlyzD2rs6JgC1wmxcfQzIwpmr/t/BN7QMiMSar1obIi5m43XpG+vUhLVaLaic2e6nbdsxpT/v1gcn9gOYu5ucc8qTCSpEkpjq2HEkxRQzR8ZDtGbS4iq8y55NTEmoZjXjYq79/7r73/PHoIHGY11VTUpK9kujUZqob0r7XcyuhKhAMaTr5BbCMgSNxl5XyHIsi339hM11GbUTd46st/2WpYIYdwGX86d76z6EMHvIkCysLjmP6S8IEChj8GBfRVMgAETZ9TYDxF5n5+cMRAGLebvC56RfCHSZJ155h+G7qa9UAvWp4zpT7mcVUv11aqmokVx2RLlKE69WUM/40UDNX2qZ7H1vTrd6QRqW8dn5YiufvnrzGv0wq6TCeCZ7C2/HOmRpZryc6N2kZmS8rc93YvNCpjRA6QNExBwigTVDJ0Uq1ZaM8i4b8ndF/H3GVEV4WHRC9QTpaRvxONYcRDpdGYiCw1O1kJpaSBfX2LbwvDfbz2EvbnZQhO+PEEjYB/5XQody0H5cW+ZDJW03WtPbINVRyWE4w2xWWylYTvRRJEke4Jvo0xo74Uf1r6uvt5nTeCPYqG9JYhO9au9dwcLdscyPlQa5JNxfSbiu/LbPlIfo7yc+kEnAbNzyRJfpW5PqXtatkl4AOxRfNbBqjEl3REdyXKIAqwJXlr5n8V9QLVk0dYjcb1iiq1YC8/6JLOcSlIvNqM7rxM3nyD9aYeX48mmkewXj99LUBUylTNtoJzZbS8Syq14fK511zk4g8ZLEla0ZFLBpdUqqxLkiUMui3ykoEq9+KEh/FSKr3QGGfdIfPQHxOGhxN+QAenrTD682wDfsuavBjE8+Kx5WdJFf1+K1p7bpOV7VMXaO3K3Mg0ozY/vjKe32Ek7wGMwx2EkRovNDnFR70kMAhihIAHgUT2+wlx9R+W/2CmxmvMPlKyYIW3qSMUo5+MKoB4dQ+Tp5H3eQJzJA6U5M6W5dxi0sWgxClbYkin3bxpT58TOpG5/AlGe/1nxZ5pTjOGopVxLOEsZjBkWFu/zbi9tA3KAK1RzTlc3mhfOk0AqlWn5SGz5cl1CXA9SHQE+vRejvNIi8WHqujTacHiqcYCKR5fn57wdOC9vLaBmEud79lhuTUNk/KhCQMWnq2ReyZF7N2Eq7g8Le7FDGHTaFoMpkjhHNZvVasr4NjI5A/HeMYazIcarIcbQzv69sypmORD1+243zwi5h7/oDH8+RspoYMIV/P3FMX3ONL4gfnEcgDY0Kb7bYZ3sq8Xr0lT3qjYmJPfJHWZUY3d//Df8JAFQNFlCARMj2KDDNoEakgmmWuakq0c/NP/8/pUkW1bugJZMLpPQwcSOuy0blOh144gNpDoNa+zDmOopUtvxF8YHNpxM2Eumds5GT+Y0TrvsUJjpYFuYwJTJu64mJE7Kx8cv8+O09QluXa+SIo6PNhXSi1eS48opmqoWvldoQcfhHbNKfQWQbwgUOjql2IaLNG2eqbvqZ3HnakLqWPHlNSC50EqwZFcqDy77gpeAxUX10NUELOpLKAkSoazUGV6yECcmbiGzb50zZi4alivJyykcbLHNY2UdGkKwEN8Oc8FYDRhDdHF6uZYQVSWNSbTJzqIlMMjg3aiUrMa9Ai9r9ZMaaLafUZlUgS3qFf3f136EamN0wALPHILE1O943xbaiP/zQJE0djhuuRjR3/HkLcJzts9HJ7t8NzplpbI7ZP527oit/c5QyHP03QxI0UzLy0uPd86fTxNn05zufVYLfSJITukuwLDpM+BZ7SVLvehVeBhYtqByzQ93vVOBxqD//w+DotAs92PTKWHXHxPOSVvtj1IQRNsm5zkbAjbCUKBHm8IQXmC8K+MyoNrlfQQEQ5fvSd3AlpAWGJY1DTSjOPs7kFRoZpUdsrv2tJNQOOyrLqH2d7SyhhRQfP5JeFbS5/NO98v+/vFTNQWggayC1uGm7zdsw6VwFz5prLSri4EDFafYIWIXWOaa457CqDdY0tVlhQeMhX9ZtAqntc4RC1qb20vdx5ImbAmi3RsJldBgW/ovnj/TdPqoD7gQ2i8wtAfvjosSbISDn5nZCS7CC8BQotAdMXusmOKmPcCuFBhIrHpLVllj6EvpnBgoozWgUKRyGVIGhOle9LLcWUUFIIeNIYGElkLw21aqVFxMhaNISFgaDLa2aiQn9PTF/4PdAiS/+lb7oif0pWxO1EQE+a9hG+uqU4PDFcZ6ubrnWXdJC9Ox9Qn1U/BpkK0fIK0QiFNrORFumphbG8ajFaPf9BqxDzM5WRk0gDvL0n+v5d+9/djPSs98CfbVZvdRZvG3QsPnSypz6GSI03YH9cu+4GZooo3JtVnoF0++4+cfSKvuz756vzhJW/aGiFRkYuPGeMkGQVZeqpvBKsNAfMHs9x5uLB4XhxXB+QpXfehmJZ9cuvTr/hQ7rEnYHz+pbJqWcxfV3YVrKCKktzNIddUB2D5ngxnavx0sZ09gG88jrLzINMl6O9RkczP2kighFHZQd/SZN80Vz4oerQpNso7LzrpXZTyyefab5E/Cv3SxaTE1pce0Brd+MpGvG6rCYHdFntSejb/VD/tgDkEGDZxLJXH7N+pMxr+oMsia9XrVN5LkW6OFg/yg0T+fx7/SOX9I8qtttWT/H4C/ysdbMCPfbmXJ9r5N1nJZG70nYsGm4eqhWjaiK2u7ASFnoBafmEVURA+e8E+CqALRJTxuHC2YUc4J8M7QnjhtHx2lBBVyBVFk5KH4lDkJy6bni8sVQ2KSEAkAKJs8VqTp+t31x5oCU+T/H+/ouT2DWvowbvByAN/n5+SzQt3Hm/syYEe183p2r+C8wENIgYPh6eypQ35AN6/SWl6cFn1OAWDINcXlpOiZfU//P9h+Qw0fcxaPmTgTNi2cgia32sh5GpjZSE4UsQDokZyinm0pB3JxLz9Tw9MOcGtYf8wc6d4nY/2ljGi5UfStH4YFCgvlu2KSK/0zNWEUc2jo7BjHGnWpZ17S4tJUWJUOROOgECAsFQWG6Whk7fQif4So9vhHE4ON0WFR2J1MEV8/sxfIgWnjbft8HFurpMaj1VWxOFZrUjivdXOdw+qRaYfkB8J3+Nm67endQAhImnIVoRnmxOa3GHh3nab7eWV9RZWLh+Iz8Cu0zNRfiBkq/7tMYKbwyzGmZ2qTdHRq3187qnpKnY4okrgXh4wCXbXufeFHQxeaVljo8BeYTFmF4+HBOjmXnM8ixfs4u7eEpzs/KJR4Ex5oB9sDBqHYsH87onMBv5to4Jlo6hQ1AGaXADQokg+gaLLN4U+uSoyqJcc1nr9ss3avW1qIaFku8dBPb7SRnZbqNizcaNWn+rAgmcXncn/hNf9cEbQqdw2Lg/s466YYvFojqcNqtzx7bGpDt+CvqN8Tlp6PLxix2jbYEWCo28K0nc/s3q6pC++q9Zo80HFjxHjwyeMH1v0ZmxG9e09M2fKK/Kxk3xXn3mUpDTjP9xl0HKqLjTrFKPjV/mpDmW3kYEJU/SBSB9ddzssFZ6AJ79z50EyDP0e1Kmsjx6es3UE8K25gTB2uQ0kDjWrlrinE86/EFhwjLpiGXDkdkXPzYsz6qkegPXa8Wr6JGCawQmJjx0YLlkQcc9ZFlbVI9HWdpGUO6b0OJrJP7/VqPzNWiiG1AQtzB4AFTZPnBG6mbA3D/ZuV792D7n737qf0xCYMcv8Y9GJosYCVJFQ7SS3tSoRZYiE1VVxrN9L9/w3nxzs0HmR057VicfYU7dWzZ4bFe9XXmBPOyC8T2OoBD+qSKPxeAwGh7P9wYuysRcvG7LDJ4DZk0cpHy39YcUWcb9L5T/p+oqHefdXKCzIWnXH/HCZ/IOv/oZG/NvLx9QDjerm6I/lY4CsoNnjyG+E3vvrtROfSh/1Mxbi4kv02so3quqKWlciHB3U9dobx/PwD46F3taRxqao/EBsDGr4+fzoDMbzCTJu5NbRoFL5wVzal0nVlYVna7ItTjfsuDqXI3FbSccjGzNqPizu0w3fLUyJ11wDnjFId+gt1sm64SevGN9mov50tfybn5eAVjxcK2NjnjMdnCrLsY1WFo/WhIlsPDMOj55lxQ/vsDqaf/VXl3srh7y3z42tV/VGdJ95ckJuuqo0V/l3QlYvHGIbjVRWHS2SVfUGOa/m+MYh2lr1xRNvnciszszSeyZvIXVCN8GWvtytneW8QBeJKQV+iz6tOZjsmXu39u75+/vBmMlh72OeM+4qBZHOk1wEvk+aDaoqV2prbMKTcW6NTj3ArdBSIVTlczA+pT5dwxUUo+BSovfGCCx+vpRv0qvmuW7l7f0es7GzP78v/e8lHss3YA2wOvZhze4qyQ5aeYhx8bxBUJLRMXa0N5f5mqJw9j36C65su7We+UsLlriwWMH8unvQ7jGhPDPR9SmzOd3taLElsVBIgSgjpWFFzFw9XptYFFHOZmSkj6rKc07Iqzos6AwK5Equ/InTJMVImHhuoxLOzMUQ8ZzCjLVQAbAgEVmjczu/KQKyPzo0jYxQxkhDi2n5kThdAkRsAtKz0ofkmrTj/DqMIw8ghjNaEp+wdw0Vcs3jJfF4AwMRfnOOIUn3Vm6dNk2Abn/92vuZLW5/B8HP4n+EtzvRi1MRwJ2WydtGor3vwaaPtVhI7MaUtJmAHfFz6Z5CpTy+OSl9JYt9o0j5Vxr3L6S2HLYLk/HkdXFxMzTE7WN1cjED6m+Ni1/Nh/dwaB3S7WJc5HBrAw9zyjxOSS/6eUaAr3ItttdgwT70I6/Xle11bd/Qe/08I3TwRb6MHbKTxMNOE2D/ZcIjowDD1hNduuuYhFWFo+pP3QIctVOPbkWd2gu8PV1QjUj/hwan8QsotiVfzOmYXU57i5LxWzrebDvxdBPuOLIYsWYd0bNJmPICaFP0g9k82m2APgbM5i6f607PP17FGF7//p+I+0vhgaMlorBAy1j2Kl6WMMd9QoY0Eb34AMDl71i65lDF6QXMbVgKxhqXvQyLJp3DiWi3YLvqqA2Ydbp/ZLnwUmi/76k9O2uTygNwKBe6oFev8G0f1YhXt3LcuKtra38TgLCpwTEkahjtcnZzRzkgxOrqAFzskgTAQU8AItu2Qb9yzv3AUzgPgO+uiHXTqxUOyLaq6gb/YF71e0B9NucFdOEjc5qL4Nn+dYgemg90Z2oKJgSM8lQg4nAEYkjjQ8NLrnPpnNxt2PBMFb0KydLXeKdNSBrEiDFVwRq6mKNmVKIJgEvrn7MgfQEbkQ+9Php0J4OPsUl8+g0LJ9co0Opg1BoJ2SJzYRVg0S1uge5lfZk13aGAplgyGZPaxvRrSpmE8ZKYC5Gykbug8gLQHD83oCq0PNMynPIgCqW641IkluwtddPoHD6ejZGNYkR1iS8fR6Xw8SVwFCDEIn0E5pFajAoBUf4fwqiCLkxuphg18jHWgGKm3kWCAnkCa6xSkb4oZ3xWDeg9WI1lKsIX6YxfvHEb6GgIFFJFQgp20TateFLCYOg8ktSdhlGJdtEiRlJMLolxEMRvdGmAW+oFah9vZn2sB5u53B+sG4obhGEpicctFPWHnQyOrDWxINlhoBtTW3zH3Ly2/wNsjgSX9ZqPdIUelMJJ7hRKtl7BTLfFYSsiUCXng4erU09c5CRueQdwpHerUqhwaQKZFk83ymCUxISfFiqPp7inB2qMFEqO93YZpYpJyOuhs/5Tnp1nJ1KqJrMHBf6T+9vAVnEkcOsoVWlZFGAk38X8gTzu0SZV7lwKIlzijKeznOaVuF7kSTITCRMK7FjK9xvHEQuXAiimQEPUJSNZSsR5JFBGW/Gwdu/iqeJoCvLlH0zwYy1QWlR5LUmZQmpQ76ZPI4NZIJaubv/UYnFSN6pdxhABz0IlBOVJakr7vamkaK0MBPdB07MZZUWlJxPaNDfMUc0IOAjo4f3ynH4PypRTjJVfBVF9HAteP9IiCqdMxnkzVfb4VU12Vg9HE3sKPOprE1CESXGT8TwNoVHvnBGSwFPlCX2ytfkR8LCwuEBb8AVGfSQ8/TvRbNLigS6fKtc6cIPDAg4Ge4ytMXv5N8eqHe7sXZcx4cXwE4C3ZHsidxqMyfduNCfw3T0E6yCZ23Ko+NmaZ+ag7lW/jBKZmV246rOhe5a02CgTl8gVGsCZwdj6g+Uwr4j3PqiIBReiNnzmtoOa8itiOvXUaUVdXDJwTGTrcOSyOz0KBJ+VMrxKnBvs1Q4G6ImYeycei10zdrQa3qPIs0rEiGQs2YBlcXL8LIoCMSaPnQPPlx3pzs1+y2ZD9QQ695+9rjKU21+NikriucXgSfIueNJ5cxuV7fgj/yCKRxhRDeXxs62KCF+dgJrIRqY4vP84j7PKxl6mdJi3fOeYAlcW73XbFO/KWaJ1TVVP0MSt79qmH17LFKxxm8dj4WcCRrsrUXwsmBnrncU3GCxN4z5V9/TqaKrIg/wOjs7y/KWBBFQuOi6ZDIWoME6K6DKIOaU0Au+M+MvlkkpRjEESqWCWKYN+UMeUfuto9r4UKZ8WdEHxHC/7QJ5KXaOUAH885Q8TFPEti2uZgrVoS2Cvd1Mhcf+pEZEpKq2jVAEwGH4MGOXUqqUqbCpn17LNKJhPjD6yGFYty5IqCTW9xRdH+1A1Mq6DgXyJqLSzZm5Gboy1YK0+xjTW+y6Ghno4EvASdEnudISBNzqqiXT7KaoKGptscT6gZ+OkAKIPE8Q6ooNxLn5JEhkRy8oX41FrzbPLTZIKCFPS7sKyJDTlF9DLLWynAUsohbP8sPzv9KNHrYX6/QPdhowUDQwZERjNhxtSc7lRfiAlUxjkwlczZ2uC3U75sNkTge5ZdhU2Clgj+E3XBh8dBYoOCfY3ykF6Ugssyy+BQuCB94gh1lhuUzGLa8Mz/VJVGFlSEcUMZbBIWlApdSh8u7aBm2fEqYXxHmY0otA3SKVENZvc4isBz5zxZ1XLSZSYBPzJoi0xElZ73l8pN51+fTDdGeQZPB8UnL/GLzfTm8TPM9xpidxFVzSHSeR5uighq686/ryV3LNq9HJmH3EP3c8MQtbo9nRpKsT5lAjtI0qHGCwnnMDPlzORJBhSul4iJJ0U8S/hj34wMzEKqQJYsQ7X8PE33AuadY7Jir0aPOBjjwVLwrG4KitvRreO7hRlU27I+P5z+RKYm0WOFRcx8QBOKkMDuudC6fYMxH8URT2V16N8JzTIcmywjBDi56wg5/4gAeYBg7++MDFZMvea8hKiCDwMgZVRqqMUOXWcXi2aulceTlu/U6+H5LOQYE6Uyj+Xm6Cjssg4HlAn986LbTPhrBA1vlX2Rni/CxDzK3v3/WMR/N4GmB/6b8WSE8c2et6Vl7B5DYLKVUZa8OgqB1oc2y2JEJqyKd0abF8w8KsJmGfnCQ2Avh4XBR9jOxDhmzZhHEa8cqqlxtJzJcJjNc+16EIfCCNYFoAJnhBNFcxYEPY2DTRY9kWjHJW46Qus4LFdTiBSQCOFY7EUwgtD+pi4/V2hLfH1wllJsF/XgW5PrHk77GleZbujNEPn1RyLtrVpdi5VbZPEgYSE7/ckCq7k1wpE7GoztgWq9NRGBuGMlRpiesBb202fRNRsuVZjJ2wNtamnzGDPbj7XYR4n5+YgEbGBSK6J4ub3a/OLEzfrvL3O7c2tqgT4TX4OSGcPdax5WSRi+5cusmbblYgesy0dLTdEiovOvRx3M57NL+1qGlXL1HIpxQiq1F2tMRdRxtumY1mWtKayO2TegFt/2M3QYnBCmQOfoN087Cftq7n2sTM3qzj9ARCNVYrCS0lheh2LUhF9udqgbomUqijWIieRt+UlwMTgKLlP4wsfbGZutSJjm1Pp3plsuVH2vbchmUD3YNBIoX0mw6KVJoroONIVz/CgC7O88IGpSUp8di2dzHx0Dq1AteyJzXA8FAuVpLQLyIWFmIy/alwD7e5bOIuLZ7mTqVlGdQetJii5ykAxJoe/UnnWXOWgitoYJz/XGmYXeZVOHfut8IA8P7P7fqaLU5py30FTjVkWCHaZmBEwx6QXn95+lsRG6YAWAtGuPGqRBwSuDxQRGojk6ihObjTkt0K7V3n1ZWTTbd/G8lHbkkj7lKJ4dymfE/nQGZcKKr06pRdUQChUUtRpCI7CUwxne0brpVJe7I4QDylcfKddQul7AYGOqpBw+bmjfsbQWXgpGgqLXEsJx+sKSVEx6HguQZ4RpyuaV1l3s3GTuUidJNCfz4bXlhOWmhIXtFc5uDS7lV2vRTNUJdKiEw0KWsIQtJYh37S8KgTUuCgqgcTkJLJwqV5WOk8hBHYiKRki3xLh9mTGeiQ1yw6BqwLrtlgaozlSe7xAn2vSgtM66VYLHo620rLohvObGHDGk8DW0fD64EOwhLNWFDvc5UgsEX1OGIXO3i+Fo8QguzC+8X5RLqplXcQV15xGnQ0ZL/JsMHdYjEU4wkCF2w28Lj198QWNTixZAIglaBlsFjYCmKhg0GqHgh4ZN0HmZLuXyevYOWJ6AjXSn8PABwH1wemU/CiVWTBif14VCvC789v1tyCd0Regpy48ZUO9EJUmZ2DS2NzRinNBYZkef0EM5IrYrxDP8dhVz2dUoSpOW5dFi+s+jYT1ePn4nRCaOf5/uYkbyAOZa5d70FMXFuWqPosG5bj+d9Toy3MT2ZyLseFJ5bHvYZ7KYLe742PgRpj3CH9nCvu4pWaUU2NhmGIHd3VoHOvoRQHCHJnM99ofrlK4qX+lSbpnGv57h24m9wc1zV+ulZP2nqz/F1EttfN9tTN7NYweqmQReC8668lgUSyTeF3kj+PkIefuH2QIIHbXOOCBWKGMRDSDSEOnEOw7whBL68FkIrAT9+OwzS5RMSakaA1cXltKN1wYv7ww0ZCRSJaDh9EDonqKKVksdozGlwLhsMWi+jS6M6UXNmwHOuxw4mfYVQAy4m1JNyUKTYafvISM+FUavkgMMWM4Cdt9IzkeStioWQxxtIDqcTkGRco6KkxbYWv8klMdhK48r1IvA7wMbLHJ9N6ren1OC6UwC4abuN1bH36YO0ZnfF4Jlup124MNtM5zl1BB3Qk9MjkaBKxKojiTx7yOAEM7P2DfBmtm/jFInLxjVp6kEnQfOCVNRfminSMHYOz1rciKOfRudHjUanMTtiyEg21bBKUxL6wfe7/67Y6shhOz7VWVdHXYciCpJo1iSbLYwV4/I6WSfLeaKtLXuCi5yKA//vM9uV+KENs+h3yFqLIvCYqwjXXVKQzztLDZSSRiABP5nevqDPQFRYaHy84xrcf2D8wtKZDqOBwO7Zg74wd3jJLVBHECMqTUqDZxONktgZsO5WJJfi/XaaPJPJwWlo25tVginJvrbHSotGvQfjP6K3RacvWOhJhsaFF6CgNbmnpxCeHKP9obkd1am744nV0QpqoSLKIeqX7vJevc0kNkaekhaVJdbjPLU/v84SXkK4ICVplmDnnE2SbpQykxORF4lQiRW9QbsIF6UBLiXUXAfZARivOR2TTwxzdLW7svxBxNbvxarL3AFe1sCSZbE8uVtPymYuHBDCkaCYxe/9XFISIwBY5gx+mDMnFRg+TANEVkEFOTIAsrEta4B2yXuBQTWrQGiomPOwkUSNEN1qpPZVfnERdkIVpyVW7PZKXhy7amfd+mYt9nACBYaOz2TbpH88dHtO/eR3+V1rIqKbzhVKVkOa4dYvRH4Nh+H9zmTJWsmKtnUepllhNEq05YKQBUIVaUKlGyPSrcXWpOn/ilUbXHv3SGGpy57VpzJkENEvHKeQuD8QGp8pB+wivXycafOWePXOK3OC2W7/rj6AfnO1zmgY8FVxMNfKg8mM7NoVilOB6U9F7kVWmISHoq7JArn2yhK9gbKwTadx4bqs6AV8VVw0zAOCcieH1s3Plm793A/3a1ymD7FiM/AfB2fCVx6T//76vh6kMFHOcLCS3cLb8Y+i96Hi369/AbvjfReen9nSa7rMmIsDyyxGs3SsFJGucqQprSiPYwUF5V8Tkgf18IpgJfdMk4rmhPQhIsJBv9OZGI5A+NW0XtppC2RJXqt4jc05ydOPNplV+ZxwpjOyhN17r6uqSSwvl2rMLoqc7bnYoBywi/+2JZTxdp4WVpIxg6ejGLDqRHEvKjCFXx4Q3kPfbNkmNqgwNYHFHQebN0jH90nE6HUeY0t9b6uiOa6e8gkTrkLo2EwuoOKvY7ekozRUpl5mRTt+bvJ7Hyf29FG+0pavFW1EAG18bfFomtGdjCtRXu6vYIBfRO8QxMdddkju/4esWwfc3JRqnbhUZTqQly/bpfyN+3xkSt8eObmrOsF8ggLhkb3vaAwCVzBFVq4/5Xv8eZuJGzoaQ7mYWJF60f6tPOGTkArGS7X5XDfsbOc3h5nX9v0gpMtIZE7qEh4UlY++xjywKsG2S2golWSm7r/L/y0XnsrXDtZfFoEr9kMS1r41TIMtda8RDmPVLViT1j9sgSVZV/qrbYc/6ev56rForoDZm0hRh7bn+wjJOvwJHB3MtVDz0PkdPsv/Y6I36RHIbDY4QsIqDi98UQ/BK1VXywVrm4qNe3dF9YF8eTbCN57+v7CghjMf/k9s4F1dJ3NP23ymH27Cb1bf5h+7Q+UcuPDFMklwMaD+eDFEULdR4hGUvtqnh5sv91CZv9MB1F9CxxHAKuAaWXurbQvQrurSlZTLfFQQ2ZzNa0SfghoO/e5n3gWlgt851nWiPXwwjFPxXYwv2BpiYJzIyuFJxdIgNW5PXunfbr4C3IPSAx5w+2euiEo5N9It5ZlkRnpDC73EMxYUHGgpVb1RdLtwcsNe/91LKbIRen7K/S7Gy1ydyHLE+hRaYqRMEu4j+OvhKHuU64iHbrlBsu90EWwY32BIeVkxeAta0XOsyk7SnIslk/8ZWdARtx+OLDzyt1f7t2Z4tNxmVaf6fjOzjcbihm0+UapMMGaxMLQCN3Q6FublFvsvsRl0z2fw+I4/OWx9mDm74zm7DrznTEcirpayREuAiJYgOlju/c/FLgwHL5zEUg4RARqyFpXX/cRhkeAa0lSg8WfrvCc/8sY0hdrxcPZUvj15NYtIR2/qc0sy8EGZx9IAhDiv13xNU3DaV1HvCtz/DYDea3rq9eds51Zqyn5e4pv60tqngdURKPzK9uxW1gRD6r5fMv54bPOxU5M9czw1zV3DRRxV9hfGhIRQSBUJ3EmQbU4DeeSteZJIqgZedynQK7AnxoWJRAiwrFvJ/HLa2gFzSbQ+TAVITf9+n07UOpOO1HJBLPYhdH7Btw83HZ6Xz0Ca+IOq6p3X8bK5bVzWAxWXa34Xt7g+cufwSEd5BPvtgSgIHRDKAUQcBHeYuhGEx6RA4H+NtASocbfzYWUUPShTconm+evZZF3xAMCAJyB9BeEuqFVqmENUokIVCyELUrSqRH74dLiGFQSYkwFwt39br4J0g6i5kquIX0XRv+U8TYEXcjViwrb9f3gKkpuvrByabWuqR9qdHwdDxAw8GjItDJLL2VfCDn5X6JfUs9DiLOWJ9orF1ZGJJw08UmbCkyyG3C9pK3JoMRCIowIb1gKlbGuVgntB9kGh5v8tsrDohwkJaIO+e2vsX/Gb0/RNHYGxgVmRNv/+GRsNeHZo74OeVeVg7mYYn6Ztyqd8Bb7MG4iA9wuPer4D6edUP3WtGHTxRSuuA0Dn8/eRj0XuKq/+wUdldBlHc7wSjqj+VYCecb31/0UoY/NWyZ2QBvmBt83VL/6cMJ1APZKovu8qFTA+HuPUQI1Wa7DWHAsWd34P6z+AiAvXKMaU5ziSB4kncOXJT2wfbWtsmq/T1vG9viuGpz8zlWq71Xu53DQSnmH1tTRR4klDi4XOcLqP0xtbVYTgHNWMAz+Vvdx7psFcpHXE8AQfAt+PBfFQBEsg3/f2hAyEQPigfVVxer1CipWhKeqlZpaUoCA+Ch0R1IYwfryObwf0n23wNdwUd5c64M8vkszqi3E32H6kIDQ1PJ73gzdlqXegXNamgKL6CcFGLzXDqIDZOzxTNecrEFlQ9z9+VpGKkyLyIxOnXFN6pIrfMLQUYQH8bR/BT0C2NAL6xmXcyKtnizYs6stFt+lLp/OK2MunU478Nm330ArTfcF+GdgDuReQ1c92bk7QXQAdgHb/yxbBW3m+kDtrsiaNBNw2fOUTGGtrKoUC9JNi08kj+4VEIdAoDHs2H6+FyK2vWKgIvrPtX63nPJ9odcL7z39XgS5OH35GdugMeCUyqe5FZkh8hqZ7JXOMqzsyqdbA4627jMDh8yNZCMYVEerSTHF+9E+dY+ieKAYnO84iIZ4eBAjM9VTwUzwBzFbk/IAoUQ3T4NKCOLLNst5Zb0ifyXwMgn7LxAfuAT20iQLPrzNy/e7J3kNW8mokWe6pu6rstvUBRTWJthHGVy+U3zfXSw6Plx4tccL4F5934b5NHGbHMiPxq9iT2v++XLZ8Ek9bRKSHtW2+JIXdjd5EPAMbb4e3i4uUV0jIFKS7ZEDo4JYALrNRJubgZaHCyFhCDK0RcR3kcaaZbW3XeOroJXQnguMN88XJIYKowuVlYV8JJA+r84fCzSgRiImAIB8Iwb8LNZDyifvbHALeOcw94hhBfMvcJZcV80Nmk5Lfy/zr9e/wuEyYaAAD6Xy2cPBKR/BRye8TuVx+M8hREfrGbODOl9YAhJtcGSQtphhnmfzLMDuqgMEFBY2267zMCgNhOw+SIDNgM50BMf2HC82Ipz6odq1YuN5BxU3ylF5CRsgLX0d+q/k28d9fLb52KJ8IjGzRp2Tjh67uKErRKoE9Ec9Jz19YWWdQe7xGIDUPCV+WAX4K2IHfhwYOnLW4ef5D0X37g4ITosfO7/Ez13EYfiK+ElcV92FymLWkP9FUt013oj//9W8aLt6nGY7ysovI50PPBT8d+rEFJX2i3hY8Q9HAr6zx1FiQF4/55Pz8R2jPQKhQSeN8vc0IkDeCrkQ5iUmuhpeBqb/nG358R2T1D4LMkBZkzwO1xGogA1j69wNtNAViMjfdhqrIJgQSomXQMVAVUE1frpNlVNBN2UmYGTwo1EnCD6b4mnwhbFpgJyoloPqYNYMEfFovZOPlde8jDhn7nv1HNDlToRD6NJKlJk5UEzw5qjZFkltcDLIGzjgpuZvc2U7T3HSynq3fNbHdYfzjhkuZ4sSU5HyBfIw7LiBQgzUPuMj+3Bii79mBLYs0MuGsCwWt/wPfI4li/tRvzVNOy2HJB1dEWPxutcnDm/Shpizt+WF1NtsCFsoUXRNSkkfZwqCBPRXKs+DCotXS/+DPfP7X9L2o0L/uDA1YpTvbM4CoP8e2db+BwJX9hRrlksrtUV0T2Sng2G4XmpsTJ0ttGPzHxowETt3b7e2RRDCI2NpBzg7pb7A+iJcIlIk5GNs30Qa6C3scWeBK0FbDDgeN64LOJuhH+kXwYvTRb3zWYtHEAf8Ee9aL61LOj/jZm4BC1/wzI15HZlDSxD/YpCIwswUeeC1fBknJcWthyAhnCooOpiisAQygxCIlyFB/+0lwk46ZAqeAfBmIdUrpR7GSkRu0ba5UC+VWTugd2z1sBCTGITNiwJMTuqvq1rSaht7lIXRlCNORl+5Vav7sf5UHJBbY+TCImjS/677ugzAf3eOFe7vRcVsKLNI37iHO6QLfatpHDz/Gv5WD9hYyLpsmJZ1Mi4LWs01qaKQmJx//+jCpxFEiO9Mj1s8M7Z6X3exXrYnZ9KVkFBoe/iQECnmM+++iM+dFms9YDY0MQHTtdkKbf3FUSEwxV9Wzwct4gS3YIhxv9iXQthn7PwV0VQ+t6IuwdkIhbQIoyCFDpG9o9Q5WGS1CT4gh9ZRSsgEDikOtIX8usd8vgvESFg/jkYBLbAFZy788CBahRUAof+2lifmhgqFs3WEULZTXVBlRnkdpZmaeI3WehQjmf9zCgTG6Lq7Z+Kky/xFSSojEuTvcnZPSmsmmiUXB6OEiXrfJgggX/lOAjspCZg5fHKwz8uxdydd/bkpNWJbTmH5H8TQjxdczNKcARPM/jDIoCmBQSi05RhO9ixrBS40NPbLd1ll3sgnMUO5MBCfM/u/x3wK8qZC1ZfcblL2bRIaJbrHoiRyXHLw3DnWSwmPXe4JovbfnNSuVhlaeWXxG22lfBY95cBbwSQtNH/6pDyv/0KJtZ424ruK2Z/bCWS6GcOT2QenpC8FkT5jb1j4uR/Xz8g/en5T3LUQXSwSJ6D86IwUmGpftwgkrKQRkhTVJFzWBExGl+aB58rDKnLZNSldcG7geZBBhuwHePapZmYnQcdQRqru6vTST18baBCA4sLyV4fdPq7Frn7GsDHhXcPbrIHcpu7a9n/HwdYPrh/GOPkWuZrPn/L0EujIpGvy645X4cXr/3X8Tf/Wbio9+l7KnvYRut8QMD+FRw47C94gXKWHM3sIJfY3v9DiyDmv4DW961B3eqapu8BrhMZdMd+fPjeQRAmJr76/Vltm5+94Hh4wNDns7dhrgxmRRQCC718mGb4ev5ywLZeKltlza6Abmza0um6WwglEpnMXnIVhkE+aB+InhltGQaJvsOfDaO/yb/HxQSBS6DA6MHzQHfFiescxZes1L5H+L6i/MDcdbz3XCYhBzxgm68s+D3yPTgLXkOugXSCGbOxvRy7zdy26TnOxHFrzKjBc2gcgLKFepmdsy0Du61b58Hh/VIufCJw68Tp3qadbuj1/+xAO99azj94q+flZgspGTKNA/C4p+GhK9utpjnGO8pLUytb2uWQjTa3fvcHOuoYbW3n4hbXqklSMYVOZdQMM/QM/bVBTyVVcTtYhkz08sNIOjPa0nLReoDP7fIo+I3ASdOk9lGspDpdxUr78V6ugpG7f18Kzbr9XN4kFzXtmG/juvmMqwHS1HnM/fxqXhgd0O5e2XxE7Io41RO7JbWpM7+Ff6qSX+Lk+0YBqz6GDN3dOagDIBBU8jFtxVPJRCT4KjcCuGO0tkG5EI89Btn6GEqvXMN0oqN3Qbp2ADhFJIJ2gsFEIGjPvYWVKXK8wv347j5aJ2iLsteOgETg1cEuwyuq6kVxpVW/erjM4Sq34miZ2PNS+aUkFw6Q9ESUmaIo8A1RMJMQGYtK/q+RxHodYmQxdep0PgJQ8BAXkM/yfs5LRfjiQkN+556iy90TRFS9AiiAZyFrIj/hgd2ogo1bKAKoLUJwAb9NYLCtHJt+edRCbmmiJj+zPmuO+E/ZgIqbbQufzKPma6hd6oL+i/KEKkr2NiXOA+be5YniCOktcO6VzrDTAwwCmSIKyRZxNhWZwjT4PCFFctN99UJodF7wclYWQlLshnBHbNr7rlCyEeCHfw0VF1Q2FIFRKjaUJCSFuglI7z8/M1YkFc+TR4aathKR+YikjnPNWQ8L+Yw07yfgS4/eILrj2+/UXxvhotaWjLD75OltVeiTHgtfL/b6z8Iw27XR3vvDTzJycvF40sUn7mDUi8PPqPSCepBXUSN+2UPx3F/qwm9KEPhNykDU0vcf19HsY5I645CTQ48f1IECkX5ZZaPLYsUaolPcCXsrt2IBJCn2U1xdQVi4g7GMaVcP4/EfHdwzwUEePXDKgV9EvOwv4ET9DBe+isC9zqcGScuSY1h0dQRcCysm0oVhYJ4ottiEA3U10qaUJW3RP34ZkU+lRYYh1NAiDI3Gj3SWTtvOZzz9/FwNl7jZYkdCcRfZyTKSE1jELP6iJnItq5qcg/nmUlg4+OjHhdB0HCIiNk0MydaX0dYyLA523Y5KOkOeKo5Qtktt3T34xk8s7nz9bH3UcgInZTS1JDbfpm2e6CWpbNukJPCg/RbFwWx+rMkX4bg9zXb/TEP5IAgHBOkGq20rB6admTUVA1iQmy58oM6+tO/z4ZLINlgMijkryhf8Iy1pKxXVAzgBtFgNQ7GZzCVOcx6SYbXkWM/MDY2q8e0bhJPbrziUAIRZOWP5byJ2sT53MKX9FtxkKmtLm9cd7C7iRpzJaKayHhhqLvU33ZdAILwflIv7z33/NaJ3c3eXh4R5PakQzfzWAu1mdnMBdWpnwlHE4rnchMm2hKOZ4r5GWO8CXqDv935OzKtzNYtRiFQPyxhnxgXs38yjwOYNOrGLatgTSB7j8nyywC57Mj/vBLaWPOezt5/FEzAK/3rttnC4p+N8nP7F1IVmFDPiYqYyh6DTtjRHLMTaHFXmBSBacli4IPeCb2pzc3jJGhVO8cft7U8iYIyppNZoo4HclnTQwkiaimk1GkPIlIzWvLJ9ucwWxd0Yuw7gIK7obQO/ZAWCH5ctIOhM8QJBFnXeK0sI80mQgZ9MS6vvlcnoVoOhlTSZxPCeaI25LE7xJx0dTyNgjMlOHGMwkhxO5dB15PPtuEkPre48uaPDW+i05HMd2Gl3pz1Lam+Hz+zCkr22bS/QNpU31CX0gxdF1IwaM70kKS8wA2Xg+OjIOAFGj9uP02dhyDgYjmPIOJATVMSgmzNqjCLworq/AY6E2HWboSd0p7IQNJ6PSZ4MW779kqQiiR4DsKghyUYj3ZwOB/ysFjPNBropHak0pVPMyWZxzs9ygFmHak42StAAi5lsToJgty+XJcO9TTSeAHHKWQa0mlhQQqfHAhsS5MXruSP1CGRedekN7hMP0poq6hvjR4rXs7jABjOzNLEgKAGN5maLOTs5gWI1kIvec6Htw87HnY9bfHsQzfcTmy75e8xsCPZfPXmaTCQ6whUivPbs6dTL8V2LokcwLg5u0QZG5QTkOQJBZcujrPgoM5SeQgZVVagh9CTvKQmeLdaNZqUkbXER6F/cBwYh7lYJRYugcLs9BrqrLk5cgnvR3bzNEARHJYfxIgrz6yo8KtiBrbhfzGzREr1m7ckDH2igEPLdgYuDdzAfTWp/UbDDbmH+GOKqkr6WEJyVWFDiUTqUl+CLXw5FmINc2+YfuKyuPfKWaxUu8ECtpoqOPeI1PfufdAk+sW93kFTEEO6yvV0wDYRCZQ4Ca9PiFD28ZmTCz13XHChqUAioOAF5Uy+HEEOaxJbyEYyh36nktei7bBmsge9uQk73npCuxHAa3Z9Jt6HTw221M+mjds5MBoYylduFcW4XeCvJiOYxVBLubknaUIJN9mFkGU29v13gVklK6UZsb7ldIag5u/TaZP7c7Xm9TeIbpvT4rNXKUHXdGh2D6VbygHbD+xnqPSVue47w4XatdYPsOjbT7PH0qcl1Sq0jaABzHD04z/RLej/KC+q1O1Uh8toRXg3Yzqx23fYswdyeUPbPpfza+TJjwPbmggZJNs79l1fHTmrKY8qweoyOZhW3FFBr0nEoshNf1LWW7OJn5akMws0XVxcq7wfm0SyEkjBiKUJxWPp2aFcxFdcoLhFzwPGU8E9zfPzsfvxA5P86Pl6TV8UnZ2wlQJghXg6XObBRzTvmewYSb8kaIb4rRsI8RU5cYFzdKeNF9cSzjlz/Sb+PIoXtUbWd8UQsGyFYtiqE90Zu9Acf+uKLuUkuztRS+5F7LDScDMCF55706lsXNRpVEgNqcAiXpQITJc4eXs/0CA87xGBlwGBgPPU+WIHRs66sfxur15JG6YzgBDc5l3qWwcc8F35kude6tDjal5zP6qghnm00iPyydpPlkata+0aneMxXEYej9nVDaJj7zXlNkaUzx9KOh6hjMvyR8+8w2CQmW+X2mTwHUYn71v+I5tWl4ttCWKZ57/PU1Y0/SyBNLqWOBi3HDTpqEGcbtcmezC7KpyT6QTCq+pYnbtLxM2LumpYesWpq6/HVq0bRimrgQlIPPqZBKZHmFgmSHf4QGtgd4gExDiJNTdDLlSAlZXWmU6TwKqB7ect9OSMOtC01L1MUSjU6YMEPRGALXsEEkbWHc0xV2cebrMATxfa14goU3o7qQAb/KrjotCMv0YkMjO5/7ESZ9PjBIHz7UhmC5wFMgk85UycW3XhZrNLoWWP7sc5CJMqWCCbCPpFfhVCoCKE4KBCk8gHgNY8DJXO+5619mubXkSo1ZZmCiLhV9sqXHqjf/4lP2jatMDWok+VrZBov25FHGYoRF0x453cJiXPPpgPWUsu6CvkCiSeZ0ej4Q0UUQ8vU+ajFf2i7ZuKEgTRDkZGEZQphTComVN36uUjs2l81QeaigWKRDw2DiT7LK6+94lk6YH2/wFnpsgpEXvos3oLbP5lRBdldQicZkuDu6dwn5eIDO323xyiyItBhqSakDGwMzoiuYNYTP65rvxeGbdsMQsxbfloeeKZZoNul2tFuwVsRhEOgb7vwCaknMhrHXHSy6+f14NtOcqvmSPrvBBgm6OKm5AUudJu8D/8ESRyOeGB+l1LgnjoNjHeRewrh1d6vdGP+bt4NyQiEMLYqpnPVGLZkS3dlXdpmvmE13Q7PIN+yW+YdsHRNlzETInAVOiavfm1fO2L7dZsZ5lhgC+3LBtJDR2yKwd7ibIC+gVqq9T6PqimYTzcW5R1p/mmT/bp77T7uXPyBoRu4uQy/MneDY/LiB+6UGfcfPcUZb1kvDMkqDWJKlJiOsCHhYtcS80HpcA6Fds8fuBaR9eiCTsEBTJg0Kl/kbZLjg02iOYkktEsOpb0VoTygssokl94zYEw2JM9uV7e8p9jcwSmCJek8dLnKd01PiMJ6+Hg45rqfSv2tifLIudJDZGWyxyjflIdc3QV1aXPiBoNAcpo4rqjFV5Q4v5PqMYwguIatPllyfsylBxTU/6bOvKyiYSFi6+qzTvs3kvAnMsG8N7y4aY4ony+g6zyX9V8V1x6xsWh2DV4cTvqxNSwKw86R0cS+jU6BUTv5Cjx6IwOn2CmJ39MWdqe65kxsa6z/zE3TAgors3jdHeG1iPrSUQdiq5lUgMv65UijpjLaaoyJV+rYtNDMtRwiI9Ik+TIcGv0U6NnH+8Fd8wFF5qHW9J5y9nxbYDrPuZfgQnF0n/OWwXgN52wjSFT4hMDEf3iFHGO/uJRZ/FVxVlAM2QsEcierB9+wMPrVa3QqFjg+31DMrGDWVN1flj/r7fjt1rrI0pKreyAPmhBJ52XqRrQC8NhibMXuHQ0dx/Ib7A1J0cK6topiFvbf3JM+of9qlU8jOqESar29nql8jczbvbvuneUvRxwZlfioNLGwS0Ct9NntVNfe5Jf9uj2v4fOfeyvHExPzx3t78y8nJlZeGvX359VXFNzgt9XVH8ltsn1pqgbOQG6mvCwYj/ijbbucu/5gty7s44mNxTcfT3OzWo/eexBg9soSsjOaBdIsWexHH92zBUpBOemHx5fF9reok9vt4AyMYSo9BDoN/WrwfUpk/bdH1rZ3mqwk1k3HDx64NIr+jg8Xz8hl7toT4gJUFjoAUlUvL5MfWmFq7bgJ4IueSsjH1nElQ/V293n5dX5RY6/TPhloQsPlFkZ4yOe+tMRs86cbhSkOKizVxX7YO9aFFEAj/Tjig1Z79QTpRHfHrC7AKwCdhco6wqd70OksVlj2oAEvlSoUwtxwL/gqF1tyaXDeMpVTz2OoRyMiaowQkcIiYm0nWQG21jmJpKNjC4fjVk/FB9J/z2EDp9zVfIAHiP1Rbat3JBOkC1vwJ/VWFes8AOPK1OQ37yMPwHM/zH+vIzrE+lOWIHDN+egAppzldWM6Xl4jP48o9wQkBkkZF5/vHVg1T1G8zCxpVi0PkCKQ5iB6XZQ5B76L0xzemS3WHxzz5MIdMsHtSltXLLOv4PQL/br2fVroFgfiwUvXuhv6iLb9OsS9s2dHUMZBN9iqKCglJd163Sl1Z7U+yFFqO7306xF5QXF8HwlCPPopMK9EN+Q9NTGA5uRj4ezL9l/KKODtqHxwGVLmT1MXyfEIMsPxJGKg/KUux11uSEqMdimRVEn3z+KS6bBhwMKnwVZm22QP3dKHPfxaze/GtBhHEcWduuPSfX1018n45On+BRPLR8CntM8VAPl+9HfxX/KXNXd/+I3szB93w39MZN6f/8Gfs7/ZQds3ot54QvJk03nDqpTT4vMlNy/A/fGt3CcOgHYrXRajXR5BWIrI0Cy6G1tobHubte2WzKNfU3E4ODlE4gTuWjHPAp5+aCaT34n2kUc/k5V6X0qMrWhh9j9fRuXVma/Mw7NbKq9O91lF9ZkVd8ejp1f6tfGt3QrD2bmYnM6Zc/sUU4Mlnb5C1ZYR3vDXjYT/2ZXz4hRKtHUufx92VNLLD60F2ci6jUPeGp556ZC3BaugCE3XZZBgX1s8XPed/k2lunB/Z0E1Ns5/+XBDraTOabOrLh55LTVnFtBS8+I9rC6346edKcPqd8ajtawuBZfRNIeU1tqw/NI+O49963avjRYtlvC2HjwVN8BvSwmomtcfMDUIwsePuZ013d9Hs+8e2UGN2bW9zEAqq8cuc000dfWCOKYLsMrJQpGSf8Zn1PbrIueT0LXxOIFWfLKIu/L/9WbdyWQxbUtNcXST6PTl/jVTw5YHUwcuBsevdK0Zp+69LydV5WDn+yNCQc52fPuKcWf/78/YoZK5P78WTLUMv08aoXdCa8k73sgjh8vI0xVBB7jMJhddsnyTKNvnncIhxjgPt1n7GRhF1V2CnkZCdC2rIYsh07W76CZZEJ0EDDl9N6bQFH/Jv4xajS5Bz4f36uZBcWyr4Z375JLu8o9nUavn7PS+5JMuAwoadyZY3jGbFI6NatmvmxtXZgQnHV9/aQ2PKHTDfjv9qN9mzVyf5ayTFia1+bUEdZb6tdfISHPzKfDw7FgzkHPb8GxrP293YZlSPxtImQpQlPzCgv9WVetrOdullcjIg+NbKnmz6hvRrnhjs9QV+31W5pq+9Kx0RY/w90kSze2i9HRW3845kcZoyIlLiOIWx0f38RgUYoGVw5SKdT29oRqGuGZ/DEa8xdqO4T3Zr/BvOkVYjiBP3cR5uLjM4pZYZ/OPX+hesna79HjlwP4JT8b15Ksf+D546xmuhpGmtr9xKXEMws+xsw172eCoK6oDC6wxbbM13Ma+LzBaKHtA79aiXWbW7ef5Ngg2Tt2++nbm5GqqjtL0QVdiB+Ob1zV+m9p3bT6MCEKl3U4rSfpkuXtTPQwdt4D5hVUqPaJ6kPdrq8x1RngxZqd203ZbxhOpw8dIKAQVs4r+ll6hWtEu4Wmv7/05O/hzOuvlZ7JY2qcQdiZ9c9iHR2GPHGHZUx5t3wg5+tR+Q2mAR73EOfJmOQ755uE762SJI1TqaNLrAh0rDNJWeCH2B6KzDaY99pe6JvkzreYkBlzw2OJwrcO+vYLyJ2+L4XHJF/AW9ds4Ol7fXKjQydMUm3GQbssW474stf+52AIvRydfY3yc/bikAc2fFZ41GNb0KxDZgiTvhkcbcZS4snN7Y2w0iWnkrRyChVtYx2596bo1YCROiIajRt5anzBtwwnEe8tZa7G26TiR+MTTxGvgJl1enZYFazCxhpIphsFkUxy0gSWKIy3LfiY3jNVLM9jeQK7VG8qL0wvTvNR+kEXRLDEzhu2mtsVOu/OZsCg+vPY8kgJgIqXxiK3ecD3DvqAvw3LM765acKEeLdrw1lY5OpYBIehTqsZg2aJEBMYHJfc7kHK7TWavwhqO5VemMOtTSdF1qYK4jGo9zE90ham89HM5x+5CfdmMfUXZGZjTATtlqUZcQZQt2ha9cz5KkOGrJyGRentWayYtPaHNQktssggcQMaKtf65ha7BiqStqQUhm5V1Sw463TrGXg/d1E4hLBpcGaESTDMkD5gkSSMGm5nfg1sq4vnyfYcC7SKF6M3cIhnoVvJt86fYtqLb5trwlSjAXXahKaW+htebtppRBX8AI055lZ+uj66UndAtYSz1BcfXJCDDHXKxJherNebiUmNrlajYWp3YGL4YT5MDTw2v/R1h4UHI1yw6szcKlcbxjIpUdBuTF08byT6mzUoxawtEWKCsMo4emVaiuJYPrTcBqd7H8eTAJUtRfQGnO4US05doiIU2cnTF+9yqNUed4I28Lv7V7BUx1MhUq4GcU5VLG0jkhXQIOC2BVFFcfHgmJvYAKyKPa0H+QooWLCWAG0qZfYkUS39ySSzIYWwboePF3dTgOqlEkdu4LOTqx4/JreXDO15EECpaPrl9LqufwiTR+gabuohmOTld1ltv8/F6R2HddxCnQg6vSEcpgDYZrAUK3DqUl71iLEEKZqccpXTzfHZpkdfr1SX/QpLKzHyk/D7aNanfYqpBUItl+Gt66M1c65swwrR7ZdkpQm079EpWIexuaeWCW7FwIOWyNG2EJag5x3QO2zzQZaeaI/sidVVFnPjaYmpRbL+ZGt9t0tQUMq1Vhfj8yN5zDoKv1W/HwebTnfzdySa5fWUlys41rnuOLwCbvxp3+AtLqmz8/r2iEUPCyDEV89Vmt8IpjSWi5oJG4xsv8XG6mXMxzQKOJjmJIaGnKbBsKN+RTVggbI+D8rGcAIQkMYn2lqVCcz35jgzsAna7BcrHcQNQ4uo5rmFmWTHNCX2MR02kh8noxN6Wk5Wq6t6/zw6+Ll4Zj3zLW71mPnU14WIqL/5YfGenvyyNgyRyQRp9gnBEJUhlv0MS6SwD5CDTLN1FojkZ5373SOs+zjA/U994zNFSfgpX3Qa+ZDHln6xyHIaX3UTnfIPF08p1GGhwcHRc0JIF3Foq7s0k5ywUWipBi/nLPHJMU5SoMosuVNdlU+vySFmxzRXQuh9eFuAa6t5B5QTf9AoCf2VnQC1HYIz1wlb4L3YsuZYu50JmcMuv8GHHkfDpZT1mLmw0UV1cfKT8ZUtQRHMQJzL4saS0NHnTEL4Dm7RA2Z4wi5kBMEl8EiOSmWfFNyfMyF+G2JeZL/Eai0Yxc/rq7HOZ1R1FjAAOmigEReqJZMhmo1Mte1KW36/3WHgdMPqpWBeM5oUp6TmBiniAgWigy4M9ky1JhuBatpOtkoKFqOQQUzgyMxPhjIFXy4xa7CNcXVjQaH7YVSRu0azy46kj2ZsaNR1CKFB3M3F8cnuBULTmaK7JLu/qb/gp69tN9tvTgC9GqnSlBdlzN0SGmonmfHK3KKYx4JPM8VFcQvJX81SdxEqC0o8UYKymyvkFldx2RjvV4bdtnwYUX+E94LeDOWr9M80vqyvD+4m55Y6PX2QXaKzPTaewDPwBfnntX6Zdh0zxnYLITGTJ9+SEmXdBvadGZtwKNo/0TBl/vc93g5o/9L0y/OfcpfXMj2x8uQt/C09AxP9xSikIVR9NKWmQYnIpEcr6uoo6vVlPhaDzZCmYAmIEL6O56klB7qrjxAfjci9XKsQc/66gTIUI2f8ne+E8KyOPNEKOFyit0xkVqUgDljnJrCuQYfNkNXFsPbBcDxb5tTLYZ5VJc+goNBfCd7Kwl6naafHk+3LJqF8y6LWwkCi78NwKtQxIwlf50ritzTo1O+j/yTUpc9QjW99QJUbVbmOn4jDPOXp/ooAozaVgAJamHEpN/Ll5rxMXvEgJs+mxmgIpLpehBG3q+hCWKS10016/7qjTraPtdY8orQZ6/P3qPVEp+82LJPCRuQLix5OtsQiP07Og7oP95VqdyBiDvNNiHeisfs6urL0DxTryr/yu+lwlNAMtUs+sFInNzJWR+KLnrfA0w17veRt9IhS51bK/u8POzrG2ycyJ3x7vxvQi3CcZJrYsRJ1DppibZsCqPXVOSr8Fh7M5K3yCL2ES4OwiqSWhDXW/nLKWWZK6Fv5//5/Jc+mFaL5zUqDCEuP6slQ5uUOpGZ7x/ctPyYarTZUeUArSTyGBMMLSwrOCURmxDkXTwpbr4MdP88od3Z+9K6sr6Pj8cSq0svOrtfKcN+16VGkyIjp/QROFDpDlonBySn6IcXVwmEE/tD5CmPS6QL1w3ufDDrNZpYBasuILK9W82YyRHiyue0IwbQ3rKGCVmU9NPUXnT5XVkQ0YResCs2zAkK0qP6kDZyAClUN2tYw+l/i0vPdTWkQl3/pGlTMZZiYiuj4yqVBvaOr5gtzYefykweJmSvm1ttqe3dlLSzqPYQJxInJ7x3XSwIUOBOkOrvVKOxk3zyoqLKmLkKPgURiK4mcBAbDfdWDvtjX8l69D2/yv/2h8QkLMxsgCzQUPj3Q8HOW/UfWC86wmnDjjFkZZHRxiDKbo5CgluLpeUILirwk5GTsXONhC/45+2yWX2boxrYpX9GcJPSPnYnf4yr3/V+AAnTm0sCbKqePlfhOyRWEceVn2O4pYVT6LY6piJKsFCgOMfeIcThmew48XlEOxIESxHoSUYY08YcLsPMGF+sZpH3axulWEtTD4DD7W4hQWq81sPSQqSSJWKpoTEafCbGTFTPKbBMIf5NinoMgItAp5ZzsPGg/Clb+qSzYV0p9K2Sv9ORbcS2kC/JRoG1eU3FWmsVGR0LYCpC6aRtK1kb5LN90miAtIEoVZO2tZlkPyQ0FHzHyXq5cCIDE5iU4rq/aQZcLTOl5tk+zdCP3fhfHsatL/51lwGFOLfBy4t/vymC2SZXsrnJKeh+GURNyV3fjnp3WI5RUocP0H3xepPkDY0kNUdd4zyO/zFQpNRSIwSnggcRyR7n9Wm6Ln7b9Dm1y5oRrnmacVIqcwlCTYJP542sDPwGGiqsqinqmerhzvVnqes4Xi/8hDeO02vPPd0o8sCo9uxQSCEwpa4s+hIXyiL7rSZdMMyPyVGCl4W17pKc+b0v3cb+ZlhZjRTW+rdScX2v/FtpCj9rqnqNr4YLs4o6P6tdqL1b/YXijR7WsBDAKupdkVx2SstdIfY4zaRLMP/0UsPNBXFxY1lvucTfJOJo3L7CSuUzPkr3LEbevPWCV2LLG6v80u4bViHntXFtdYx31WNzqOS+qwgomFtoP2ZI8uJd5ioSMqmEclziGOJY5nv6OIp+X+KXVF2YIuUo0sO03kSPvlyCkbOZgnjvKezHFV3dG0NpjNcooOrWTwtMyTp7Y3Rlnqo8wp5lPBbJ6pVvPJSoRzLpyjOAkZa7WpK8uFnJjJl9497DH7a3DQeYAv50iGHr8kd8HLJM3bmjpIeZQOaFMVZDwzazFiJWeL95WsbUmsFq89RGR12Z/sTEMO4w8TzrOafuHwk2VgfThWYnnoXI6oSrr88XQiAATWnB3PM2c6gkh0XKuaUECXqDGbY4ZxMcc4vgLMWLtYh0oqzwf5x2IhkjiFMnaXNL9rjGz4eE31+QCeSDSUq+zNYtGpMCzxP6sEkVZixpvj4FwRFhuSYhZgt44axpsSmei2CtF4BjVno9BZiVnUWL/0//6eISiVk2lQ+x1Dk6WJ731k2UJ+tY4ShaqaCBpJngDNY/m91PMXAuAyW7dGsJF2b47DLTRuxanYsIGxt0Gu5qns1HmKx7N3SaxRTHq3QWHNIcQ15LNyk3vMddAzDRXLGbDcsaxcXhhbNuDrOhsAEaf91Phww+dvbTRzDZPOrxJgXGZfuyONyOlqc2GgKC0bW7uXF9DCOXJaUpw+l0Lrpx0Q+J8KOmBAybpQdAje1qq4q5+d1bI76nxfNPeNeGuaPNrmAp7dLwvYI+C5ktZXVGECDiwLQY/U7AeIo6kQrWm0mkthpqUn5htGTJRP7IodymULutZlekv8VTVajE/iigW2rwDn2gsDd3OX7bVZ3nRvyLswcAcRTkUSerJ/8mO2h3KzGeFlTAZrfNbJaUD5JJfnzzd6vDRjuZMavxsqPGTwIZnLxj1gmjuHdLQhNT0LC2fL9Yecj+/i0PsqqzR0mHZcLu+sT/Y461RO5uvJ3ePrWv24Yz4uoUZJlfSGV+zQzsYdbfPcs/c3en9U9tcM/9a4JPJZDDOOpcFggBU7KtHfG7afDYVapoVZqH+8xP9Kta9Jab+c2toIPmud0/a+svaWx5Z31glxFDmu0M5p4WY7fTFU2jXPYnhfimt792Ca9zw4OqTIfrW2oqm2vHEevGl+Bhr5zrrtFf5zcWDjlfIUqk+EZJ11u2GntYfBdIMd5OFhyX1DcqZVmZ5UGmZ3gE2GRQ2tUy6LKWMidGYee2g1RQkzWpOh79eHpU4XZcgp5a0y4E6EPgNBbewJ/sJVWtLRpKmBHOK9HdNb50aS7NQmQ267t2kR1WixPgnz4I2L0t3er+CTj9Sz/B+DpW+VanqmGRVLmm7s0kJhTU0XavNimTS+pyiybWRFKM66c7dz7PQud3tPAXQe0QaDd+w2+GyB5k2voTa7QBCHyLTlZBCwHN5Q4cvbtoA2LvbYQgvwkfvgvXWNatyOqO9J7SfxlfyOeblBcXbHJxcmGVkTGT5xzIcEXamyh3175tsuRHk2JLCx37VTkmCvNkKx/i8p9OlNU4zt/08Ds5I7BXt1Fxz2PS66dwXPesv8PevqWNpXlG37nGomypInWQ5IhpRMr2NipvChWX53LCidh/yylYyv5WkLLiuJkSo3faV2h/5RZ41YBi+3Xinmg6QhziVE4zJVajE+ABypF/CKDiIsPlDSGqy7OxfeRg9KqpIfC1wdPdOhbJkd08i2Fl635CzWV3g0eC15ycvV4kNdEvPhhR4BbrCZ8pFrBjVyp2xXOO02dEM42VT8gIlQ4bIvWEm2pruuKaeViB3LrTAq6NTFQefIuS3aF792ImXH2lLDMmE/3bPXlywoRfu5rLVVXg1dnLDq/p+ozYGHrjUgpbMdpYNzDjWYzOpiBMInw7XNcpJPtA8wdnjV9miGDkT9+e0GW1PRsXwnJWReH5Y64srNgX+vOG2SO+E9bTCY+p+zg0325Pff8dbd/rAUUeolb5SDYLXROeRbRZ5A04eet7c3mcA821cAXtPGfeQ0goe40h0ZX9WHta4dCqfdZ7PsyJSHteDkWJpITPPSjQdUiLNwEapkTKTYn8cKWD6R2ttwGnxWbuXdjPajwXYeviqSHs3Q+HBy9EqG8p0brEaalmGeD00lInIp3fSipNvAzTG1uhuhfst7GczoW+tZZcpleV9dGthwxaODEMlIrzyXrtHi1H7tnq6V4qmeEB6BFz8b0det2eFvYg2LmVVABUuOg9zYChoOO2xy2Ipq4g/hHPbUBux5RhZcgTne28kukKh7PMd7KOAf13PdS7EmWj5lcXaOX6iWSmG0LEqiNKtv+FlAo2idcmGCgZ1sWe9RBvn2xVqrYvFAs3ch9Hesj8tl+RVRoYMb1bY02+yRXkYo2dH26LTd8j4eGfG8ytMlL/JT+w3Rqa77pnLabv4x6f6LL6PMOPOjiozrG9sjvJ1VzcMctZjgpjW936qTgjtCta/q0uQuu6CRQ5X+cnkzzSZG6EZaA0A1onqQi9Pty+HA83HnT6Ey7dci5JoDPziu1j8qOGP0sT3dExfHvY/TcLdMoqtR4gOMzK7343BuNUvaIj6VsE/MMAfEv+zCxtQ6a8Yv5/RqG04+mjbqHbz4ZBWRV4XGDIiX3YjDZPByczdOrwMDd/TbO8/IxTv2OOcVJ8F1UP4KQB4STpIAdNG+NQQWySD0rjZGuHEm2CFXpjuwodjQO3SYnoXoNTvp+4tzak/QnJdH9++lwY1qhgS6T9ikJ68O0ml0/yb1vjNdUH2lFc8n7qSSFMLcAy8veFRaeJsteXljGaXMG8njuAQas6u6qBvxivaHDlW9ru9Wp65IS/MXC/Uj2YKE/kx1Qe5UoWnFSKAlrqh+3rUz++ToaNbPvRoaWFvMQF9BZpnr/4t1IAZv95IH/383sFt65EVH2M4hUHkmpdG6vSGW7+OvyPyR/ClrVnq2VL+GWpESqPAdRPGzDidHRwPAaS33vJMfMVb62XRU1pG8hnEXpWykSFmSNZ68Uef9hFx34FnWej+IPOf1Er1892TVNzcbmxrh0GwkeamXQkMAixqTPT6nhD8f2S0rbBSbwji4Jw9NPoLJUU8zk/KmC7SDmbykwWxtcd5iiXRF30d8l1h1xwHVdNupdtjtU5KR+4jDqY/+dEZpTwHP1Jovyc/sixUWTBYZhov425pPhwxZtEI1ThacgYhjg9WxW/kGao7WV7mS5doLRP/PLfvSzhsP/MhZQDMrVsxuh1CNBtnOFlBdyvKRozRXSuHKiyS11diyJhAvqQMsrAAcKfH5WdSiTC84mQgYRh9oxw0f2Kz518NhFy5CKtkCDgvCStkBySNZuqL8+eIH8nllP8xTV508YyulZG5cliDJDxYTW2nAzsv1+fNFJWNZ3MP+uy2aaMS1d1EcRsDu8foKFx3vN+nWzYa9G81x7RvYygI+pxhZkVx5wmA9b+b7V3xvWkFvv/2YmAG8wf7IkzPGCn+n6/a4Z3uGrDB3sfLUCuBCxCFSmpRohBWA/z/mrwl2jpDLtZL4dpVHcXzEKEST9mxI/KrD+oDJ5N/d2MoUdFe8JKIKYaOZA4liIuoeNjrjdE73hK9GNgJSlmZNaruSPCXX3/VGtB1FUQ57foPtCHGlZoJ+k4dBQqQVdeUQEEIMzTNVMl3USatD1W2FCdxQXpHLCRwZGBFFYKL4EIAoGgKq22d44Iackjx9jrD8aDMuQ2jE2ZcBnPffgco9f2v1u0F+eofl5Z4UiweGpQ+ndrkHPvktfvOqVTH0bSqD/P/c+QMtU6x8ShcyX12KnIvUmDuIwv5wkSRNKi2KSZQXitD5/DQkRpAUzV+KxzZUsCaSKIax5IpYdC2te2y0UtlNBWzgSaw5drWKPt2dejZXnnQ0ts1Eb9oSPpOZFh2bXYXCSSqjhMpc5TLKNVuqt/ifzCj+IZYPrtFHn93i87SgZtTlgkaSPZdfPg6Ri2uO1NCekCl3fRHNR27UIe930CnQN4t7T5ZlRZQVxvaHU6ALRrLLSqA2dzpP25/JTR7J1hXnmzs34d2qql2HstZ7TvXDHl2ExcRqEo2zanpdTj/SqXzjeBHjRO31ONzyTnH7yeK6d3xTwAWKR5dSbSmYyihbcfRxP+ogn7jV9L/3ZB0Mfk2yXhGICsbyjT1w2s6L8eCZUVtegG6d6YoYIAV/FWWZfxuB4+2Xx/4k9WlR6RXwNv4VcchrJ14k+tKdT6orb944d3C6dylPLzkhkiArlJ+OMoIpoxm8yxvHrZ9mdqnKfo3I+t0jIinsx5FPcFYSlQofIX9aX3/PCe3ntlW87SmBtZcqbG3w5rJIqS1DvBNJisNRmso5B4fDb6oW5d7WnMgRz5UdI8I1enBLMLzcHcMVxOdV4lEuJdBLwV2p1C41A9ReL93INCccTmxNoY8aNnLjE/WQsiicujQMFxxr4MECuekFThLKWed5Rticgus750W9xeruqqun+8+CxYVJ0buvqx6WpsOXyHnkxnrfxQSmZT6uLpbUzPXeGwNEA+1sTizQrtfzZ0YTb+kVFN3UG87nzWxJmYVl6jKxXXFcdWuYTgpWoTsf4R/M6c4uNU5LiC7S4PIiigjE8OSEQDBNHAnWRUAAEFBHIIgThCt4EZ93gN4eez3m3wIWeCMJgM6UxdBy152DNTS4XPYo/Mtfo1wY8LyAnVnG8f9/kpV7WmfR/CNTo4w//4/SnRN8ADPW0nxoNdthrv3U6yngUbfSrh7KrkXlx4CjZbnbvlH16Ar5ITxFin3M4/3i/Xnci5ffxd/fLc/50WGNY2Vqt7u9/1Zre/dhV3fTrbkLrV4M2syUL1EBV5uKXpi0dT+zYTQF3YQPumbVpUkbCgn2HxIlJ8Kk2lSOwP4Hbou1CL1wKa22FjS+2a84PtNIqi6mIY9pd9i5zNi0qod/5RZLI2k+q0BL696qrnretvPaEWJ+JkmyKeZyHZdrTSe3YwRu3umcC3oRsbMks1Rc1h/jHQs+qXJ0oyIDcuxALdCo4Ysjlyb28ArDEeXloFIYIp6LCq48oykPXxoD6m0+Bh1FraR7V0d76n/0i/i+C1zkEZQQ9oMPV4tFEOCeGEc0lofbEesjYPE0KHUyyp+MPknAMKOaL/5Spu9rTo5YCd92pfnOVcUlO4EwOgh4Cczd9VnUsRe8U9PAE/KTg5NwDvpyybEOcg8fHXl2BsvDTZjPjJksi7q6lC6dekc2R1vkrVDrefXHAwfuRmLh8nEIY37zJMLwyhb0mQWgiHsjMGYdEfE/vE5jdkdPyE9u9l0+i2eiPEyKoPxkCjHvS5pyBig1EjpRjEoFUxwQclpCSlIURB0JiusFS7SZLaqvLuL53GCRei0Zyx3NMeYU9wAM5FFqk1dSi0XqyKYrLOm0uFSrkprVkMprBJAW4Oetb2Yn5l4rqZsL0FWdplT0Fdyuzig+29Bw3KHM+5vZkxsQzJaOlZPACeB65gbBQYuAmyL6dIxj+JZLX/yn7OKnzYgYUPLIZQo0UuItujkZmgLhslQyHJjeAsVWhR4tlpJ3N5CF0swcaQYUog1vEP9ctk56jHPAAbiIbHMRGGRFrOSZKLubmCJTJiqcI81X+zpCY6c1vzapNv9Hl+fa3uBfhxv+qzwQKn/XOqf93dy6r68k5K3+oiTrTZdPnmdd4r2zfiriivyz4tqKPJ89FAs553H9IuroJddKFYznyLRBzUIUSSNGMqKAqgIg0hplU8QzGRWRHDX82MHUtwkm2Rnd72aA0fG1Vr4psyvxLyYdGLn3lg8+XZmZN5jJjV9NWO3tieMPZEFumdKLGIMPyAHubt4JOEnNxjRq3l0Ha+syBcX0FBgz6DUB0JQ3nhlOrwQm7n5M6Xn4pELsJ99c/vKf3tI2LlEVkxKRG4AxxOnDm/JzKpBiz6/rL/uruMamkTesoTtet34frSLjn5gAp+kuq5lxjQ9xKezgzLJ5ajcfNlCuPJjDSyTooD9t+PzCrgy9g9mAdSCk+EJuSPQ4C+0D+H/wvGdzGis21aomFloz+A58A8qBkfIKTbrajiYN2VCUmC5H+9k3cvT8jstEGi9t3V47VR44EOx9GOmp0B8e7M3WqYy7aacdnrU60xhsFksJ/NXDZ2vmdvcDKQ2dsVoHkDw6NfKXwzyeSwJejr3MQeHpArbUaaMvxsuzlnNtWdBOOh0/Xt09jWorma588dfFLeoZb+vg4DUO4XtcgijFLybghIIWjQWhiqHQvJ5SmxXfQCxISI2EaaMhQ93x2qgQ8X1TlhgN90sEyzq5SL/BTNAWjw4OV+nLpt03H7/PT+l0Mhnno53JRedPDmD5+inkAmAZ45400uiyYIt8dC2ZC7FEG8OZd2PpJvfyxOS0uC8MrTxwXJRFTFxYA15LWybmDy8e3PCWcTKXPF35eFu5UMV2+HzDxbuIsEI+1pBq0K4UZ8bqM/nwOENrOicrbSj7y3MnmtRE0rRmnsoty3mzgroRVPklunXZcmaAHUawRI6YsVEtGpWxiKg255BTEmtVI4VJBVFkdZpRM3KGHOKyIMbyPU+Zrr+b/IWhvfLtWOq43PBqTO52MwGPgMnT5HaR+bLT6U9r1IWM7wFp/+ObHm+26DzsHKY5tQr2tJB1LYPzhm1Vg9eFmmPknPp0UUMe1vFD4oUJpZSRqgxFCkvzCKPx0lm/nhNUbeBxtYRTrQVnIbqdgfxb7F5pCg2/HltdShxgfAyQnfIgo66uhv7+yvMvcEbdxIbEssuU9rCQjPakrK6aUnW73AcGlT3He5uDWTMA2JsRjKnm7RM8qgrgoFPDKCTzdntfp/fZ23oz6eIwsJrsaK6R8B7Z7HF+23dk0/JqDbHUJ4/aPk7E/Up8L5e+6Vm+IlwKkCLhl/DleIcbiknxLp1cIrVjKzlhbth6IVB18S917riYM98kzSGjsst63tBLxKGDgcbJl0FW8+83PWA9aCQfm7MXjRyTTYqlwIbQOzWYI/bmd99w/C5ver95dO/8enAtomfZ9ZvzVetVeOK2fPmGgitwMJ8io8fi0eklRoYaps9XB1Ej0qN4jHq+Ko4OYWJpDMwEKusEW5XYlijQpxkUYKDSQNcgSos0IkpwKmVgQL+g1TZCM9WYcabIcL7AdaM36zy2MpYx7gZeAT22d/6MOrMYCOHOdHle4imOhJwaXVCoEYh16Byw49Ntshy5bc2epgky3XAVC2SXP+17Q3ytWwAXxU1vMHZl9ecLxk116YV9vpO3w6zJgyEsMk2+A8tP3t+u9k6GzPvYbnaBK7+Q0oro1wUX+33UmSBHcS8/qX/yziN1cucUWd7lUJzMr4GIG+9Tg6r/QL5bepzyp8TlbQteqTIlISa79b0rfXIuTjr5fT0A0WXNVyJqZunNzeg7+UVdLWUL/YyejtLHC/d3+7EkzhWGk73bxKpS/WNLss8OD9VBA13UnJPt+IU/tSNups3zwsl78/XSYTHAcbexffhFkbdPtl9YttacqZmrmdPFvdy2Rp4IKoG6UoBPVTR7+rAX6OLq6GQ3oWK2cdB0wXm3jCi9IHHNff7vy81zczGuDxorepT8V2gOv/K+4JZ57vnMw4/Xb//hqf/91T+wUnKVa8h1uuXgIcjA5G5p0cgJHLm6u88iJofYlLMWMeRwO5k2Q/kAtKl92vBubYp1MFlzyt0OvFYK2/z9wquJ97vtIsceRheadPJ2K//867CTyO8/BYv+SG5qLS2abI5//qtbfKoW1nz93jW8h0finlcT736u3mJ3Odd34mbZlXHYs9dDEWFbvoklNfQgwTMHs+andxZThP/iVWX4dn3YgBwpPNmXr945I3mHKm27My89vdeMQMYdWlb8KaeO2/aywOv5kseRr3jTyZ0jFBHlHJ2HKyqpSBXbN6icDxEogk055K5kammGKrIqkilO5QbyCpvEIa4nvVRhsmju8wk3Y565vchUWccpGEjrpvc2xM5UNdMKC7Yw68NvNq274Docb+bDaE+ppANvxGpa0lR98XDmwcKS0ryDGYKsoWzNQK5wYzXqAEIaV5N0j1V56lYTksEIDQWuA8WH9FXzDieY273tJUfT7JmQkeC4Wh5v/mnLoY46r6em7O2z4+5D7XW7TD0eDQrA0vnvQ/fc6ro8b+cX8h4xSM98y68gjRYWel0Uz4HKyiDjPGHuaIFuJE8sLfH91RmcP62Vt/qL5Rem3sJOy5OLyvTvrPB41RoLHEmS16eTlJvjMw5pCOQ3iAz18QWxby40P8BWBrrtb/ho/xN4euF41frE9hmefzNvYfZILBbnsrzmypa0ZLeBoG1wHjAe3gAUVXW4atmmay6O6b2QLzpKYWLd19F4O8ShZ7INmzJ+e6UirthGLf+EoneW/7d3m2MlyVVoFxV0e1QKY4xrNjytqtlwya246VbR43o7vwj7kFC/64O0X/Mp73e42QW9M3Z/3L+jQFKcMZ4iBIyllLQUsPZcPpQJIryPMq+rEMxlyDq7mHq49JEklSmrYh1F18RpaW7IaRtIiMb9eNXB0csO+/jHYKObL7eOb4goPjwya5+W3/3qQvrOBT19bFusWJOhluXHZChwkswLdpPhctRMnBVnXTLP5LDRvxF0/oC5KHigIYc4kCjAEcA4D7DXgQ2DdlF4H6JrdJDRi9UVGcaJTsrCkJAEhQKCC2UJwCJVNrozjrYSE7OYAhkAEmHlxy6iHzzyNUDhieRSJQIXRqNkH5/1X1lgBXTQQqHpx1+ePHt2+PToqLoN5hlhVRFKowlabRQ8Mqzc0LAoDTFnHLjOW4Wi8846z/9Mf1x7wVWITcMzIZfcjWC8B5MyHB+j0FWHMmIl14iD4nDe/ANGzG9/3pukuEPd/7h6h8wQh/M2bhI/ikbeQV9wFfqU+XLut55//pNjofXdzDO5dyf/VCwXKgvAN+fSlm3hrhu+jZ8mTyjC9wZX8apXdzGwWSsnPh8FPwGz4z8y/h5dCOHbUq/VFnVU5sRvL6d1UGMZaS42lb4x5fMkOe8fG/+ELaESvjtahU6XnfChaHemfVTrJbeabrfbBaWUx+TaA3dUDMsebf8ZNGT+XsuRDpLX0xwOn3/ywUmJS0G60oKxBF7+SIF+sIiTQEmtXWqDtdugvgt7ACeeAzzXXuhrl8TVRz6uJO54lBpOFsBF9V2u6KYOA7joaH4d/lE18bYHSjKfDvG3txKxlbUgpOTCGnQFpiqg/YL6E5O6c6T5GeO17qxFBYri7PEUZLBtZQbhSLZ8fBCBaYPg/ogWjnWkSVI7/EF90o4p2+z0XfP+7vnfs+MvuFljIJLBHAijojw5GAg7jaaPzW8gcYCmDt4BsH+kmI6wQtkKi7HmTeZxglWLjtwRjtXXRnGkAHEoN9dhDXGzuNjZRFW0JALBNiQTW5KYTCgQOVr8F4ZQoJeA5z6XQSDAT9i60tBTBl1wgB2LDuyB2dNreRibOSZ1q7eCO5LsOLJIlSD0RtgPP5Ql3fxhWvSu8B9sv7ZStw5kxPlhPdvc9in753vcneI7aEXkpVQEpID+NBN25sytdqae1jv8exCy8h+m1PF/rnsIjaFgAlf816u8o8RD93B1OG+M6xhIC9A6boGlooUhhSRkZK56VnWQFfAj/hM61rXPTjtw9Yw5fq7RgpLx4HNfhc0Q3sf/d7kueomc+aC3nlIvoVxbVFEGnRAJoMOVmtU8Fdw4avTXrM23FUCGeSLYRIVxpUjhfT0CoSyNJWjjdUpIglqPNsQhN4KKYYqyWKI6USNFxuuiMIZYlDL1Bm+lz0gXBlPRXLH25PZDSZdRF8lbz25uVjRVYMoxJMkZ/pnNWCi/6SkmMKsjU9ID5Cb1ARXp2R3xbc13YCHtGzg+EEOZXlyKdkaWk0/3Qx9YFzseWtXUks5YcSFOsUEuRiXvpmvxI6SLi0ujXac3RssSUsU1KvO5Hxidau3B7cXAe9bKJIUlu8owON9KcgF5hK5k1Ydfb9oGVbe634JiGW9Tam67QDdqk6Y6LNa23mCJnPwb84OPcnpsZLIUlLo7cC1qT7bPglczVFPvSSD3yQ2lMC70v8o2veRaChldCaF4G3i5vhe1M58GYBNF0UCzGptlzaJ2J7NvnESvZORTBGILzQovTn+XOb8GSo8mpC2+LVEQDSj2L06p+ubPCUNv/uCfWcaMo3whWlkiVPzzhtF5pT24vSjv39rITA9wQDVuFGfmza81Wp3W3OBV976rey6+IlEWk2lWYXOsOdS+ZM6hb6J7aspIIkCQfB3PGxyAPCo3gk/Aj64PLRBnfqjaat6y85n+2pU2Ya4Occx7lCpKueWqll4uNLrcLX9nU+UmOA5x20w6++b6X427wL0zNxU3A7+lfwN+kC8+mjgEIqKZw13Bq0VyJIIbq2Jd86tpLaltFbFjPmh0989Y1O3TBYkYwjLNLTEiRYY4RFNVbzzgevKqGlIWy+ZjQ63ltNlkxblrzkDe6OlrdlFCV9Jix1LvzH/36o09zvTaZqaCX+l933TR4262xE/iK8VyXum7K1ZLnZhmikPH3SLbxuCxB7uN0c6B12x2IaKa7Ck2kflE/GO5UXyT3GZZZ7Paxqp7vspLXLHKFEPUJpZquuYz5DSuGDcaRyd/suoKn+1i0HZpVNd1Pkdo7gJ+CgBT09RNkaO0uhRFrU1qvzRzPYCQKIvJMquwudZc8XP/kLyhvJYmktiZlRkbT3ZG5jj78SNTb0GQ51SPpR2qA507sT7Gx/yB+S6y8xJrsAtpMdWctNF516VuwP1tDJR0qxq9DSq+ATdPzWv7toi27IoT3j8xuuCW+fOUoTd//C/ftdhDHYWX4RVeZUm1ubawkybGCk4PGhKc2RXlWIw6XOd6KCm9WI3nC5EiYzapO5GZPPd71ha9VcBODpOvpARmhHFWrV3vZOi9OFV16f/g3bcgzPIjHX2iwojNVsyiNxxdsyN+8H4JL8ZUm81IS2yM3lMRuGUKgEoyGe7JprpsQlp03P7H55+q+AVt1rWdP2lBQ+BAlww3PsArxX8l2dGJEWVxnUYHH3rxAorLjk7x7ee6pTliuTYgSndscGQMYuE+QqbL38ahD1Q5XdiIzbJ+Vh8GN4u7jNFzd/5TjDO3ObBT4kMaWxfuFaCBgAlzH9QsbA25xguXNJygiyko11naZxB6Pf/4wqHUwoAEI8iIhYh1YfiQRBOfm2WVJ2RYgjEqEPWurpl/r+yCKW+2ghcKhjbR6iNqdj28vqmG9w6Z7XhoyfNRvLHUneILo5yecJMy8NK8m0dcVVqxGG4aWSFJYSM+uHlpYdOeAHkM3CMo3HFFAecAKUrv4QFy1OiF55wFCGs/1ocv6OxdiN2L/Flc3B5QxTVqH4+t2wSffTC9Y6849iObKOjCHxqPTqOgwTkJFm6+BF3gYczJ/WzqS848s5d4JLcxo6ph64tHV4RkSa8P3Ofy7G3j4piwaibXmg3uYv5rPzO+hnPMqcritAGpUTXJnGiAXgwN1+qEVQxusrLo3EUfmjieh1VCNG4jgKh1t/Q6O2VuAP1Q0t8bUTHcaHQzGuevXzD5Jz/9oR3o/i0UwTZSJC/AImncfEZyJEQVVXQvX7x8bIuto5m4dynC/RzvB4r7t94/i2D4PnP9yu9LYBJvpTgLEwP4y8qGImN/8EQyPTEnLIlPVMD0/r7EWUTAg7kS/uUPuJopx/gnrfU/CXf58EkSmQFLuHSjj9tGPBoYqS0jpnsaSJhQ1Bk/V3Y3OT085ozPpcwxibC3SGtJF1kza6G/6GhqRgL4HzJxLtyrNh46bf7u/RwYxHeukupkUiMZuF2O0J6v5H4bIFvvFdh2Ib2fl+wQ+Wj3n7vFiDbRBw4bDHBo5uXUAEYwowwkFl6dlZvxg0JYWjaRGUDXpZQEkk6exYkRfpCCCBMmcpV/RqhKQYRXIbL3G76o07JmsYEZaSb3MOGaPTSA9HkIHOq0BCX3JMYkuGZh0kjRZROx/r6H3ULgPp8BnnCt1i63obbb3C0+lRB07thex0wfTyKDTHbI/KbpaUpD9+zSoZlsEOZTssMezC2pUDTlVq6lN5QId+FhIt3nrz71srjSWiUYKI3hp6K8ShiL1zI4PeziPtz1R/WMRdgBy+h1t6/RMs8V+EAdPN3HwG4gW6JdbhPuqnML3OObrQnLxHdcFxixXSHzuxdHVL+dL7WOBgOH1O+Rxy2M/SaTvqOgPjev4nWEkMxzWX11vmd0B8oCiiREkisX+0YsfzyvwBXxS+tz9mRwghNcVnP9W25ypGtJfmylQCotFrCOVGV/39qZP0pkIBkWVv05MPCEfuBolaZ6vax6B2n+WoAwtJiDmOjUmtixq4/9+YiHNXnDnefY+CxR7WG7JgOFfYw5eIcVH+Vac47sNrqb7fnyWbFjrA0oxva+KWF6VVZIMKeyI7ogXE+Bd9Bfmfv/L5/yilc5xiZtjrqKQn/CIZ/lNUKysxfZ3I15wEJFTOff7tTd4GB58l7sGh/pnHiMIoQPQ9HXEm47PdNqlbBTL9clzUhi6oF+9tGIa8SUmZylyODgllJ/PBOqSM5eA4/4ULHxmmM8pkBGKnMD8VbvlFBdNsYX/Un9TNguCQWsDgWtgQtKs147pI1CApGgaC7pqVrGlX2UGrQbyB+T4CVkSH7NqKOdrvzZp7vuENpQnT1vEwTaZ+pABOaugQsr80LlDuTSrFafSXsfnvC7anScZ/seCx2MfsAo+i9Q0Io+Q3GPkIE5Q282e716xFg2sCsOEQwN2YdtIhyn4MMyPuQLl/lDxZvPjj3BPn6PLpYNbFb0vjE0Y0p2dl4Vt9hOAnuQOYr1HCX/mnBXb1ifVBZ1SLhbvgJsAt5kQajUQVSSuRsDfRAE3AQpQ+3By5ee8uFGLUKHgJ4wyavy/scJJRnNPuNAbw71aVEK9uCJHs/3qxFYizZ3R/+1iD0CNRy4Bs5ZgEmi20uUeSp6J0LgD3jiQitGyc3bBrQU5pM4ck8RnMmvft2EwKLWvODFYKoyw7GJ4Qk1woPXAOzrRa4w19qhax/xwxNLikPE9neegCSZYgTTD8v/gB89AhV5ixHh8TwxAbXuTVk1HRUIUWXw0HnR5SkkFZCBIh8OAVyMtgsu4h4pZnYZMFPUMEREYAyAiCnKYevJRXJ/ITdflySO1EHN9jnLPdtxcLlN/rwKVw6n830OqU6q41GM26iC22czdH698DJ+zVrLL8Ufp0hLxVidtLByPPlAanhTYAoqegMwwHfEH4wmUgLtneMkO4sXN0YQaX0nrSXHsFj7+4YMapJcxBXtkT1zVmcTpFC1fQbXrobYmffr1jmUbbaPCkeBkUUHAkyiElKzl29SgzMWdREZlBQ1WrF3JJmgdCXSLmL9zklyWUgKA7zIL0iph2kpvKncTRzhhsIqQMBaoFCEo0RJuv3Q9azypL54hT5r4A6DieJfckg5sDx7NjbsRGXLmns5jICeOh+tKkYeyAq+eezANVJaFNl7oizMkYILePi8zEGEU/OWZX++J7AHalGs6LFz4/LRp/eh5TJoOtyzOmY4Zu1bTjfLZF6BO75fE9M9ZYarnJg1+FhnAqLmFBATZbLgovwwiHx85G0i8TmOAooMilq50P8auKesZsTtPVVzKWzq+rgSwE8VMABSGdR+pV32lIyfVKg+yY7WmQy4SD9PLzk2yhODtsUTr64bWPdnlmnLhP7ZGJ7HW1+lmpq0hETs8kN6DRgko6VUJ7o5Dop3/xPwywLpLs+MKvWx98E5kZ+8lYU210zGHKWH4uEoF5SEEkt+7nBUPF31f2IAYX0IgIknQNif6bSvbPZXGv2zpYKBBsvAzqbazAS2PcrAe7vqbzHqJpj/5fz9tF4oKdXWtGROXuUEjOj++MwOWAvjj+9KyHhukeFKsFSf203hBloXimByzy6ML2eIkaV58vsOPswMbIDuxbu8mk7zlJjOjxZ8ZDrMZ3vCaZ0BUuYHRLU7hR4sOTr5gbzm8ZPt4QkGg3U2jwU8uF1pJ+Aeaz+rT50LxtaOY3SaxrlQD/Y/fTEQLhGFLRRDzRhOYhwyMom+cdgx+OQBqQJu5QYbQ2EwXdJei1OPbVAem+y4WAQ7iXZsUQCJIAzn6kvCa+A1yC0gNuicywyk1CYTqLKPYitds1Hrv966tMbxmpYxChwFlFSDXvDFqVhY35YdE/Zn7HTMFiATUsTLmi+J0Dw7ASqAKs7nFRmlc0dRimR8V7Hl3UCGktwIBz07KfycxKX6yX1oKlfrkCD+1ldeshxg/vuSPA4ZIlBgSTLiQMEanwOzS68WATdYRBWQg5EyAQfiPHm6ObsJ4Dxi7aY5QK4WcdGs3fQiEXudxytkg3hrQ8iTuTU3XOvcorRhuvtkjzVBB+gKnp46Ve3wz8zFh4+uJ8tGza5HyxWAisGDkdya2LW8EKbnFMJZBBfQLA73PI5MDz9R3rbmVcmsO8Uldt8P0q8XPBL3Efd4/nfsvbECx04Iqi8O/wTtawdh+6LDPW23Dzx/Efx9wGDwtvfi2SWN05O1lIcHRrfZ8P4wwevictsfbLf+jv/PYCneUndkdLU3aYLS5IfTlPrycTQKjw39y8Sd0ENX7W7xnxLK+Z/7Y9wvpP8F/x6YGC7IQaABcOIFGIkJpiDk4Tz7bFWhCxW8HuQmyELaHEQFhYgDU4nvparQJ0nobuPbhjRpzYRuAJasNwa/z9UG/t5Gdg7DyAHXiPg2DhzSy0dboL34KnNwWg/iIKp8R/uUfkLGSd82HJ8mIpUjBjYqghR+PH85tRzVzdi+PWDwIPO4UBNrx/FzIGgAHH8GhqXll8pDeMBAzApeSfqT6pceYsdRcsWJLKTNBMKfJw5IJb7WUb6TlW4+1H91bUuxBvHdpYrIDaMrt5BRrfFO2skNU7KkifUf69HGeLQ8hM1G0datymg7jpcDDQn2opWR6g7eR1QgSl/QFa4ec/H1NL4n+481Gt8n+gOafwhBnnq4doLsnLQGPUdL97C4kKa8ARJhKobYehfF3pL1dyyaEcUPxEfzblWXj1wB3+BekoBnd05KngfuH3LVBTJaJlJaQbdEfbU9v38e21ZfXRgFviYyMMu3Ql+j2yKv/EB+dbAt5/DFDy6ycS6SqShDTSkh7tyCwPAEnLoTG5aIezgADfRrozMtwXP3vwgTdmHjohRh1NHSpPpB/U3CIISvYOYxef6WbY380u2b74nBXx8ZuRA3N2ifjpEMNdHQsqJfETaHucXnxaI+xZUVG/edALj8KveqtoqL2FJbIlZ+h+N1dSLZsQR6q7Z4e4GbyqsE4Z3zXMFTodpvKeH8cQXnHSIiwM4vPPlfBPIXIIRLKLWEuV/ygpe4g5Oa9lilvuTHPscTH8U/U/FIlYeMlESW/Ao8pU1BSEYEPihP50+l0Pn9Gy8EP0FA4JFe4f5UjSpX5KdHljvnDTy4ssoy1+cH/SPaDydfQghJDssSJ+CxIWockgruJwXjwelkX3vuDOomtwnCEJWD9Wp9BxzWLbE9K0quXh4ps8KRwiQVguBEInoPlm7Ngy+LO7kjyBH3im91quRodkFMIcUnoBjoGrmubOQ2i5WCiW2Cx7ucv8Y036/MwQAKtuW6ZsOXSQ9vC3Ig9yiZRQnnH8rPgGrR9o3t/xmF9XBp9/EjydygDoqbvU+uEX3dTLYu13p+jCiOLttGIMXoNWOTLX6R1nCiNUkPcwLt0+9xZ7oGGbvrg/KULEMF5q2Bc4vy3wNeuKBb4l1n72SxJhPc3HhGcMj/aEw5s/CzhwE6oeSA3CcXxLrUmvwuNmcpdwfTnmCbDHYBg402pSFQT48m50if+ciMIJY1BqpPrfZtcbHZ/6auWIwNq0rgzgIbDkyAirx/NWws/0khkJpgKnYS2IgPgSTryv9kwSMw4kjNAmodpYLpvybAzTNw60nRnx8iz+7e8XJXnEVVKbNFFIO33Rk0zn5tnVaC2x3xywjrRvFsqPYv7CN+N5AsRykQseARv7vt4wAmgsFgsNPIQzukcr4ILY8Gj8HuSzmj6SI4S2fQki/YUyiW/UIedMQNSMtxQ5Rh9pXeDlt6o44/NQV4qeRS49w06wTdPGI+jV7o7mf1z8XKGx+wksyob9XWolFkh6TpYwfrJ1cc5Zt2OpEvrgxrINz/lXehL94A/UVjGoP2q5Q1uWeOS9Kdkm6oF3TH9zaHQ0n9zNcnON81zbf/va5MEHjCOPIoTcCoobVpP1p3G4Hps75CqVV07lAWs1a8spSAzYXx1PZ/x0/7HyYcxp8vf/aAtuDic9NZvGRDsb0ecrg0I6Jd3+qEhaX9k+dawDM7vTK4OUwXvhoDzOi5ox1Lyy8Hg9lY276/PGsGzwxFbQO4xKxsdLemW+EmdqnksL1yvfjqDV3f0lB9kuJ1wIWmNI4p2SbEk+1ahikVpyPoIJj4nT/yWp/tXHWRtGjnGFc6cs9AlJSBdGMCtJ6CiHbIS2SML4uo0CBeWJ7ah8YhFPL1QB6SIMiLftIuyEhocLAnk+m65ki5ukCvg8VWKlRS2hsFdQ5gxTJjVpxRnitAZ4dVMbhR2TpJeHu/7fHHWscVtsEdmv604xKvkPlwCN6/9eRoIv6DmFPk0dZBTtSrVL87o2WY0irjbIVNx+LL8cSFsvA48xOLr+gPONwT9ALsdRzuD+zX1Vp1PAfp64uVzrvCJf5RpLc00Spz5DH01w8v/oMjoNAA+3j0LiLuH8yN1v37qfDjKepdtvn57kS2KSk0ZNKYIOwPHO44VjBSuFAUgaW+mQ5s/ReMqSSylE8u1rGbC+pmYUUWA3my3pWRzRQ1qQbDyEVvFsj9cFHGJVY1jeUUk4c4hNvQL4l5lTFfoarqyUqwBi2T3pElSflhzol42NrncrDrdHRYMMUaq4aNuXcp/l85tn0uG76cJy+tGFuD+vlgkDgcEuM113tkbc7g3b729sUeCt5dy5QozEwS0yhS8Q2yjAjZhTTCbIGtfzlJ27uUV9E5nzpmumguuZ+XU/pgDlxaeqnceD8nR/9gNjus9PtzwkGwe9+AJ4M3wmLOq0Wo003zDe0f9hh7YUkMVTPl1DmFZJq2uOzEClg5Odlz162LJ6PrMAi2CAMlVSOTMLw+8rcWig6xxaKEmAoKNJrC6ujHCNXO7cWT19ap6DoHwMAW54WeN4jS16jOTY7NYVvL3zZyx3YX/oq39hr7sWSnG62AkotT5eW3xeZRUgLE80RVg/Xov6TlApyCz20S1qcO09qOecWMyA82RLhL6JbDxsaRrUIFt7wlZ3RxaXDf1qxUZeTZ9iEmudiivhIdyugdcedMXh+qDJefcVQcHkAzXQ5LIKNLD3UN4j5r1xC0ryFnDDLPc4XhohN0Mg6LqpfiofRuJU8lZfaRA97u1jhG/CRzk3AHaqAIKJCk6nAoIQidYueL8rgm940SWaODL2m6s6242CZtfmZx2+mqNNfJ0sR9hEZN9v5H77ILy/S1k7NFCGkCQ1tcoA6iVnRzWfBM5oa+mSIeCNb4VLMo9QC39S1wzhvFngXN2gL3DHLZGgMhX5eJXEloelR/vaQ4AqopFi411QTJwiDXfS5UbJIIDqvalgcQWUfbw/+mjRX5fzJUuSMqbRucaG5PKHwAG1g6Abxx22yjQAYq1sXj0VBFWRayn5BXHrTvmmEDZ1IyWJ9dcqY15Xirn/MW+/alkCvRacfN5jo3+a0vrbTCoNwTpnZxaTlHbG2QgXNqOpa3DnYf5JNzLIE6i7aZkkXgR1L1JvXxS+9+Nu859HMX39yhJ6+Kheuq+tGVSgNoxE9HYnzmJ0OUJcsKwamSibPX6+OPqGQnmxfwDzB5PxPIuL8/a+oJT1FF31RRaoB/X1/yJl3DJlks7Guk/j/wgvJtxzqSRGYOjjVrsWT9r7Y3F4Fqqqq6LJO1Gn2BRgCPpxflKMOzyb44gbwSV3t//Ya5w2k7k0/iS1VqvNH0Z2vDuqD7tC3C+6Sw9qtTowWTDVaVAVaIw9i6EEQsBM7gQrMRkrQQBN5e2AMdIHYLjQaECbb3pHCIVXz3Uky9jnrZODXyrFS861+nxM76YEl9f5LzVgOr7klV3pbplfkeH6YRRnR++/TFMdnMzs15wh0Mr1ljK2/bfB9e2X0SWboBqe1ebTd07+RV9imktSMfecPq9zxyBuQ6fV8t0JoLR0gdmHHApF+DDClGmZ5VtRBnEKow55zw6OrCKf8JRmUZHX9K0tbYFoos+DXFn6cSNDSFB7wfPqh1N6jvFRFsKCsYX+kgVzjcH/vvDSgOTgNOJzGdkzOPVhDx8cf51trTH0TVQbdCBJxJgrT+an2qIaFubaavz+31z7yD8qJ7/C1E9YH++HnP2HjzjtEZFOffV31et/RrY6wy973TumD7zlLJzcKCDI1SdDU1rqyxO89M7g1JVEjScuPMEKb0IDfz06qo4OGk0ISp+Re5dEX635SxtejsMBafnV7UQDlWRXTBFd5gWJKD7cCnWVGxrOr4aaF0mZdkY3PM67LEjmiYp7zchYJ442kPsWXN9kELWAYvejwurwC9yQGe7h6nN9atU6u0F2+rZaX/Rx5di8qsq9vd+gasBRCva4z5arE5WhpSSg6VlMAhlZD4E5NvXA1SJEkKOErIwhF6mIxBjrbk+mCUvhTnzSBoVougdP0h8X9hGPXjbawPkQfPQ4XlkH1x9hEDhbO52cWvcflH9HXNX+4UIiNfRT3NzFCBPm3v+346PEyN+6Y/PJ/+r7g0T2X2r+XZBtbTbcMLYMvIslr2RyUsCuICQj9VKdUuGy8umxotspuOfSwAmuPYXb57X6Y85oy+Sl9dEZEtTWPHjdXt40rrZknJUYY71YQ3+UlwbY7jRDbz2jpjhpAjrzIxL8Kcn8mSnweANmRJS4oIkr6eN4picUo1Pn60PHQoRiLGuXTivKx4Rd2aflMf5r3wvOHFyXdFtRxadV08Gj4zO2WfM3zDffVckpI5fpyaoy7ehglo9ohqHTSVYaRsSmL3uA+NPkbndVMAoRlh8pYBnzhGw7qIk9V/plUzOfTOwrOIRntmQEFgtKOg0NSQTwrJzUmGwZQ8GnTDo8VkT/h4DWcFtUavzlUsIYM/uLzOemh1J4b0cZMhM+4duZOvWxzA4rwz0itvLh/f3NYcPME/NvpwePH8VoV2xG5Xuy7nbSWjIlS5sS2EyGVVgfajrWES6tmSxm/6t6JbJR9lVs8zjdWhsCXX7L7/c5ZmfHTd8MxE5EhfItWiRVKLtfMJ1LLhnuXF1sHTV5Z2vYrx0qW/da+0erkjd+/ARNTXgPkxywebOzR1ge83DCkq8IXZVd957mrLQuuxGVsFfF8xUyHMLP73T9hIN1DlyBocOnk03Th2FOoc7s4aL78GSX8C3TgBTAfdzM98UnTj9U9l3PEgSDSMuGBzjIwfHCivGd9o3qiMQx/6olQ9Syqj4zxg4WxdpDKFrsGgeAIMnisozJVdYmx+6laKXoyvy6yhWDqQeQeX2kz3Dk9rXfabm+NWEUVDqPiowZzJ4jDnsuTei73NUXGBg03i5W/yi1/4Gm39uxv/vLjg/PsxmLOqJ5svVwoFA7+3VZAGKkqYhh5BqkjMxnvsH+oMNXS1JhmGmvIIn8gPRfqyum8lxl8o26jV87ZvO/B19WQ1E/zlCgRmdOmnzhw0NM88HpD67NvraZ2B80E+b0WnXrp3Lz6ulUwvaWPBnPX8fMr6dyq/4+6rk/t01ZMBKTswQ/UQa0svdK6lorJopFyBW8BluCL3oISuinh0kTP0BPAIfjQEop9twqDC41J7Y4N4EdTAuJifHKXABbP0BqkShtnqJ/9TaUzGiI5EGMaB6RjNemF9SwESBWsllSRdeytf5upNZBRe0ttZc7ov8v/JE3m2c/InZjeOBtrmN+iYnbkU+bebaIt/NtN/yJUKZ7cHQluRhTBcb1u7l9BqFpWUNNJybqZWh5cOCZ4FJfW0gL/sMm6NrXryu7tl+s2z/iKdu3F46HKGb+6Wjgzz4XbI2Fjm9+tleZIlNBlqML8x/LVPYG3I5MHz+/WbtPSy9Ybr6QF1R4ud7z6Dl8GfQeHvFZc0vPe0BOa/o7P0Pd20psYz0yjE9DSidGoG6TtAYwxF7iA+K0q4eCxVpdhQyzekctnhY/EKNRIYVD7/08cLZSaMjow+Uywrm1/dwGHUtsvYNVVMTnVzQR7vmcY3HtBnblIBzi+2IW6x9KUcUwNV2RtK+RG5XLlxNE6u3NSrLzJIgupGFqu6miWt7mCxq+qLEr+8sGBX6+Fx/Lm3q1Nxk9n+O3387qfpdhpcrZ0skaOFS263Em+BK8WvhmFgUhP1oaqqGUucPTVPl15AkfKsSCyvU/8F0z9W1DX4s8zv29r31DarRUHI0WMpT1Bk67ezHrYiovt/AJeYTlyLTTdcicnemM4UddxKNzcHtl1KDhloSFQNtnt7IOOqj+qRtwM2FTqyHB/hfNGSCoF0YTVcwp+XidbEgtYTYflm+tmpqNaWGNFqXTCqRspQjBwNkCuOipTzJAidNAVNr6YODzrTqiwsZo1k+wCTWVSNp1os1GJiD7xQE+jsTpMvP7Bea1KWWdYHopmsGlqhf94dayVsQb7tSDsq8kqOVXkTPYtUxcyAJyLSQNWhUxJ9ESm7/Yi7su5lZdkXXEqSS6eLLGhyadh3PbrKis378Vma0wLtrDCgiQKdQ8PapscSddMjGaXXwRl30lGj7zi6ljSL9U3+JkDo26br7vEYien+m6mxCkEiO1pH3oWQLo397WSJ1T3tGfAfrzggKTMtL567Jfjmq28M7QPYjoT+jYf10CHjsM/L9QvkniPxf/m9efvTL57zp//rd7/817H9x+xbJ0lcIl5DdvQpMpusVXJl88GXXra6PFtfG9D4xu/bT2+m7ZSXvsxEdY4V7d8SP+jqG2Q+EQM+3SnDsGcAB0SSEpMUw5hojC2orFu/5C9ycUGfngovxcLFBkhPyhCzR2AwwCu5vaeYDa6laantdkUt1ZKRtlRN+3BSTetHhxD0p6KfzmJLdz/lbUjpJBnCk/0thHqgjedlDkKZkiZTATKkckCaTC4V7HPxWJq2u+FgQZ19XIeihVydYTXyNs4CEOfSYBbuo2gJxOw7r/rD4JdyoACKG/DEoyrex6J3W9bTM9+qgVcPF4e6X05OZeR+OVv+2leY4Tmwto6qjEjiD0x0ofIbvtj2iJeFuNuu6pN7b99to+8bHtq6Tb688PXMOVZBtJnfQTJmk3esNJ6SAlteGGVSyYzZw68fvh9JJFy9y1aEuIafW/5Ebr7PvicZf67fPsfJkG1LHyxmUXaWScMiJdF4aiR68MjN7pi8c//Q68wG6oCb8S6zF2VTQwwWsdShhuzfyujg9s1h7rOGfxaU0cD4pbG7kdX4nvINX3nm7Jp95brwoVNztKbZ9eqtPVnM5QOhyGvLDuov7/hE1SFQ1oJpEL5uWgcXWCClinQXB8fZe/8H/KjlFVxom9p2GlJ2toNq6p7KOduyw6aAB1GEc4cWasKH6Ywpo16xciUMcZq3p9/tO2171R/1Uo2MLKFUm1V2pWi1n2PUpZZNy6mFwxXVDKpIh8WJ9BVyQDJTGvxf2TnUZrYrBKnOtD0gjJTfyYeNP1mo0G5aVnXT6XlrWksDawuVOa9LcD8wmMr4yjx2jVxivlyf/BWlxT6m0BgBvRzdbHEs5cp/UC1pP0jWYVXZZbB+gPQTiOZQcPo+k5ohLq6VPbSWJRc9M8NSWJqVX5llyUfPgMGJjndLoB/CYSXvHxbDHO8WQd+Hw6Ef3StWyJHz1hCtK07RgulH0/OPaC5lr+9e0Enb8OGT8L7L2qc2zF09mieuBFyFlL+yLNodLhqStLwsynyHUDf4Da+dJFNACU6nE848MZXNULQcdRWNhR9ad2lxK1UQuGZTZJ73Viog6v0vv9iMDK0SmKFUIgp/NKeVrd2NLHz3eDWwQM5dI9EozlxsZr54qcV2qmsst17LJo+U1DgGLTzZ8vzLrEmWaowrQjeQkgk0wTDt30weUpaboIxMIcrx8XkqadoiPP/dZmAxkBhnJQOKKpsK2o+mgnVH7haNA/UiidgwOZxjGx9Jy8nOSXsnzn61LYOn8AyOZxISKy7RjoYpD9wuqSOz9Y65eSSspREi1PeqY38Jz6LXwevA1h4wBSicxra6inv99y9ta44WVtTur/A9wayMwKvDMx6FBWSLukmF9z640enJY0deFuqEd5m9zy6mHgHCjJimnFyjGSIXgMgOmnSHGXJxKWlJe4nM65h2E430Q5UaNp07XFr1hHSrsN4q2XCrHO6a2e0wYswZmin0tU/5XwC80I975Ft4UIdJMSbSxiCDEe3YUk6+jIuf1pSWD1t2q5bN/tidLrwZkDlOA0cJQ1HxwFKKEz2AM/KLIkWiDTo60OdsAS65Ksn5V3UnQzxpwzRTfX1KYmVJ4V+pVq4eX8w6k1Fc9eSooLj6vYLCp0V9L9gOB0MdMxpH3+yc7SJXAgdCoZmVOYyr9bcK6w2clUdQ0kjENInbTm7I9zLlko2MuXHRXePLaNxNY8JzkxTR3SvGqOeal4ktrMjW3ZmHmIxXIMl3s8D6O7PZJuMls/6ugmEb48zVQCwC06/KbnNEVZTdWwanG2/kZN7JwnVxRvHQ/Z32l9lnZprF9y4fbxSYWS6eo5AyDk6I7ptcwWQyTfHIkEyuueLuMiSD7qjiMKprWXwQrMoksR6RH1UoDivkio2jMfKV3dQhYbgWEGUuBGrTWPBjSf1x8wShE0ljVo1CBJZv00D0fOqhUvmFwwnKlGk/dnZ2qtii+iVJCTQOdaUqh4eSuv5rbOCvf5xOQZBzd8ev27Lq5FYA3YClLMmzS6T24ldHPc71YHQykC2r5e7OuB00Wypq3ddaWTHTXpaOgq+O22n6+hJVg4PxK1cc4OKfFD6E31sRnZ8nSQ612Aem+cWSyC/JSYwW5v8lxqkxSISYUJiVJMfguHCzoKHig84oi61jDE3pVMKukNYqMfwGvTbgNzexR6dOWNnTB7Pnvmy86O+4vvunvwCpKwzRfA+c+1FADaFibj1Hfbg/btu2Fc3boSBSflsjs7/AOd1Py8olRGU1DIeY1ANFF5k33EcszCS0JIXQtDDmA3D5py7UMP62Yp1WZL41zc/EjfhU0ec6u5sLqtaXkCUzjc7TGEzJwN8Tk7/ivxqa1KCq+OC8ungepJgaIV9+PG5DoliTn+yM1T+PKMvDRGCji3M08jTA+oWeAHBG2dpUUeNyb0Uj1u7DMr1v2y2MiVX1/ONQeub2m1cS8VfKm5uE9k5NMM8zR+WOrgwM7+0JlffMZxl6FmP4X2dZOg1vLUFySm9kg29miH490zquQwEkhKvJqeI4D2o4NiRJpLfC4dv1apUKLYSYpQvO6jSpoM+unrTA7X7aOc0yvtxi1jAOHjp6NuQWTS2tWuRypw4G8/U8JkSYUOsn/5lKj/MTU40EZ8v0ChrdzIK+W5aM1j6E5D6Bw2n7m5DiFcTFQkEvdmEGuKgIIKRWlK+0DGCvjSKrKpexI/4H4f+Z29kCgtWrJgkcA1/6Bnq/syUEmnADA2rSnCWGz7DP75E39r+7eh/Jjqw/STJ07LHJzr/PCIq9uKNP+uLygA8rfBMwlUWmLdX/U1gdnlQLBfubUOFvV7n41rs4pvKriPXMQs1f4j+z6/jW8Wxhs275U7+V1LnSIUu41iksf2mZwbo+F178yahTSRojRra/e3de8fMt6J470vf/3E++1QilHV0/T5svfHpXaoF+YvCacXV19drLIT/RzUd/JnE5XO4wRVqht09MGQf3rDc/v+3uZF167Zu1mQKtPGJpL9Hnbyfzuc7Ba1dXFV7UOJcV9LmPJCeE7ctr2j2eaF1PYDt5US9g2e8odsn8bYX/mn5kDSlkJeNN9KxO+8q0BCy6nTKaPVQl0mzteTd568N1ro057kp09b8jC3Xu/3WwOkU3zrhkP3wT8VBiLdfjg//vxZvGt3Q3Mt9Liuehe99/7eHUtxzDrGEkaO2jUjokXF4pBWB2iMlsFosL02Ob/T/1Gl2QlrzeVGzbvv70u2c8kygkv8seuip0W9TN4Gja60/mq8J3qS/56lJ6U9137iv6M4n6Cya/2CEUVtbJlfoqgazchqxS8dxES1Z+E8v4B1YgBT+dgnMqm1GSMbFCsrARYli9vcqANl04iaXetxw+7ff0wagP8eJ9q9kBUOniGABFooEcpLJ6Px26rvFX443731tlhKn8v50z7oIc4ooiu/dHFx3alNK6Lv7J/f609Wk/Iqe19+tL86nw91/jy2WSd2RZWB1jhrxh7dT556mON3rgkLWeS05HtbbDFcW9jahNhw6+TFQiK5D5fgvv6TYfWdQzTkpXPgSno0pokfO7x9WeB2gXNZQkPkynSvT7G6+j1h8tdnY/WlhffbDU2flgcaWmS7B26HU9ifhGqGn9EeHagdek+vpXgi24uF3xFhtXYLXLbr76sDT+EnjzQ/OPKz0n5q+0rP7ZuHD96+LlpUXBpWsawJUn3ovCvst5uywK1FtBhtWDWTF0e025jpUwSo8bYiR0U5O6UyNGtkNWzBA+ygfu+OZNV2xt6xFK1MSpvhbN2Z39VFpvdbBCxHPhXRXxhIwsDi81XMfqQxfpWOnsuApSrPmhrX6A1MyCw5lsCEnGEAyvDMQVhd3F4c7iMGdxuLvlmruOL8m8ebguPp3aaYqyoLV9dtncFdGHl5bFponDu01yltQ+DHCjTvR1V/tPkJjWN+oHDC3p22glKjav3MIWVFbQc+q6VRO7aIm59PjG8nu9mLG2+gynRcq1WdhMo2Y7+y+jlDG7cy/O1Z8w3j2gQJes+S94Zdx9+3abUXN6adUP401+CzWsguANqqLBm6Ov9S8EHLbYjAX9qU0jzXDVMs9zVV3MrlJ43AojoZ4eN0tP3DvP4K2wlon47nJqhf5FoqTqk/3sKy5bIUGWMo7c5Nxzm6c2ro/TKueo8ev9EtZR10qwbmTCPqNj7eriIL23vwG0EoPApK3cmI6mvX1Fpn5LcfW3KsmCF8B/F8jFX7+Fku9x3MxPrazSssssfFZZOU/0htosmr+GktiTWff3j+5/5863lUUqToFiFKDslevZvniT3hDbMyVCXt8RWihreN5XGco/bbjGcIGQgpbHd2Qtu5x1HEJRWKePTBuq07cxS+VsvqWMJbJb5c4b8MSv5wz6RlQTh+kJvX5x442kqxJmFKu2nMO1ljH51irF40YuWACTwlDA8UWw+9IYKYLp3oB81+bX+royynZv2Mi3t6RWEIvGo0UUEwKHzQj2V6sfUHZV19FEdWYaocadbYa/+HVP+mQcTZPIRA/EVOYGPdOC4ArfdOGjWRbaO6hiESyKziHHPDgQRDO7wCWenUef25nNFFUWY3OkgBMFBwvKHXkletPKTnH7BccBTl+vcuKwef2ZvyE1etU68bExocMbG4UDl27ulJiYEF5e2ywSsgysiDr/6ccGLOXhWja0/gEk4yGs2PjmRpZsMRtUVepQDwSMZBvO3EmDN60lpp43jTcOp6VgKwk4tRqN1moxRK5z3sFQft6septAauYU6N/cJtI1y1FZViIPUiIP5CCDLL4HLOkZvZO+ghRylgRHlquwbF3/bZ+Sub9Ker+ovVLHH6i5yxE03m+Q0pC4VNbamaPmdPf62WONBr56+mykVtKjRePxBMw25ZuMjGQiJBY9jgmRsZR+r+MXs9P6M99cvBB97cTGTOk9WGIp0jZl02BUagyVszybGSxKP4AzWSqJZnPtsNTa9OwOzfdVSNac85q+NfifbExfiC4eZy7YjLDRNdKi2lrsrYtjJqiWUhN/vno5r7YupZ/k/yM8UvTyBycb8203PNKTm6njLOYZpKQGS4GistvAFDQZ9OTKDI75FTrd2ZhV+OettuCPpnGsKxBTYyqWFyIOmJ8dQA03b+k5yzsjR4pgS3OTzk+drG6CdQRVpsrr19MzhFqDGJ36d8ckEjT2PSxOQkkLS26odT0ynxLz9ujuLEveFOJg39I0PB8rn1YUbbXcHn/7ZeMl7Qtnfb5GoSVglUZUwPp6c61OuBjgW19/VR2v7VjSgkcQwUpMgPv3cFbOdvuiomKEzGASCxrxaUkm7fJAKp33W1RJi7SilssrrZW28EtapeT+loDPYEz9pUr7o/TmHAOltInI7qsWLBvOIdq7rZeInJBidBM6XOUvJP6V9HY8Ycv9r2VqH68tbUzRGDWjLU9qi12nJyF597fmcVbV7y/zSLGINCASKaHjvgTdnCIbw264ey09cftU5Ms21lAcfq0uAof/1iksK3dmn2/ul7F0CxtuGRtpgV+mT3fgOt6sioDEKdRUvMGARQsLYP3xnLADQShUqk+yTaUQ8Zm2I20h4t4VB9OV4fcANm/HwK5gAb9WqdWhMRodJRyR4AtHn49tAnekgjKLNSrm4cE5r92vwg1o9eaaA92HLJlznP2vuO2aBA4uOz7VVpWfW7pvt006qVhfT89lb6bnX83M5B1ZDFPCJ3ICn3644Ab3TSWJWHVh4bnSiJPxgFoNVLn3cGQzt0CszEJij3MC432DFStPM3jKzEgypyezIqZLf90uQ+TdDUs8bt/KcH4gp0K0Dq0O8Ye2KUmpgPo2wtKzRyHoxV8+y/zxx9ffD7TtCxx0PHtfR1le57kNqWWSrDJbrN/pkxV5E1S/5A61DT8NdbZNtUdBFm1cUm/ZPWTWZ5ialE/XC4vL70GzX1bg0z7bLL302vvnc55d+0ghwCLBFr5IFKCTHM2FjuFzyTGfhRsv1HpzSnG2FvT+3mUIz73yzWNG2WVN4d9HAqUrGgNYZdysoPlF+WckYH++qeKWQ6BVqqX9WJlihjTOVb4sST73kIQLzZlKa5XxJcKW0gMuIo9VeR1ZPbxn8ZYYJRCXSNAQvy4J5xbYe63f5mVOXiIjcAPVFZ4DnGRbRhk1uyWPex3vuqwS5dCEzpRITYcujs2oGkLSbAILzOkfniXtX+ld9ucj+a+gygmriv4mv7+8UD/W0NO6hnRInn4ti2vWDUxxOqu9O2H/VMRGT2P1l/Ppg3oZ2ZsCEt99XyQ4V45IXlHtohYtdZb+gyDmVua09/ZxJ8u8H1JDe6MKksDiYK8TObypAxdOnzVe67byeqlQcYkYYAisDTenF1fqh17M93tPw7kQgnlMrVBV6riFwnxpxmhMNZZJy1RJjB0v3hPAl0K/3/HxYlUE03LE3buc8xv3UCApHk4bmY8+TXFr749z6ip7/IOkC1IPIHO9T3XXpk/IaRtqTdH2CnheYkRy+6ocsQvgOOimjem+JoizBTf76zAiuEGUG9lEVy7/7vBTlEUj8/mv82tOeBvy3zszEi8CpuYkDh7RuRhpC7ug1OERrWYtFmEOgsyjmTzD++q9Vk08S1G8wHKOZMRjBV5hdL9W6gP9btCoDQdDjtbY3tjLz6t4mJfzEFJQ8Wg3O6fyITjvYX2+80h/UfXa4VJ4T29B7fpxOUduYeVDHCL/Xj74ISS76tHN/Jymd6uM7N3ZMaYuEafxaFeR49CZEn6/PIrFL8S59pd+twJG9t9IS7lVSvbCt3W68FvH1wfDRqIBn2315xzVMHXnVLqVho2OEufaMDS0A0Hghvdzsx+8XN4GPvoDtHzLyI8WTsiV/MKHYLDlwfW8gsb3sRb2DkQ0a4mc51jbhJccWy4NbBHF0LpzEqK9wuYo8B8WeBLoO82tTF5dc6SoviG0quyNWxB48wok/dtqVFX6d6sQZN+N1JTbpWQ/fFOnC69tfH0waWN07o7Gt5UWjiTPqrSmhhBhY2MYNQc6nokOnP5nag27mpj4Dt6n3fzhSmrpu1/Oj6RF4Kc7g/mt4zNDUhTi4NIIXtRkdO+usLb6ElH8OTTlQ4tfXwpz+ZOdjrAUIXBkVXpeUkiRbzpfL9fC1Bk6lJrv2LQk8J4CkjENFIypXhuesD/KzLmbrx9SxVFF17BaMlsCE/dTvc+csRZByRZKqcGmHaWamgr5dHmgoHHH5Fg6QT9JDrbKG36vyaq4eRMCUWdlLaiZ/APxz/+liFVAXHf2VVYeRnl+SiitD9vVGz0ZxR8SDURRlhwjzeKC+3Goeu5ofeqtG2nVDcupWR9htvGJz9YSMLd+TTddzVSP50CN/LrmSH5TQ4mAKySsnVSA6+7c/Qq4J5hJNFk+XUsre+/004N6XpfAacE5pUT3bPijKzIAewG9g+b4Yzk/MdpYO4CeV4btzNiWe99OZv3JU320TgRUrlBk8/0fDz6xtrZbqyftvcZqJ6QSVLV2GuZWT+i4pKvEnHzScbMoN7nmXGLGBeMzUocB5gv/9vWCeg7+7SfDAMRhdFIJvCJr8GlMzyn6UtLQYxdXKzfPhdkffX5/c+vjf5v81cOBL4ELxxlEbBuNYGnLg2cW1wsQS0rsJSMlnvfW/tva/Xx6M39aqNysFtn3OSMQWdZc8KLFBmw9rbXirKFD9ROWtK/5SeWA1KL5LTXBzn+dQzjb9Ab93XAzYWjpKUj3YmVpbkVZCDI5n85K4x/HF0rzOaCaKLCSCnHFjl6FYktmZMvTBv5g15Nm6aoPbxbbIyXctZ6Jl2pvnpL87aWm0juhpuIw3dnMHNvD3dzcisf5uW/kQEpvhpmJw0vOpKdyN/FFW2D65JMqOKu3pHZ9IwgCvYPa933x5J4/ouLdqMdPjsKb7YUdnj29+IuAwC7vniVogdjAT71aED+gLioTpLMWqwcG06fO3xsutD7Zz0N8DUzRftqXBLhywsF9Z9B0SoB64L1q2IVTAfzuyZmqOFULPZ8JQoYoPOXlpUIzKxrp8U6hspot9Oagqd7RuN24i71RkRzFF6rbEi3U2BRz7EXUXksKvL6AXVXCk5ayif+yYsb1/Zq6u6UgiKZ8vOOxHaKEk8nwpqHZ3jnCZG8uWuidU1ej1MN5MVB9xFM/EsI30EjGZ9ibWB8DLpbNbY0CVlt66AzG8GESZc5fcmDsxWs7eXtvIGYWlgkpbHrYf+fmmAzh0RSGl0PCvJ8oQTH6HHssDH7q/aqXDz76+kwflpVbrPtskMKl2xabz3P8ppJRs8nDaZCqGQuT4zzkP5c4zzg1N/AW7m5ZYqs81epW7Xblleni7drB8fXm+qHrHS4sATyPpDeQmo6lR8Ljacxqxy/2iw/LHDnYj8qfsVHjN9zKeE0Skk/HsaNJRTT7H2uPTNMPg/NQ6Gx7kSlBLDWKKuulooam4Mw5sYvkWI6W3FqqNMr2X5lV+D9JwZ1IApCIH6ecJxn59NwWZe/EDGaYdVZ4+Yfuk7bUs9IUQpZp2zl+IP3dec2e1P268i3Y0pyyX1zH2ftk/3l+Quzn5TwpHD5/r8nRCoOWw4pxVlCWVp8eFyCpwS0VKGDyYsWAvNFgNteqBe/ZK8PYURlqinCOY6EruEVdvDdAX7F0dY1J5ZNtlBR63J0gZtz87fo7/tbC1FnRn404pZhM9D7YWEwN1iRgROWZsTOl++DBCKH9LChbX3sbzUhyp0YglJ5Cv6F8dFSSSp6Zr9Xli5sc+vaDxzOTFT+Slmjq7pXZg0vqZpDqHYEPKgg3kheMygnG0DwDu2qlHntTHXXzwpwcY6FYom008LIy4zLSkaF757+rHBmsrhwfw1d3FOkxYAEA/9TVdi5RUmyz7/qXfwT82KHxZ55fjKCXN/HR9BgjgSv6/2PCm/x/njsW/omLW9VRAuuMGXjKLEkj1SwjhUvT/4Fb70yXxw92e4Scu5Ef+s5yEXldLYzfnvZNyGyL/NKkR4Fdj7fn748M8sKmriOLU5BLKNTftsZM7gqlVZfxrF5zbPcPlGhQiizEKzAXP5TgaZm4/7QA2p5YpJRGeL0tvhsTDg/rwyZJhnaKPvSAr/ZJpxrYq9TNPMjp8cZvPrC2xLTqLi//FGWwNzsB1x5xuaTkvvyX6ayK1nlU5gr8RuGyiPcelH/6gnDy+lvniDoCUfxplLykrJac6HWKSvT/LCS5uknL/qDKJ0QGXxFQWr38JtniwB4in8ALUBQf8HoLgdGLSALVCWlsEzE3bm6mZ59uN8/5jgisQBy6X3BS8yoMvHwqK0HFoSbTJdlUTmosD2v6wX2g80+Bb7g+7NhpUQg0kj60Rha3LO2bQkH1k8lfZXjC+9c38THOrgZRz1jBbtjeqmn+/tFB63MF2OIPLFaeIyqfYaEbvb1MmpSc/vviU7RAVoN3u08bwgpyaLfVUif4c1YyhiU3Jn/0Q+5uoN8JmN3bIFUVAxA447LPZQWvnDURe/jK2V4PEKhcKBIMD5T1FzwmNmvintIF4/CKgc1aodv4Q913BiDoJ9TwkPW7B7CIHCoy/Vf/yzHJ9xL/EZlB7WWmM7e+FSEeYdVOu4oIYVmEDNckF54g1lHmCCMlnGZHh4eCFWCkf5QmvH51Yi9iSic6fUpv96BzLbuaZwwtDNi6C6n3Pr+oeXyvaLw+MMm4DkIyfUXlwtT1XGjQ2TXgjA7aIeFnYB1nEiJn1kREIbyQ8HDQR3OM9zq2dOlXy6UR2Oxrp0RYOiLW8kjUjFTn/3NeSemGdI0ivXsvi86iAHKIPry1PbZRO6Fu0HByQuwnAo869Tyz3H86isu9dzH1uved/6KwBAqEbRr0jo5y9U6CFIWEeONMXGfEC68htbnAwTbXiQt3V5CVkbtIvfv8JEGB+KS01kJixfJ8UP6HHS9a99OQj7pdUi6bP76l4uYRTneMaPX+lYF7a8sg2PyQ8P71ryzefdXM8Na9qdHdvf7R2esLi7M7CvaZ1zLtpj76K/UdyO37eVFyzlweoWe1Z3d9rmWlsT6bEX90SeHpSJLf2prkj3KHK6SfNSod95U7syvkYrnRINE7NM2nxl89jNJNNTo0h6WROKlpSVEstl1M9JVc17krq7vrcxMrQ71w38lqxObvkqhvQDlfd+RcI//k48fjtjBur4iDGaB0O5oncgcUdj04jrZ4Y45Fq20kNfjvKFIQJy9wzVzvuxjTsL9o5VWIAqkoreM64ORXednel8wRy6WYy+OW8Q/8lYlbHLC/iurK5OSMhgca7CuUlPmVG/G9iTiquLRsT/tyPkxRuZjCwyb0bAm+FDWZg3p63fWoI7Otok0UX0a19IptrQvphHd3A6VeRw3E32woY1J4VRgrApufLkcSeY6lfbhsWmJvW3gYSKLA5WXEmsuginx5N3PmWfO2sEN5H3gkfzbg1LDr2kLK8hdPogrI5GuA2j8pLsQI466yWQ/a7UDGugr9XyIpBBoncf+J5dSBi5Qn3zQEH2eN//10ceSvmYyT15bVUqk/QK789eZ+k95f97XLV9ri0jYL0KFd8xuwrfDhUVX4gt+pbyqRnjM1hdOh8L9c5Qd91KuF8Yyq+X9w5totmZpFitQV01jZcFewvlTQNbIzut6z21kKIczpcro/n8U6/vorootzfwT0XeFMMkMJb7xcyxMLMwBHPkaFVlohGJmkabSV7cIRVWBReFXhzsF6V12hq2th8ZYtRcVbtxQXzmyFNb24U1p4YV/w0UPnLh09yUVI6p8FRF7+KCTt05idB/PGS5o4+IOCI3PGJl9SElpi6713vapqcwtACOk+VxDGrxP3GQ5qG7kEHZZb8lLjAot1n7kaWMz7AUzBZjF+sfx/McKKq+lgllvo5EojhzZ519un3FRHmvfbXp66d3YlwOVbjOVDg5cgs/3saAkBb0w11ASU7ZuG4W+s1RFiii5NwMyoMf0xtqLjeEK/7IovxEJzoYQYOZTSCh7TUm4gz7jM2uahmcfeQzOYHZmmzFx4MGGS8CLJRbI0fudrnXp2Q2P44PZUaZPF+FygCfAvd6rstqYPFVm5jjHdzfa1yAHTCbL4IK54Vt57f6uyxj+l2hjbn46crXwfXONp35aqCegvahdGqlNbe7a2qio8TBVsjslGIRvsPK6hUujinlvhPJgzWVLPJU7xj86blKGGDuf03r1eU7m1WZ07cjkzSFAjGTBO6hq5eA2BC5TvpVmtNLq1nE63ldN8FlxIdgDjD5b/HwzJDdyqfvNtG4wTVeuS+AsXJLFnbe8k36sBLD0Bg1U3UOUza4DCj1sAt5IOiS1s0EO3UKjZVVjZ3AoSNbeWHvp2RU7fVZhMQKe/xd/UfTDvq0+NJJnZzWpXb7aoqHdcv3YeegtATMUmtunuG+08Fq+yvdF36FB+793NKoC3baua4L887suwlLvQzhkrOExLuXhfx1Gprt3ZZCAzuR/IQLUfKX0qUbeujPUIJXn4pfKvo4mdGvG1Ep21b3I/gDmslmu7SOp+G3jVWPf4BoJ6k5mxkdSwlT4rSR4fLm0wBjZGahHiPAPGFrF5dGw2lLt36hbI4dWQZUaLyY7WpUl81aF37u4UyIDVn+6GwLKVD7ZfH19HVt/JV10tvJEcPX85sHHmaa9M7wZxbBNDYWkqYRmHLe1TKhOH2ytLhgeLZr52M49Jd/adWHGpNwyfr8vS1PY0pO3LCnXB1ckl1CSgDK7ykkz5lbjBcGVhjNw0Vlmp2pwfs07wQwKqch6llhyA6jvcKhjjcoRgvY30G2z8c3L2Mep83/BAHPlm9XVmT5hs9R9SeBHV6LBV8liuX7o73ficcBX0+tzKPRSsTzWI0UXK/WW9M9k2T5PuXhcKDDw0KYeBZrPNDZVVPb+dN781eZlFBAXfOHXr+ox5aJaIp6ORWXDTc9PKQtv0eK6jrz/q32A3oTI9KUwckBQhZWchVJnVAXs7h8/1zqpd433sqZdjzZ1HxSc5km62Bm7yA7OSpAjGZPrdfOCs8+3HGm+1PtrMMdvNY20aSzxSW/u5s83YLPiwaapsqDVw5V3g1nM/7khsfKP66wh+fVhyRFJ4I1vryEjiepXjc2frcb3hTdm1BDINTxJLj279uK3j2VKxNioxFJEuz1Wx9eUtw3KjrnovpvjKvuu8f7w73zFLr0wBPHaGKqc8/jNkXaItyj5/CjoUE6EaFvdl/PwKIuGHHP3gAxfYOKztIHYsRx75Q2pgY1rf4QROksp2KyzXmpC8/UDE0E1ZzxlUN5j3WuSlHBiKQdj8/oY8ITDeujTRXssrOEOfBp/bov/wcm/3w5fSpM3vH8iT/n14xkNn3cX1xO+N0cbDaR3fvPOtHwH9QPL95sSPxFzUfe1bN+z3pV/9kN/XUrFX/XSZ1/z4sgotT32Ny4ghiadC6A/WMR/7fQZZnvjKRxksj33D9q2sgb+E+21uuXq7A1D+24v+kbZHog9gG8thH0mHiAOTTFUoKAaai0sgg64HcnGb3/8DnLe5jZvyo5t9QzAMPzWJLsqSMDqibplJ1fkAs9ln60kb5aI4BRGa3XC/ScPLJWx42O1fjUc/kNngLbZJ5NjWGORRpJzwgsV25uz3cX3d/v81uW4197L+xZo5wRwsbikOJwizV/Ncp4gni0iX18Ihs6WNm3MYofmU6WMcNszxJNTotsdVAW3Lyc71vu877c6e7FwcASU75+KnKo008fQtzc39xFbWZCWO3E2jdU0V5zMza416iZ3OENWa9MJKgDEmM8Z3Ln+br63Ar5J7sIbeNVWBpfTSGrqnOwEr3adEUvlflzCWCm0GyiNRnh4F5YE0GGQKypLTiqdkzAEsKcUdCR2TK1Vmx82JMB8qB8UrteKqYlGqsliaKlURrm/sqQI+y7ZnMDGyTEw25rdy+eriXn2Mj5GwFDQZ2Tn+Vl+sbYw50HQXw2vvkr5lrp0lRMIhSlyzLcmVQra2GIlsTs1GaONkMlBysr5Ijd1vN8EKE/2FteaLXCiKfpIu7veZysb82p40+0nz+2uHYcMvu1fuNSYxo7sSMuSXxW66tLpU/Nnn30igVVCgStvJQXyuGNhTBdXjqahsQISkDfEkdXAQ4SDCOiwrg7gcUmxPQo5hpEEHbRhA3o1gjWdyeSlSiULqyCWFiiRCLr9gG1Ri2FobcCGgNmDnIMioWXRBVOsEMmz65CbikutOHOzJVtbouDA4bhtuwzGShQF4LRmAHAcDLXNaFPrWcYTw8JYuVfjcVSkUhYaL5gEN13FfJU8JHgi4QWWsCmlLg+O9NKg0KYGpyHLYUp4Dvs4VSYADuUin+ehJhbHj0LtnrQ74W9BNS+d/cluIbOi+uzmsoCMcE4m55VBXg/YQtIG9CA1WeP6We3s/NBgo5WbJJbm6eH4LHt6qq7ZKO84MEPHAsLJS81Hg04SYsxVn5TTirxUvYw6ygRPVN3VektBNVSl1SXAVhgrLd55ySUIft5c0MKigWn2KOadSy2pr0HZbSe4rGGuCF6FgvoCl0HpELZrX8FD2h5Ex7N/3f1N+V1dUY4nY/xf3MftjD52tv3pHASAoatW8uQ8v9sMbfRhsbxt0GL81lFWjcfYwK4q7XtZq+9xqOsD25mZPhSlWlHCqB9TReaoH3hE5mpLFeiQEmdAXW6SSEnNTeel+dEKtCJYNM03V4WsaVid5ue5R/RodafaTlvcVt7ccrzruHM40FEEyQ2TNUGDpI1HoUieU51p5m5oGwB3KgfIW83CZuL3fwQo189r1Vm2DmlH5+/kwHja5MhvBjY+qnO7R0vjTw6ASamFy7pjMAA2R4Z2s13+7ppF7xaat94KJT/RxuGJjDogYxSWD28/izlKXZyaenD7H6gabD/ZgMpDXUfd/WTMK2GXe10iYbtEdADhR2KuVKxMIGOSZvPscypO2UZlMBfAS0/7iPdQ7IW3ruE7nyFtKNUDOVTdvOhlBRvjny/Qs+IKo+lxKRlKjDhFeJmHLcqGgc/9DC/dRWijezvTUoTWXaxCznNi5eUn91zaO6wMOe7/luUeXiHSCQMDIyG4sFI7yIDqmGVW+PrLcMLUlMXU0B/GFrQ/uiyq845dlQ8NZ2v3xnQgLa9jf4h6FEftoM3Bt8Wtbd7g/BkBebjoGaEGJn5foFxivqElic0ki0gImYJcD7t98q/ZUSOWyx3e1tKD/A2X3Ykrifxkpvlsve3L5mKJogmIZAL9RFBh1UFzLE7S/gew+IxNXKcEEKa/bebgN1H9whlcfOuRV7FbAIsQkQhx3pZ3PWCNOPqzCJXSavZ4GWbjZJqRG6LV0ZV0tMGrNRQ0aEsEBKvfnqi2pPfZRtq6W3ksTR7Pml7rnCNDu6u7a7vf7T+7r3+t5gC1pr24fLbxW9E/X+JtZ4x7sHtekfmbTjTwgp5NcyTxaR2eMNqPsZ522CWMABI2wLE5QxubVxcGjy5V8JRjq6apGFjSPPT1AXBMTEBFxScGaVosz9OUlCDi5aGVW8Mj5urfWIswArheCnk4z6kFGEpqn9nQMvh8tnYObk0f3CxUUZP45HJR4Go3mpGDMGqg1nh1hRW6vt6R/+DXwfm3AB7cCHtaEfPAeelus4YCT7nuu3uPcLz77KkjnvnSbcnqfOwxbFWv483OduP3E5YbFvvYDfxRM+tqrPmLNsdkA09yM+CO5wFNLztjZprpEYTczngazu0oPewll+/gHtEcGm4Bx259HVWGF1SkrqarM0/nt0x7aC5whN3lmPXN+kFFYWTVwEGMUl65Ai+Lz9CUFiNzw5kh4WI1UpMrBiFUZmNgYU6lxa4mtfOJWqvQXp1POcEZFjU6E/pjQtSjMXvL/1Qw9YisKmvRz0rW8yad58Ke5XaPez/Nhz/Mnn+fDn+cXpbZ/w2rFXKsNE5q/87h0WL5UMjiWcdcKmsWHEDFw6qs9SAMCHer9rY/YLwkrDYXBo4kX67X7AxjRP8uP4UbNHxuaDTs7AqolJqI6FfVXZdgM5miqwKZQ0sdjRQT9my61V+85b6nuKLr8pEV9I8+lOHbKaRWAck1MHc4tT6M7szuRfbKSrJWcilGEdEcFU0m1Uwdm+W+q5GmYlly2iIeDimMEYRA/cySjFIDGdDvHr6leG7QuDvkbbEykXhkRRfvFoJwd0GwpwwHBxoG9vRkzABJu2+m7jx/Pdhzz0h5lfP7Bhu1HnimFuVAMASZ1ZNRgqyV5wUl8iC4KwPh/rQiVG+aW4lOBb4Niabj4SfRq8rl8dE5LprqlmAQed+JomtruICiM8SsRE316SI0B9rVhpohHPgZfEYpuBbAfSJGKGPcyHwu7X/G+rpYSvM5knhTN9uCDCClboyZa0d8C+28Vq9qWOUuVg6BEyLyWxQ53oRpSG4lZPk9hoKGtVczcUPr+xnOesn7k5AaQf1+toGTwpywRr8X1Qua++wlCzZmsg0lP5tabflvdeSTM7L53febeQxo3B65wZUFzGtY+/olMd7nk/jl2U3bAIrfaSJ3bVvvV1ckcg2+OPqkoKTShL2VeUViRXdjgBtunN9sJC7foVrS6IyrdqlkncDbpzu6BPWEAG1cB2/AK/1mnsvvsNcux2y9Fbm9X5FK/xPLWpt4560nenBlcpEEQSHtUXfEidxGawfhqe7X3AYEnFxSWNBPtMGEbxegVlz32khNFuGe28oOco+lwxT1FroCtiUqVwoA7KoiHmClXza0JtWZCPQdpieKLnEKVeHhHZ+rqQ/6WyY5B+dyJwzDajPRwas8EwKg/V4bvckkfsE+KifxZXDH01/vkCoahzi94Dip3HQBB0atTlhrPeql51MZS27w6wm2O2/AaVHuaSioY3D6XcvHVxr+qE2syF4zcmaeuIW6XXZmfxxiK+yd12aB0H9rqXwMCg/RcJtamRBvDKcmNSfTM2NlqSpesHvhGVeVl1277QpG0MnEhL29XtQss1fi3r0GoqO1qjATUW4jmCHA4Fw3mxcsQRCc6fc+iW8aOqVjoDds6YyQ5Sp0NSkc2RsH3OVF2klXUXxDl9HG6FItqQi8X1w9bc1Il0MyFxSsLLPn5NcyOOtN9Z3I6gg5zTETmlkOnDYNV+22wb0OxXccp12TMpl1Xz6AVTSRyK3Ss1nr+ChOsuL5837ef7kkIUGLeT6w4E7a9fzBNEKPYJRl9XNTAoD6AqBRLTtyiSV8/7MsVr3lIcenDobDAvDup6A+nOuNq+DrOZuQzgxXG7sLofHDDATiszp39o1fS2RK4l/OXJm+owvNnUZ5SBUSxOiNDZQ5UqfbslXVsegOVCqECODzXjIkc2/jurawHVKd14Py9xAWFlcc9wxzwy9O+WA5AsDtvRuHFjVcCEZzOK6H4nbZtpbzmyyHN/PbLse3s5pvRKFn7TW7FZ9XUhSKvL2no969nGEpf4oGh88hP9nkK2gYzzt2aYsC/p/B9s/mWckY4dNDDEGf9ss9Os5CRNBHdYjC0nGI3YSbooIchjAlLrsHkdemW35CT4l03+r5X+9z+P1fSt+55dYnNL+BtUp9mbVtrH9tF5vtE0uG+Rgd8JoD4RMP29jXVArMcA1MqE0OZPmwV8XBFZmQKKiiK0HDye/HfZ8UsGow8MkrHWPFJxJSHnZcJMhjhf0sDrxl20Dwqn1tfc5aX+z7lYrRT9jPanZ3hxsMlSG86eAtTqvY2lh3WFoRwMbYOhVHBamV4McvGURUc+rtRssWT9DVSuP2qOEasc4Wp9CEDDu8aZb2BC8YQ8b8JDG/u5ubiAv5M3F2woLa+M6Wsbq4lL3k1V+nwMXo+jXpoFOeKcIb4x+Tao20LYks1FR20Sg5LiVZnSCL48RVYBE2VtHsnDZxGRX0LeGzvBymQp/uUuckbYZym3kLZ/gG9oX6KEJ3uego/RXUJUSJ2fRmZLj6P3JLauvfMv1Rl5JaDVebdb/k2fa7l8XTo+W/2Q4f/2GcO0v87u7KbcPcD+0eHj+zDa0kfvv89q+W8E48qpch1XMpnoWgmYwiIZNcbwnRBOE00PjYUsb9NM0/8gz1YAclxJw09/sq+4wig/mG/uZzy/tu/hKrT15TpXK/XafcCpfxUZyTL0FddAb4u8qGlk5o8TAMqQjCDctE8IUTLidI2kt7F34k/9JLjpSOA2sNx1REQByD1lLf25tR3VuabnF1F1W39qaMl48vjaiikTK1oH8dUea8CUtDgQ0PjO6+grQXZ1XJ9m6W+eqxEkcmwqQ+hxIORbJ2eSpDBUSwJOnU3fCxltmNis/layglMbukA1/RP5CJ3BNvOxJyjnhu3b0KGjFhMdw332bEF66dOFFx4wd6XtRSyS/bndB+A+r5tmkqMd0lwgg1d8tMmbTjV67VqkmAYiV8bfivCsoZcqMoHUx24r3VJ8DTVYzXYffIBVDjBJQdA6qls7s5zdlTlWxwdNdWtvSr34Qk+vq6LC7djE5kINJmwk37urw8QE0/fjlf5B0K71/Hya3z3rhTvyWZxej72i5ZzGCw9Dj5JbELrmzogNZ09RQ/ttXfvGMcaAZHh1zUvPoUQ8DGq3zZOYHhOENBO/9isfLIJnA8EfhguMcBUXNXuzGkaie02c1iX1ZgdcJbHc5POJCq/CdaEZ+5k12oTqNzZDmyrLpX5fIsgrhO/7S2WtiwiU6AMzQ5Udo9cEsWffIJkZvPf3dVgJNdTAn9wQ789q6SnpoV4rBaiEtnol4F4WCeXyp2ETYa2RfPJNAxDXXnUripwPxGfVFHrWtZvAeVUwxvbaNMYy7uqHc7u5CeUjbUG0vq6idv1FI+t6YmFeCYZVnh8e74lzWilV0M+DweiK9NUOy67FnfRx6nFkbGFOY0QCOgvgt3iKiX1FX1baIV/WSji2/UA55u/cM4dBwinfPb/UdWuE0OCmy0x7+qPbESQuR78OJ+axCpm0NTrI8Y7LyluvV/tmvObQVWlORT3xiGBo3NVeCGQKp5b4kJOlWeefusFoPY9JtwemvCW5lT71YHAo+3WgJz1lQtRV3two1YbXImCGtrbshHtKSQin0oUg6EZnZXNjXnYivjXn6PJwEB5WDHHo6JijDVycOVT6PVrQX2DSjGOo8Qhg3rYdaW2mlJ4XRIWTyKnCsPE4Cj/jmD809Aly3UuSvRNnFpS3Gpob8uCVseK6WIqVgwh0WQ+X53w7HOURhaWypb1xuYU7hxa+iPsw6cr0DlAe9KPri3OzhKrpqpRBx4GvtYpI4QGdl1ZebUWUp1IJNDIaUHJdHONPQM4cyvI7Erws3NXkj/xlq6t7j3YiSWgLPQMvpw7rhsWdkVxeBf1IS0w4Qf2AxtDoV19+d3oSVKlIEcuv6Gf+dDxriqnjGwInTt1oxyZ2TzRaFbHY5gLwflocZ8Zs6RKad55q6rEXNZ70ELHoAoSxYzm217kzIu02z+Lezvza9rHaotXaukFcFZyQVjSCHbhY8689ryq5hHce8ap01UUJzEwhLqUkDLnBF7y0q9U7PhI+bHHqLIdeWllzpZm4ooGNT0KrCvcNb+7pSN8gb0uiRt2RjlPTE/YL7hIaUnrJtRriXP84snbqN4/z0+UhsLf5z0UJDsALPQvzuWafkz+909mBeOWainqbvdNev85u9QsIyNiOS9XimnTBxPzK2UcdHqtiLDV+8Xq0khz9w/eS3oOPBMHGbM3TUJyiwsQ5c01qspOd82IQ/1qYRIUnIl4NiEdtVzfTDyBgCYd84vdyojizKMg/dhEfYhEEbSSDd80Jk6c1Ngz7fvRIcMl7eSpsL0rCTQO9W1m8kntnaucnx+1+qVcOtOalLj5kKBIucct89jvzP9cekb/tUTtKr/6Az8bDnGUavLE0n7O0dHjstyfGr5xK99rjbveUi5MLtzoaCuROqRzq3O7ExPMW7WTyq1Jq+17H5XzW8sHXsLzTaAAWXDI+Te7c6tfXh71cjRr6imxg4uemi8a3pmXr+9syT/4Gc8LcitOIwciXvfml7Dv27FB5HymFgDqbr3a0EOuzvWZ2MesqRnprd7QSF15bZTjjOkP3fjy6qhXVsz0iIs49P7rWwMrALPn4BepTLQl+QoAMAXssBjY2VOzlq3bdRMjMrOzraPGX0kv+T7sw23LaQxMXckQlTl+VJURdOnN3szmr2cHXam1enjfHKwBuvgpz5N0Btp56bRDmGWvZXD54kJMDGxqe3tV9Whf9TrNa7KgLpyRwTTiKtA5/MMDikP45mFpriE00ZR96jILTZPbLaZt9NruHZVd4wFHH4r/x3n28JMxAmorePzog64ww+7/T+Teub+vpa6SpqcBwW554EDJB9dzKj9lI858wmtlL+jTzRDlp7lcU+x2vyrenc1FOcT8ULUpsmlMxe0trPP2o6hPT6L60P+2AON2v0Xqa8KAc/A5Z3rhZiYkeds1z+ZCgnilP/xuYsm4UxpfIPjbALAb951sF1RhEfhFZo+h+cjwsap3b61jT+J6ItDcYBk+GDU6ncNLu31QshEwK+LaYZ8hC+nYDbTxQUrP3LfYwdubEOBhGZvubW40uLe12Df538PnB9javOAV3zJGifuRo5oagG7R7jlH+t91l3fY3tFeQ9YvO6W7bBOPaU8oYnI0e3Zm4wg/l2hLgGZ03WaFi6l3SLDsyPH3qhOyFMZ7Qh/IbPRyre+f+juVE9ebNNkXmH3jKG3SEZdmKi53cfklBSvvctDFX+3jvykvsPl2aVxuQ047RuDicrDiZtltuql2RgP8OOwRMNnL1SsNjCpnfFTm41sAjrNcrqk+yIchV1rnF+t1jfbdjsnd0YbkAi2GjIK3jsveHFsQPC6X4YEo9i72Z7WmbqI4+E1ezpjUxloV/+2LryfcOxPiRFI8g/bjhMQrQFeVaGAcGGzfzC5q9bkC4LC9ItDmY4l1iUVVgOunDDxycKHvJqKr/os7KnktpYvcv3u94pzxX+OvUvhelVNyP+82y91e9SUZMF7NlTn8aOfG7078tZegEyGlipkHZr/+r7z0B/q5Ypy5ratGRzgxJYWEBMj1emwMHZVSELPPZdziP9L7qlPlB0fo/Ub/LnyqUdx7Sf7mZnwdOFpF+u//jiVZb+eDwB32wzNa/tHJftn22/M3T4t2qbM7tXRZMOylwHgEM/I/pXzXzYGzlUwLHHUhy8tK2Nhy4GvFJMSbpfghcCaAUMYGhwAYkrB0tkQE8BeHZXexDYvh3LIJWJSxFy2zDuwf4n6ClIO3uSkff+AVQHFgDjVubYKNntLvl5hDjdNyrr7gIbwCorDvn/+RtPmZX/rxCYzr+M/mvAIcGt1vaencnVnq3lHhlTLvs/3vstgTjJRDozUMjF5b9ELNvbNJJZvCKCXHlNHjszJuERtY9MHDUsQtbQ2oOuVKmtS0O8XmJh28IgnX98E59InYM6CpsEUnhezx5XteZZ7Oi2GS1bsdW4IC7rlvDsD1PI+rKdidzxqo/Tk7b5D6Nr7bgfZ8MT/653PLv1rvmRfWalxiAX7QGT/Y/he/X7nLYb9krE77gxHkRxJx3ekl2dFMYELZwZrO5tX83C9Z5856X5k3UxxvAKZXHc9D3Xt/AfDtr1+XXQZmwpu04PWKzdHDCnTtztwSzXgWcubW4ijtFgZBWt+cJu7ijhUD6XQYhShlJnifIFNpgK0LD/dZLJebea2jYuAgIiIWluVZPmK1WcYV+2LEyc29LSXtUAVS0WNvOYgNiQRvNbROlcOgI3p3bzZRltbQ2igPTw05S45chwk7TSZsaL9wjhS9Bx16C6KvL17YSxEWIc8phIMnLpw7U+d26ogHBhYatog57UtUMHv7SVF70eFriVEb3PdKRK7DhN6kOH2CS2lSc7gMORpHVHC5RCUDRdNwOMwlLoYs4/NJ8sWrQoLNZigxaAFPQLNQuRm6HIuMlC8iho2kl1BplJvFIag+XbS/DOFu6HkkJRMbjgoMcKD4v5TbHiflBC/wb25oNY6TO3zTpUjIDe2mvWJMFbZK5Oy1rEd4t1JbxTus3Tt87Fg7WONoobaIg+CZ1WdFLbCNFtcmEAka3HzLdYGmPdSZsgjck/3e0BEQYW+Alu6/Y1steeaVPA8+ioD9Dot5AeAC3fXe7Ue8sDR5a/7YQszCWMypp7ic9kGPsm7K7ywaSDJ6G3qOt5W1X8eld4iHnGa/njjoO8/UV7/1M+t09vr3whuG+PECWYaE0GPR7SDa8B8lNoBHfhYtd/EV6guVO+hTnrijDBJtismFnRI8v0nY5WmklFUcmhWkVKDZ1sLYLdiQYrW/rh5RFEv+lv8RCIZ/bZXcLDQ5UnsF7janbhXg6l3Bd31cwgB726NY+FB7yr5fd5blft9tnVdX7To/AdJxb8J6RH/q40dUj7qsOvH6+NK2M4YXxHmXTsGu17YwiMXNl9axc6XMv013+P+faavUvTjhv9LKYmGgcw+JoSPi8WnQKesX3L+2tqme8cpXO1R9cpalqkxQ0l+N7aI2vlWRId7cjCzrFqUslWNaZUanWSbpKUdNSxuvlY0e3ptuyClMaAS4UFcwZmZbonuFh5yF106S6L/BvE/Ri28Fpy8/PuZf/nBFhoHa6rMLojn/uyfHXGsMbQwef7B0xZDkV3IlrL3tcxbvmE/nw7aNRzEGs0u6lOmjkm3V6HSjIcvJ2lQ0YzZSocV84+Hs9eketZb1B3ff/C/6fGJD7ez0Jk9yhCH9YwCSkdd5PYioAlUIqrCQFRsLvbIrbictrpMQfHp36Ohiic7Wj0ivr/uCwGl1mTkVOxbMTeuEHujRj6RhlCXcBcqnI4EjOVDiMR13nvrJKI7m+wEDUCydzCtKhYQ2yfLbVJofZEMkuAPYPeJ9/dupu3OtgZezCoBgqp/telnihgMgOZ84j2FTYwPdTtFSPL+jFdX+2+2SfixIU+RbXhwsxQbTQv8+MM+Ik23rb/lg9fw/1+iLGv62fHt3MspPnKuF+BK0v8JRcvgNn/W61uTJc9sPt4mQLw6LK6BzIx5e1g2nRaXJCdUr69E8f5O6u0jOeZTDFYSWxbGJ7sl7d+evJ5j0ylQRLuD+Zfw/i2DP35ZQ8TpfBDFPxLbZEzc0SO/ZQlJgbx5FwYR3RgGO2Iji/cmhFTaUqDqzkobojHp4y841MoLdRexw1x3YfoUcQ6RYaOq+EQIvV6cMvKpfc+j/AFp5bdU3mtjOH+AqwGPPTGWEcG4tueQYYJkaq8Kb2OLzLt9aKKemiOCSPunUX4z/33d1BksJzUzbIRn8IffdHJew/lrq9KGVqZxpM2NuAZAtxwR6QbH9qHbNjra4NpEz/4q5PMtYlMsA5N+888t3lwaQjfVtnQu/AJ6Y13H8wF3jeyMnZSVvAuOtx9epA+oswwZw5g6XH5vT/MYTg2WbZiavo9/kL8xvrvRLHbO8cOyxe+oema9+f5J51gk3HH2IUyiaXry0UT/m7nSr7UR3JuhaSsUNi+ELCZllt+UCGBJqZCOBUjY0LOdVD8/RKR2v6dOu/T+Lfn5VQje+H+vTeJ2VIY3XprsPKTXYitUmo0A2PK68Yfvv4OlxPaS+v+ht5ttYj7yhWfExVa4p5W8nQ4SyFxd0MLq+FNrALKs7/DwE9zTybybjz7MVDIg0P9WSjZslrdJbjJg2Vk1Pe5kUPg0EsZeIxMEy4D/2aeovnVIwGRd4PDjNn5rACaH6U5Oa1rxlWdedC/XRe9iF+RNbY/KIsf/wLfO1bhEvoM+8iHjF5TTQ5ue9+jLlikp1/6zM8YFfwnqmRb2HlPmffrt6dUtC7oOzPKcLfvFbjvDntXvQ796nD23+Ffx/21D2dx/DOj5fV2h+YXVVD7Na+yS3NndtOdOaHIYz/AXVakPLX159dGy5mb57J4Ky+cuqhXDvw81v7n2J4LO7malvpXpkdJlq1KU6qZQZE5Meq5WqSqk1GV0xRQfi/rbyiQ1OYKG1uYKU0hyBc46XkkeR+PyOivPyrvyNx3uo7jT7jK7ySzMmVvXhfLcQ1V2Rp4pFHMKS4Is/qqfLdWq3E4X6025xxeWLC6m27dMvXrWcXU67hbm8kuntL+a5l5fYF0h5fSL3/KLjJ5PV26wFEd5ws2lwyJ8pmzdE8a3J8q4PmtQbNpfNyPNWlUqzSjoLOVDnE+oeNaPinp97f2SbQkaWLgiikuNyxeSlFjBq/3v7YUGRxtUSOnWg35+DXHOqTj9Cxv3gux5Jow32+XEkS6URfGuyrPuDFpNKInfcyOePMxgDDMThpPoHzeURT3jaDszCIrWzorikuJyWyUOkxt/7oJxIy6Si/swcyuZFidr0PVR66GcXmGn27RPPXrdy5RXNLUB0KreTxfoTbvHFtoXF1PLt089e0ZupytGyP7MVGk66JYjy+nNI0KPJjfcby2M4yZGJq41S1iCLNthwmcFQdn7crFq3H0RnDgz4MqTzhl3vW913EG6uIi+KVcms5KjS1eKmi1PfYOrsnKbpJzDVNSVrgEnrZ0qMi9dwas77LehoTnJkyuoSCbePRR2iIOsuhSSLuz9sVqvfaMdgDIz5CniTBo/3rP4vU5+6g45LYqXE6qYkdObAoG+0g0ktbZ5+UKL2QubbT2cOM+SW+YhdzBsXTsT0P5jTNgArFF8AnNMFRhfbNCg+uMbDBeB42SnQR0zxFZ0PjyUL7lld7hLH3gmnLOi5r0ILrmt/eCBW/MCUunDVng2n9uLV8WTxXf0P5wH2Cpt2fRFC5/F9txxwzRWGOWWBCZl0bA82VyJB329kN70Y2Y+qEaaRLnJNEsITF+D7d4UkEqiZmwcVjbTwVhHmFGpUijywAJMVKkoQzn9z8y4WdJU4X5xGJROV0XicK5h0lJNOlasTpdD85FZ2JhPyOsCf4eC/37dgLhG2iO8MxkRYfXkh2YkR8gqHzM8tkYwMTzDzsOGGQlx3LCmmL6iO9aDf9Ztojj77xxHLeZvx6Ox16iFmWG+ukgogteMmHQIaEKMMADCl2iQZNIfX5SQm6RzkukmD8fBG94frVRAzlYmsLCOORFNXY3qx3aXowCRJrBWBMUT0aFxDv5wCiSaoqlJpxhSTFA9wWHl1QEpOF4npjJ01IgI6OHWRRhW9IY1SgwoL+ZOiQc2TMP4JSHU8ITyDrSR+iVBTMnHaGLhfbaudYf9i5v1eaVidsgORY2ZEXLlhUopjRGQkh5GtTYLIbGNQvhJD48CCZOmQmjC4vCbMQa+VpYeacjDPZCcTGrTkoozkZvhgEzN/553ojKoIb5opNyamVpbgjW8sk4V8R5V5B57CkEZ+b6Ut7LBN+H9KIfSUj8xbxOYXQByGxGKTyl2jW3tP4pGaTYowj+WW2uL/6eZfyzVvcxTprSdD3J3+VzmyjCaPM4uO1s6GnReeddz1XzbuP23yb3QvdfR39GJ2nhCKQrd7Oz1rnVscauPSamhW1/vip+iX0PWNqYqr5QQC+UI4AT0DXQKPlkRvhJMSCk54qH0dB1xvofDfbty6ILtYLINUQOqtTd4Rz54thbyD13ZPD7EcYkTlkgyev3a5R8R2uKQ4WYC1aj3+aXopvMNSkDCrmBoBEoMifboU26ND09y/jomJMgeVItjcnBhRhJeJL48vh0L+9RX4afFJhIRYdh9NH92VeEAXKP3BK7RYkmgWcZm8/+l4MUtJeY0yRQP0SrEroDaB2wCgGqqS6TGJZjU9tI9XKRdhIbjIsFYcOgSUTx2yZoZrJnA+SSFmpMQHwRT5j8hVhByuf/feLQ77KegGL5OHFCx2ktgb7eptPWygb5Axrgft0u0PgWrcy5C9lDWknjMHLs8q3Z/jtsz+tsf9jdn6XYu3JDZwXYT3s1HHTbFMXx4U0NUkCXa6hvwutv73a/FC9bqSAploCi52oJacuS6UuE3mWgFE0xpGYAyjOj3q82SpYrExgRaZblKD4+2RIkM+WmksTtMNh5AgTCeJdhvYvRc9yznxl7Ucbc7psgOIOEJu1MHtEgi/ZKy8BR+QSjF6umCm0azusZVqmJWg5YnCqly1Qu1xZlr43yXVldWna5ffJ5O/Cyu7ui04eS+wMrqPKUKJMEZoiDFvYvk+J0UJnzARxMiI9A8hKiIn+AR3p1aGlpnjcmu0Hiz3lCWAENDWISn/I8Ru91px8hLQ/kVNydvu9NrdhAB2iJS3jKezhxtRfeO1gFeIu8/79sGnC4KEeBEsai0VHVAogjkUfEMDMMfV61A6wHIEjSizzJVQb8rWz4HSupshI46lrNcbX9ona64NGiS/ySOHj6i7tWjHl8zZ8M640EA+9XPbAhaZhDQ/fRIz02TFJ9gSf7RYOPUHITrcAt8i55R3pGhzXh1y8DXOfMKTZUquHnrud4eoZialg3kQaODM80a7YGmVQH/+AI6TOKx81Z+qbRWfh7UK/L/f/lsWBzpJkTl7lP4VE6b4DpKRszgqTh4CmcLmGlQt2yGaHt+ASk3UN95OZQejTNyjRqwTavK5/Bt0wr0r9UaFDwBiQYlOGO3zpC1l95jJz0Cuqf6i3Tupq2dDkaA2lwAh+RxJ8eyP4eYRvlDa4sIRgvBjmsZkvgCpgLR7SmOsNCUNx3/Z4CeKGLGdtzmmwcMMR+vjcgETOcIiHSCn+qCSIihWLWaQYjKnuUym5RtVcg2zbMwpV6MGoLoGq98X/Dva77ar/lda72RW1oGkt1Z7iJFzfKbRoW6yvbLdpJUSQaAJwl2AK8VQlseM5GG7nRJ8Htxtep2JhbURxiqnzNse7TLluiEjmsfM8YFKPa9sOgE7inpf/6RkU2YA22iAHBfO6VwOLg1e6kzudhxHOxNlVktRqwM4QE5JCpZYA9qumPyGZ6EJ10rDn3at7kXWrnJBvCOUObSQ743b3O1ubbPGdNKjl/NhLGi164iAwqc5XCBwBcdBKDOufe5Bwo0qQw5HBYJ6oAJJuvGSoKKm6PfSW1UzmFsBIwLQ7HVltNKW/YbUqWjgRlTnFHTITR35eSQ9FM4NBXuhdN5Gcjg0J/IQVHBfKSThI7E02dlqLd3RUL9omy2pQY7ekeySUWXZxbessytsYbd2YXGmDXHif263q/NhAiEocwos1TsaQ9Hn/Imeha8eU6Y88R6wI70CZDx+cb01tRrAUTEPNzLezYE4wpvcMKAq2mRh/UE4oFAjeIi0PcO9PUsElLW+ezR8DcGniKUvFTwqOXMNxZdkzm+eIe1pClsKSu74fqr/J3yyIiJuQEpaVl5BUUlNv9Z3o9Dx4/3Ly93TXq1UPqAEoOgIz7xt0mxompcaf/HX3KMed+gYAfN7yl2G9ffAmCKiEcNU9Bh2t/1N2D7ao8Gu7MyYfwZH1YOA382LXM3+/xG5iQg9TtNLwzQ21hzGvIAvn+e5lJdOcImjde1U8+BnHA11Fvwk8eBinucFHubN7UYnTxof7Qfeiy0n7z1d7tpFxGByuIy1pR1n9vI5Oo+OQ9/1A3HLw/+q23ZVyPfYMGiRReyrkt6bhksICVt9ppp6PM30+c4EBLlRqV77mgq5g4UTifoNJdtEj8WkU2IlvvdRiB5pivKnSE23Z170UjiZuR600v3pFH3K9fZ589SpRWFSF6adNb5ck4/z1hdGgQRvOr3e0O9M+cxAQMR+BHFG1dbNPn0mEyZuMmnVDPhst7r5okV7yoMpyUOBgy6Yayxa8GO4fKHjSniNycTMteu+w+QnLTY+rpt5FaAEOc8yL9yBtvnC8Fo54GLLvAgHnGyZ+asDhARTeM7CXlVdMfdx4KaZ5pjbNexD4K600S3uIU5Sp+shsHkDBPWYTSAFBafQzgFbUG5ZSDpUIKgw4JIc+9r6Kd2M5o1U0FgsB0uT96RYWd01kh4CwzpAfQxH7wXFKWv6nOOsMEZKUVB4DlTwhG0fZOgai8QSHaElBsc4avNzkO0B+XWpdW/m+Fs07HjYYRfg4JpuhpfBX49fwJzhSZ7i/nriNtkZe6PgJoTvP39XvSaOhc7WNxHp17MqHShCD4HIyfCUUyCma0/Z+G4EERQxjMCMD3nFt1uKKEvbEXBP1mj56j40kbOMi7HTU63wEIOUqqdEBn4obVXro+KUMXo0Yl34G2RyHd6gpndhttHwHrPT+xzqrz/QAHdD6zAGMQ4HTy027F4vtlPrBT0N9HbdYN7KVHFNWqSIn0rWnpE1dkAFc63wrjMzAuDbGds4ixcAnya/LJY9ZcFnwxQpnpmC7z/mnsV6VTd1/6R0Zt06WOOX7nfrgvUybCgltfRPPsy7AcKzR+mSuqyccQ0V17zLtESX1FnVuXWzzyeF0Ru3QTAAghN31N5VkYVzf+8znSbvinKWVQTPr3TSYB628a6MmtCaffou6C0zR5cXzYxo3ka9wG+Cm/RORV0U2w3EY/KG9X0oI+GU/UoHQX7RqyucaYODMPRE6LCggvCJI9pfzi7I00avsf6xGEYWT+4Z1fCpqAvP7r+56zmtK6+vhfQWvNCnyWyXkjgVZTtlUkRvHkiTu6ytLCgbzpH0Ilcm5Zu9NMtnEh/Zvcn9feceEYjLcE53SZuLeyo+wIvNJWSicruteu1txtNrq3S/wYPw+xIA3sEvvtcQpy+F63h1n+bMpTGQ7PZIUPIDj4/MHGTTyFFJoaa/QUBXhOoHrjB7IHuwPFkSqIl86dDImvypyF3N7KSJxhSxYRvDTyP+Aw4rwsg1c+wVaUQ9SsOpTXVUckXnGbV1uum1itdNjet4c2TkI2U0aKBOT/PtwzX4FQo1hf+GBIIPki34uOua/MYUNR9XoCVqN71jdNyI6op+olfm6nFJjR09PscvkrmRcW9VkuVDdEwd53EUumTNdTgdlk6+iSPLiTJAs1fAhY5IsBQ1ffpOeBEtd+02xjRZmX21fiF58HGwVYLfV5QdFf2fFfWcCjmmotExepg/kAd2i3z4fjLo1v2Um9O/Paj0rEy7X+9h+6n3k/7kQa1jUis1/HjiF5IHvhO2SvA4qzydo93JwFSrfpoPdvp6Y5127ghlOxQp7702OoWYC4hlOJ5lIR4Tx6MTTtIcMt8qwY8ryk8q+hcr6nEVsqxoPzMGjaFCqe+H98P74f3wMIZEFgAwvZYCaGD0g0jCq1q8uo1Xh3hFx+srmGHMxtr6qPcTfHiOcOCr2UmWgLkQb9F5loIWe0KKhU2N+QV6qMttwFYJvl1R/lDRP1BRD/sqmYHxIA7gBV53gGn5gkTlAFdluNzyHvOX+VYJnmOVtzKd12DVvzKdr2G1tzPmjRhmItW7VJLl5CXKB6Bcnu4HQjdpiOmA1mmFm2md4mlV5WnC3rTGvTHYTG/ymt+A2XXirBlYgPpgAAACQMMsrY/Otx3/rOY0bSXx3P9hdcM5b0ovzVvKfhXiSb+PobB2rG++dvwjs7ZjPYMdP87nSYuveD/jK11r9VdPRfm4O/KgW/wYe+UPYw13jLX699jj5461PnqsEcUpjN8+FNVumQ8P/2huiffUlW4j1wT9h6u/TtVGvfucVX/oxlBmBRdPGRbc69wcGNebMt5o0vidY95kDjG2m8I/J1z5yQTDn06w+uKE48dMsF5OMPr546d+hsujDzf3yI7qwRXC5Jf3mEOVUr/lsYhJKdyghDjadXWc6C7UsEKkuVxJjTZxrOackqKlsqBGQux6VuGGEoYbSxhuMGE+6rjKH2XNPjeeMM6pOfqsow8aALc5ziKPbctYfnIFGwFg2wTxZ805JZU5K9NF4X+3IPxaxuiFj9Crc/OdsZ5nPTFkG6EqnqN8OdlI4flGilo+sLpavp32u/tXB7Fb7qn2wkeXQj+14ZS2XWrovfrPHm0e6RmzhUesNjIf/CLZb5sww/hLjuk5TO+3aOLTIthiUwDL2EOngXqNG/ohvRng2dBO9yB9kWjtZwVrO5RxkVgZ63gO+MTNdpUrQk8diDmdskWJ30iGT4n/Ouff5a528J4wdEVp/2TIB82LoW8woOHz8cw6ejTSsbsoX99Na0gyppanmCSxcnlLlc2A4AI0UZJI+3K5PU44hO/RJmJntn10FsVqmQGY5FJ+2hEAkiSLNwuKHYSipps29YZ2OXeD7jPr+X0m5ef4TkqTFhvSOjc30yB60+blbhzf/QFSa7vr5txpIHvrlkXAUSAlHSvCitgbOTfxGz/KdFY2nUbshm9uRWOZN+ySBRFmzG6n3EveDF5HS8Jp3woU318l4DRxo+3P83rqDP3rRoyPVi1pMokCD+gyCsAjd+iWeYZcjiWufq7+y0KU6/T8H4X9P/w14ERelQe8CS6Eg7eH87g5z/srwjFITw4kVK+yPSPRbOnNhjWKzxMlQQ/M/1sRSHDH4SRnMgO8yGO6c8co9oNQOB3OvzIIL7Ec6pQTPScoNZ767P/LseA2pGQWtCTarUZa7TQpCY50jJmYUGP5EQI+HHGmpdjUfH9RFZISzkPEqR/1GDRvII1h/9bb8F1cUDd0V/GdHwD6p4dkr/Oih/m4JZ7P9sGTZEnTJxJtDawCbx9JlnlnLDTsCRJpBYJNe3/ailfZpptkCyrWbqkgZ9jJ1dNsTuBZWx//5AFcIBxfWUWQauxbytMlpwKi1LVQjzTzER6qvUW+Ga5AvL8fQn14eWQNKG9iJ495/vUK5cC/EZlwRsmoUvkJvKWrLzTzblDqsBDydcuWIszUHN8+DKuntNLSfTmsmbr5MPw74cKQlrfYkZ97PqlcA5naPu8GN7pbM0r+AErRjaW2bHZ3n3NlFvIiIiLsg0+86ukl09DiJdeY1stfXve+fOdHPDlZ7Hu7UD3Gud15KHI7rpuPdPYDdwg8LClR6WbiGdO8d/XtuTJDkcbdAtbrZ5ad8GYUNcaGzNJnjF9LgHIfXfV+JTr5yuiyMM+9mQJp/Hsk7Md9yi0JqherBq2Ix7nr9Faj7q1l3bHNziGkxPoVgAV3dmUScujKDo0Q+JopAYgD+5QLj/1SSh7DtChSfldosR8O4YsMHVj5nWmxKs/M1WOwuWgkR/6ZVBAiKbtZRi8AIDEMb1q8R/RRDS8ETeFOGbdL8xn3iLWP9bSVccvU9WRkZtjTtwDKr8/wlEoz6nZWXBCXxGVxW1yNr9k7cylrcoPo5r5KeOBBax5fsuyK7GvbPuvCfpBrBtKwSO4k/5w+D8wvzmx0VmEb/DZQX2xkRFGirJFWXtKQaFs8EhNudLJ//iZKzbT1xkpFzs31IZo9fgOUUL0ujCjuTUismrW7KDoVLuP74XBYKsM1Dk+G2+XYRFZEfYuQWU1JPgcWdwoXIn/TauWWHm7U/A/bm6YYFJWuXxhbwcF1TuSElyC9b2qjCA9qpXJ/Keb+io+vRlEx8BzvbCkT7VNFBOdHY/sG9aLVbN+y8K1QtfgeOiJ5nciH3FKnBpdadVjnodDbpQ+pujrYwZWBQqrMkP9K4D2EQdutTgTMY97eL0I2LHerqcfrRZUpeHaoHTlTM1zwH1W93vXRHdyn64WJ9qY3ROzjx1U0qEX2z5TU6utb3hH98gpxaii3rt66vp4w30nuhlyO49bVW9cF8S2RagINpfcv5nhqXzme3su/mvRC5kupVvrITjDk0nmA3d0ECT0nk4g3lGxfbI+n5tDx9Oz4apJdzJdSrWWTgzCzhQZCLm8AmT9Aw48diNhmhxf/bjgj6+zeOV4sNyPfPOT3vb6kFQPLe2Rg6KAU86WyZo4XU4b5Ei+NbsAvsm04op8RR1P88m8VXVrHWkjWxDKRIlLDcsQKsVKsEqvjNXkJPS1/tsQiI374bx1rPFlFl9VxCk+tR5eLFWKlWCVWx2u2grJsavPVRMJuR6rx3Mp0+4kWTKL7l799kJJebTmUyy4nqbNBdP9SdnboqhQRlaqW9HUhKCXOD1AUqXBiuilZ9cVM7syJWcvOqZVZh/5adeSJBhwRt3uAOtwhErMRbhufP2Zud5Rkt0sD8u+337QXVa0lTq9La5Eg6P8XUDrn80e2ZAXGmXgpJrHz86NwF8pD+nI/+oudhpGpmA7FPG38PyN10LPGUV9so4Sp63L1JwBR58kVX5bdliSCaqBzs+2Cmsxlah4x0mO8+TmNo/BM1ErlDiHyAZ3RU9VWCEgEP2janJ2YfwMXLvgSIIjSJJc4j6UYbPDiFENrOC5ZxJzh0h1m60PeXNTBXPPwdvSVs2p1edsPseFoNq/7/2eDDs/u53A/XQYXftyBGR+3X2VBQhLtaoBxwB4xgRk8+s4zsZlmFxdTWa4wQWBI0Ay+24+y9Ju56WjetZlKbV8UP0W66rTHHj358JRnvOL1uye2v0nc2E+UuF/YBLkrQ67d2lBEcuVUkxydQrhEFj5lln1JfFlcbjnlrIDWDFQskGT/NB8U+lnIam/YWHuR1qL5LH7wNwjvTgjyWoLfSujcAVB/4SfZgCi+mhKUAfEi95meGgVCXZ3UQme73C0HV+TBMDTaZyww6LrAUuZ50s9d+jJrljR8SXkZMcJ1iJiHd3ks9H2Ejl2IRJCVhAIXLdfpIUxXztUxB8iYrwLlXbQvQB9Qm7PoA2pKQgy1/YthwlIlT48kpUg7GVGMpDu7kALEQjwxwob/5/CFbd8iZs59fU0y4W0UqKYuOh9zLkQq+nnJSshz7xcEx0SAL5tuWJHwkKPXgueHz8LzR8rLr6Lami4uRCFaLH084DmBO7HDtH2ZQVCICFRHox7C3pb3lUFBC87DvT1Jeb7z4elfoaNZn3ZAlOUJ8jX4PXAXipT7u5ACwkECq7AY4UIK4jf8ygQNOhUl3BNU1fpGYQVW89W5qwCyObNoVsug0cdwBkMEqpbCBYUAhSy8NjcbUEBm86ZTc4ctdrky8Oz5SuHJl++M0LxQiTHgQg9kxiZYIHYlwb1yD22x1nvKNkMVF2tO+muJCyjVOaKPfYw1JZDYAWCRAPbEcOfacbir4EEoLuM2fxwAnK0UV+7FYovu2XJVlKTP82Uw7fiNUJLO4AYAM4PBeiV2tV8U+TbXUf56Vm1DyUUH/Foi6TyAI7ik9vozc8niHPR6AgHIQIf3I6TYMo5FVoK59dCCEC/77OcKzp08o+OLLSuZQ5BMR2EL1vV5VPWqfAhno4ooIFEjD1tANqOns7/4sWUGl+3Rk8zM/JrL3ZhCLna5sg+iVhjiJAjfhjvZ93cj4VzsWGEH3O98Kz4jYgJcijMEwmlJrMulyZ8Ip77cZu0syKdE25N08SthAqOR7L+aQQ4yGu4XfCWXL4O3SuIW3x4YiDVx+ldkwtHXNLsAfkGN+bzEHfyqMywwgEzvG+/R5YNeoK4M5ui4OwyB4QEAaPDczXsNMPzyTSiJo93OVCSC2twMWccaPtbu/WcA7YnR6y8R+GzSEqWS2OZ51Y3tSNjJ/cWA/PculxspmztRq72EE53zdvIYKHlzZeFNsYUb5RZg+M8RpIH/m2gTlU8AYz3VvyAoiUa05JNufgSCovM+BcQQEVNAC85vJaJyeQuoHbJcus6ckwwgOj1V+L/U/PYJ0UJG6Scrtz7yD8RLREEIkKYeYLPouCc9sy+NKN6KUzvvZ9ilCEMifAjKpV9itn5ZzQ6QBBTTKr4UNJOO+ROXu9zlLnOZy2IWl1zqUhE45nTYcQBkbMQlN0SRncmZUOWCCy6I+QCaEwNC/FLcuF/OdtZI5W3/AmzY3AXVBzpVyJez2MC3VNvt3khH9i11raN9esjYFkeG7fexVtFUL8VPgOii4IBxJB7u81RXFq3oFFXwP0kkPIfBeW3LjD2EP9rJfR+DCaAaKHfFw2sJgf+edYGia8Xa4MwOh0jd/JMwjbp5Hn6CqVA6c0AzU5OkYhY3BFGZOcetoGioVShvyVjbiiRf+oyl0R5VN7bkeeWQUSFAbbvE81dudn21+WzItgC/1+0SxywpL2O/8BvlRNV0pd8/ACgPqzPBId2jr1Sz9ystCZsN6gmaSpalOxyYYSbcE6akZ2EV38WIiy3POTVrsifE7DQMFPj9c0P4SsCiw3bLi6EwjGdoXYimxG1d9HAQ9SRWdAC/UgbkwsGgDdaFno27JwMYwAAmzMh2pMcVPYbC9COmLyv65XPCFZV1UZus5+//XWWcvx4/0Y0Vuxf6rRUPen39PYqHjXIpe7+KU19CxWIoOFD7OdmFN2/vZ/B8/+ynUrW6BkptkU2rIPGtYF483OiYW3aqYA+v6L1eGGSS4ELO/wTxyW6hGnLBNM2CWs38HIIS5SrUa9BoXgtSEBWYv5Q/RFpFE8V9mfIjJdx3inPL/bx+MSdyxVc7QWnZ8Tq53nX9yxlj/jGbaJbCDb0pR8gT6UR53otuMo12K3n4rcqZN8uA5tCszG8sEEwHCWJ4UEcqIuJOXhsqBNPsAuD3pjGa4XwIBVvpsVAbPPrEHkTsxEi2+nDTKcY5zh91vJDIEOHTpOUXH0lHGqYhimZ5qrHHGWgq5vD3wnzzN3GPZsVZtYGr2zvMem34B0I7i+GX1L1aT8/21U7fCNOssLBhdjiseVyNdn26KNvAH3u073+Nv2t95sPn6DwhX9jyRegS4cXlA6ArFI1X/eN0alH5gPzH/D6XiKC4FJP6o6Ds+LP29p0UpERIdQsRUsf5EBeHHqif0EzkGaw8FvDNYeDOay4NPDe+JHADM6kLvIcEMtfPm/YCvPkCZYHP1C8Mc7QtrKS83Nu9ZxEeipCa16GA6HMe2jIGwAnA3I5TZ8R27ZA/UU3dYSfUX/0X11TQ2DaSluH/gmXWH3asTKfypPAT+G+r3Mer7FfwNi0T1E6QHlfUBW2j9NKFjYeukV+6utN391LjuuH/HAaWMb3PW7DhvWZHcsJfvl0Qn13KLxO+4wQcfUCdKQVxwYfSX0G8bIVrDsT2as4rOwzQ9WT7Mohb7g7Zj4TW/O/ln/y9aM5EDDBpuTS99B0XRI6nXnjoU2FwC6URrbUJB/NgJyKeTHvgicYhA2hRcZWv9YtmI/6n43Q499e2bK9XYXvMJ216wVwBTgaJnXahkBxK6aFWsrEaBgbMusNOSCboUNIQmBvSSGmZgwXqqbrzLxfYRXN4KmC4CJ9apwyLsn2RhuIVIpfXMJ7BtZobgZg0yx/hevXyW/Nh3kb2rT/nli+++eGnX36/ofT/Xpskg9frL/VFXXUXqZ+mlsa0YuLsAmi2d3lk32JdWxoYCvCTqwrA3o09uYi+Dm/9z0vobg3PCydFpqfS851fsr9lGc8JNFEgzQZ5JpkNARr6vNtmOqbuO1jDc7KVGIvqGRTTHhLcOYrieRbOlHbvOxhQKQ8G8sfZH7GmdhlXOX6wm5OX8jfJyDoOs6HIRNQMo9kyIDFIePH+J+bkVKPi0qukZfE/642wnDUitTdM9uEwo5G6+Xha9DusR5KiR1gOw1UVH8aDrNNP3UXdrNcbEXw95/r/rcea7qovkFhPb0XgD9HHKsF6cDeEumJQk8lmn/Uytxe4DTwHd4vxh7VtXwLGq14wpU7PuxJDlvrew6Ln2vzlPLyZwSn3ITOTXtO2fZmrElz1xx3JA0IiWeGJmqd4UONUpJP/UYUJb3O+loY0tPckXCvb/tG0sT1navPDh2ezh8Fr0W/KCXsG5hmsjKk/JDgBQYfvboVY9iBj+BmRqb05EVYuFqakQbvTrTUL1jFUI2ABD8qACwV0jq3oKNEvRYXWU5K1sNXxoRngjEh3RefGZLCCYSfD0yIlVsYLGYRrMmQ6I7fBiHXd2OUKxjkApFx8YPQkig0MZglDVQ0BRw6xPrC53lSRPL9NfVk1Xnx9tIBCiBOyQSasABcOhoMA3Jhy1lxGpoDRqTM2XXJKqmv9hMpBZ2rSzCL93n0HqFKkZUBEWPjCVQYeEmN/QaKgHjBk4cLEegkDoMesaDMGJMegjobx6w66IkC4MlwuQNfh73Ex2scVrihE5xiotoJ1jq0tKF18xGqnmNuFINNa2DWbaGE1gS1gWnfSClv4AoaBzmhRiGt1VgYmTrrsBkYm3YmTzsRJd2QyGJkMSQcEQHtywQGYKGctgIWe/UPBupJYme6DWNRlal55YRFOGVx9BYram2+AmPGPTM4j0wXWgceFHgAGSCxM1wWZqouK6b/eBXAKw4QBGgCAxqMBGiGMc5EF5v2LlfXmWtNpfWXqDC/UbTc14Yk9+wJc5dK+U6dsm0uvzRP6ZdBq3dmsIuSkOI0lYXrPG+A3YADDACAAfaGwwawNTrmp19d0Y4fe4xBoFNefbzjO+Ro4M3ZoRcPYNKPnZo7pp+RE6HKJbZyCTlyZkhvgfSB6ELJh4AaABgDeB6wDAeBC0pdOCuHLwzBR1KRzZDvSTjroIdexUw4aK6aEaC7bzQk8BGbKHZc53Uyua9cF0mFUYaJCw9O5CStTuGmABkd3WcowRTb2aYeeMgSWT9JzFPUwm3ppblTsss8G5VDExEnXrkQt5AHkCduRmIe7tgikjQKB+Q2UT3zorKlwh3hjazLQCw9IN2z4tsuXLuH5Bx9bIKw82t+fAhDC9Q7yiK3pAL8mZDS+/alPYmCznW6XpLM3+A6xk+qRKJlPgMoN65gzAvaGPUDr0TiFGkCYseLorpd6nBFJzjgTStgV9ivDf60kFXbZN4j3I5OuzIPLZNXpPOoDwzBlUBiAFcEF7SuWF8wfc7dTXzisfwERxer9+ppNHMtLcMib9WJS7XO+NUuw+1QYbzZaEBvcl/agdXJvtsSaJrhxmD3eDysIYbg9/CqERwjFyT3sdv35eAefX4lQENB7DCB8es5o7B5MoO4LblwMpRu0r0VLNKV7pGuzfNx3HlcQN1rsBzRG+hcGxOAzDK0HkEGC+G5WEtKPlKz8p66XLzbRyOE7uTHe9YaQt2EPAHwM32tfBbAfxPNmwJws7QNTZJLt2GWykqbq3hwStfichDoEYyw9revhsDEVsYjiVn0QZ2++dsScnkgkpEgKZIbsfPn6iAVGKQwGImAY8CWV8DmJRDVtvljw3NmlZC2TdVwFEIUXlTTlnV1KvyeZyS3rlrZR0mGA6wk1HgvJ9BhGfDi9DE7hbZ49po/8UtDJ+o/wT22YSQaPcoRcf0Hzs7T5MOZHk1E+h1i+c/0KON+9l0NP7nlSJz/ehj22X8alNngCMX5KZpho6/pc0JfH8pFI3Z4c2I6SW3soiZHZwL8OmTs4EH7hCD/8LyOY9QZR4zeoYtnzeo5qwneEjQ+r/nflTCuS+4nfdvKdkAc0vryXZOMf6Db3wLs+XxmLZ55mpTV7fWM83zm9r7Ckx4tI5AAb+QWnZLjhHoQvb778efzs9vfjTnNWxp1M2003W8GzGowQ4OYZAXBF+KZ2vbM7dq7kR3c+sNlekQmnO5rNDM5d4SqqW7Ej9daFjCU0vlPju2HdaW0U9IsU93qhYFA2Bwl799H7qWGHtc+74ze5aMahHwYSkU0cLjnUZZc8OQbZpcO7FvXq8d9B+4JjX9Y359z8Mrrx6PQvzyck4tuLu/zscYjTjddD4j8tBhDWaOLArgiAnFkCTHO7/B3xq6WQA3i3bBtsiURa25n/ZX5ELpYaBLS1rgtgjeD6E+cm+Gvxs4cXvXXp4MD4gutMM/bg+Wl05LebIsohf504/sFuw8uhaBJ+mdJ9LwMtTwGAGqP969ej///74xuLCDX5Fc7MR4cqH78KK9RK7cfpH9peBw9MyNsg/eeBfaXHApr8c7n3OIxbt7h/aPhybRwgYn8O9ByHCct289HC/DRytA+LyMwndfDNjCz/vefwngURfx4tuf3nT3oV4m93Gznqpc9mP97247Ed1/lpUPxti7O2086fStuSgMm/5v5l88DHbOUfHPR+tZ26cEjRh0R615ppgZ4o52fLYv8lE7nTmMWbFLowQO+/PndfTOdN+Xuke9JbTP5OCrHG/Tur8Zspenk5qp64QMeTJbCLl9dgMPyqseUFR5kb+BckjEfCdNSf9R5GDhsqLWn4ifFb+r/Qa4fGs4g5SiXOTJhXanoROMrwaO/ZP/Tz4O2T60v2rU+5vBD7f1e/P5oAcLudDte1Gdx4QrLcmWRg+4bKh+zBYZT/3ujftPiJrZbKQ60dDfwlaTu5PsRvmI65RhqfMMtrit8GQwHgTvcajXS/iqMZ46jt5cXwtr0fWoq2RqPTb6H2eJCZF4v1GqNT4/K7qAE7zbV4jYfOohk/x2NGur4z2fRaXin8nouE/bAf/Jl4exCfdb9GcgNkyHIDDGAdX/bJw1IcJimbUxROSzJi/ViNtm3NxhCz9df3X/zZiLrf0QkZ/7XnwmRTrUW9rzUmy0vCLyC19QQaL1Aq+XStouMVPs0mJV2xWgufuwOhWvzvYg+l5XmSo1UlwExpNiHbUkGChfsyYEaeF2qnnpZYC29V8lqYm4ZDyJ+0UiJmqIMb7tC1rS8paM1AED1Kqp0uE6uh2udltFC/ErzG1rIxawVOtK0YkxhKcmPJCy5y0vXXcnq/908xPrX+RUohgPKarVpDYXZm1w5T36JV1810xTr46kAn6TfgeIdsQ/7rvhlCPsqN61+TlSK/DUV4Y501S81YLBSLn23/iMZnDHJje6VyMLNU+3wSLeISRWpa8VrNlUZgdULojDiqDF3W9znXql8xViM3AGezNkDTA4DrMEe76y9+c/eiVk9ctx544foSYhKoqPMK5R0rflfOu+8UUQvhezlS7exPSBxvPWaHV7vzmCOXjueqQjLMvWHfhyJlWXQcEQudD7kNKC5aMYNYY4Xc/W4eVHToLa5VU70DsKX09/4tui//U7SAz5dwddHKNseTBkpyr7IDcHY4I2ulNIdxhYzxTcZRYrSccUOzZeI803ovaPgqblgIqLcg0+y6lyhWl39bRDyafIFRNswCFwbTRne1fu4bIVyN1qrzLRXY6d2D9V473xvfYrq/vfiFTrlntdi7XhPynu/qoMHn46SQkuM5cPeSJk4LslJvd5pMeW8AJa1iOcCbIHdpVe1Uw7zIImBVI7bA7VjwPPaKVkEbeeDarYPdeXBQ3J38AdjI3HOUewAYvrE7IondlGyj18eNdhfw2Mkqy7jwZjsuXj9YslR8ErWbS1sDZoHsZ1ure6O+KPFPZC45IPX5vJTL24qLoUeExh10ZKOIDsrMUXZW0773Cx5ht8UTlw4VEhkArfSf2ER3vVZ9uHJne6l7w9D3U1H7uocBam3/elecEI/JGz2yzyRYBGpxtuRxPNqIZFJ4Xdrio+wVvB2F4S04zoCtAQDy/u2a3Gv4TT4vrxTRQpmjxqG30ozXHJr2HAhZz4wbrafy6PEq0/Xpute+HTctr4gWyhw1Dr21Zrwp0LTnAAEe4ixPXimigzJzFKxYbWP7aXmKUbuSX3MRIr42ZkjyNtxdqTrMCzOCHQaJWgMdBJC1GB5XRcBiLrRKN99O43On2mmjtZ6aRKmelAGA0RxGgyht4cvu8tLop7qSlQHABAOVRGyIJXEiNrdvF53fJQiTNXtLfMIgyOKtx0eNg4uPEuH/Y049SdFCkHKtt7MkpxWAb6CkEp81mQYMlHqgWkGKSQ9q584Qz6gVuWWSoV5z7ipxu9vHZqoN9vDgE2Hya73WZZVPQursjYKe3j/NyXNJdpbU/f5OQi2Uhj2An/yEXJ1YDQXJ88k60jYiUjs9TmwrDfXW2Ki8UX5nRqOSdo+qg1HBESZrxrGZXW2BCFQSIM+r386jB+EOglGbq2oiAAAAEZlGV3TcRqy4kaRaEsy2fOKl258kmyKY2umhmWw9sbskblwc0YjFoB9ZW9tpeIo70nht2qszai/ozq5y3KilXkv7NfONOYkTTXM+2QztT2+K641EhsgQJ/ac8K76h/BU1G9Gbrn63Y+XH+LZtdC9KJlv/qM2inJiuh9ruY3mxOI1BMnLaVcDkMWsO0Gtd4XY00LcYKjxNkYxSG0FDFC+Fll9zc7SpFVwiZhBwhuDxI7MpP8U6ynqELWWyadjgR+Ipog0yESlVe97lIzWXI4c0GEj3jJ53Cb406QawEWS2QqAuK9FMloLUc1/2Oi4TB7HAl+JRs4G9kJCKLsUIarFDyoN6ChMRNaNTGyodfhqK8UVrGanK7IcHYtqr+a1E6m3Irek6iClLglAjqpYH8BEDy2lfbBsV36ZPG4TXN/YEyHUEKuqjGVSs1jaiL0sEx2LXZkIb4oMahlGayhGs9H/EOdbLhCZiY/FrkzE2WSlRyUCqjiqhlqIavHjKFXW4gMA1oIOZJF5ZIVnahAbSVMH+2YHO6IF9Kgsbpk8jgV+IJpJaBUJstWGjfetg5PrfgAhGkXctCI707HAV6KxBa4KEch2U/PBwFJ2x9m0FENy0ox34lismIi9adZEQOWckl/MWGc2IKYZT1KDoKWpB3ByMNKW4mQkOlE8Ly5taP+djgMJaotjYzdqb4EfHYxkxGqSAQ9qAYCLTSetP+VFQVZPeFvLcJHoNcp8W0SnpvtWK0y+U/4cYVEpmujym8T2z6TX7WbTzXh5QdwVaoeXyp7cNwJ7QoeTxPMdtKHT2Q32EAeqEYmhRfT2vNTeqKYMTQ3K0oGezXbbWXmQwFkknuolSpSgwbPeYo+G3m4GjG1DNmJlhjjhDeEVoZzzWOI8fAb7CP3/DxPnxSMEEI8NwF6Af+kJHiyBcHHOHYjUrMvH5ud6retrOPlKdg0CFe2fW131vHoYIOD49Upbzl+LXN3R5YKFi6pq/2CpGGcIz5buh5lTM6tGf5QVyBKnvVCnu/VgkfJ3Ovo5atZ/+/BExM1SeAVk1OBejgWZm9Q/SzEt3Jbvl6i3IC8zIW9wuxovCZfqEK1bofAKyCgtvFIvZgHJj/bNAONT4aQf3T2jY6uQ3yJvffAEtauF3Pod8ibcfG8t/BbecAPvaILgAVa7vp0qZ08VQWAASo7RJ9knUt1c01sAdVAusSRlHzXINNALb8QkOaaff+UBmhHgN2MBNDH86dUTzUIQOKAuxkA3VKeVHV0sh9heIbu3MAnfJL+gdtnVCnIwWKlAioZeS8POYPpo5gm9dPbw7t6G3MmKLYiLUGYOX3fiyJkCIK1vr+5IOo1pk4gm+oHByvdYsr1lVBtZ1xP6jnjXD+Y0rugywEEOl0aj5p/cdOivLrYn6zvt4yxWhnwjdTcYLm6moE23czAMG747K/UN9TAi5HG16bQy/e7VkOUmA5xUgXQzC/lYzIapmorZXcAs0ok4KnOjG+C8xsRi1pbUdS8W6JGOZ3UKoF9hbz/1xBsaizvd39mmrScgdIfMOEgbCCqrz6Bcq2Gfd3It30bi8Rfk7vP1TOPBQlr+5KZ+Ik/w65wqqSfiBJxqRLf/16STcSgnw+WT8LxIZYOXAM/7l9ztkU68AdMavdsipBXei1tjKjtFOVgonjYsHk8YPEWoVtKrHS0qusGTmz1L/AoSmfMdTt4TgH46tHl8CeuIBnwyu/YMPsQyU3ki8+qz5z7NUHDWdGdvRq9PIXnbIrDaFa8/XPHW+AjfsTCe4OlaF7X8c6sZj05i/z+/lMTqQbGbTg7m1oqz7aek7Hd6u4FxREJvGPEs2Fk3VdOw8skR6J04eSeXMimroFPxKXV3tN6ci61ppYapnFFVZ+nf7oW3VzalNU/6mRQAYEVZDqAU0R6h2ZkBWelK7iQn3XaB8dTOWWAq7NJLK6UzC0I8UfATknfq1Qy2bYpsQTVwMD3z7ORGFokSxxAqzaqDpS/JFFitciZFvAG7M/S0Ijf5lNw1AJQ9ycdzOtnX7ODTTbPjlHoUkgPegIhfI3aNRx9Buh0l7lGKRF/n6uJu2ZzRvbeHwhPBcLp1DQpMoUIkYgT4Y16G8cTEiiCmFkMvU9XfT+19WxS/OAsLRXeLgs+rHTaqyych5XDdO2JH6eR5cmhWPX8bDZ3q8duqrKO5tOqezO2q4RiXpzdp9yStejJPRGJFHVbr87T2D9zhwiV7MswbtvtdT7DhhwLHnnssyAW1Prp7SkBmMbj1eBqqxx9vZVOaS6vu8Rz/p7wz9qY3vSQmPQ3J4Cp7p9LF1W55ep8gnPbjiJyMvcveBiGOL80a8bnasI+9ivneys09Gy8/vNtHHjqctII5/BYY+ji68HUya2yuRGe4lq1Is295zjwJbDaz4CefzkTRQMb0XxSQAxM964OdlHs5oLSzN3Q1QXTnfO8IbY/2f72lHkGzNaFOa1Io5qi3rM0wiblQtOwMVcbODQFzodMseQH7g/uB8J0jq2dZjPdxLuLCXKdGz70BVAFotAFAee8S8HHUfzHXjDFrFe53IUnTbp5IP+TmbwK5xCOZtTJ0uGnVat/J1wnuDI/s28Wj1TTOGG5Ma5fNjHTZ7d6QhLFsh6mdfywvuTRngFLgnZnQtKrOfd35v39NGmE7H1sDoAUji8n5r6UfZh1yNIpROGMcZRxpgHfh6BtZ10jqLPjfmgqTgbNws8GZlDbh7a+zAu4+BefZG/731qdNQk5K15PsGnWrRslRGatboTz3LHmjkWZ5xYxbGatb2l3qN3bUY/j+Oo2X17K9nk77yHF6LuYpV6V8T2hXrpnViKRB1+s7AdnUtvp9F2GlDJ5hEQ1IADFACoL/3ibc+rSjjZxpJZZdNEzZVW1v6Nks9ZO7nnVoJXS+fjUzefPHu1p55WqulUWtX92gDM5crHial8kUymqfRyRXbBQbq1ALwwvgDZphpau0QOlXqd2y3VuZQ7kXl381kGN5+95lssKXGfMVLymdQ3jmn8/uTpmxYt7asmonwz36abZWz7SwCGmiq3r5VaR7Kzl+zWqHcyaJQVOwlGHnqpb7yfPKtfRClQPQHp9mXi20KUmDlFNRIADDrKAWAIAEuDwrO28ALpO0uj+24CpfytYWS16sbpu8bfjWjNlj99UnFj/ZTw2VdALgKUiEq1Vftc6nmd6CBHwoGrIekBedc69ZWwtLLZsvIiUDFn0t2zBNf/+SO/QesBvI+7I89Rdyn/W4Tk6w1XteC0l6rtAKdhd5eHm+cT064uqSi7n6hPok71MZLUfjDafiVnPa/7U8o8nPfv3pyqdaPlrRgNfwM7CeivSc5wPBDnVEuzNTy8FOhYRgjQ/iuVOiiEeorVNRxm5L7wPYvC9/F4j8oN6Rsdruyl9q+FCprf17DUoWrXdfRFw4/Foq7pa4xVoga2M5FydN7c1Tn9PGhh+Nb3xFMy6SBneuauoC7vitxWmdTZF8C5+OW5w1Yw1KsghyVgCAtQQrgJ1z+8+Zz3D3ogU35F5+SdFld89Dqg0dPBNqgQB5FIJgq6Ygv5CHDtxm7Sw1H4EAc56mU1O5/LEg8jmHQ5i5jUx2xiJ7uUx0Ii8R349qtFvpxXvN5XoKeIXzBkt+X27OIwjkFeQtBGpRWrLkeEIBqWdR6G00+LrKLjogyvXe9eWtlLVcndVvhSfMzoWZmCvmQg5YgfN0xBWnSmO3s8GCjpa5UZH4s36F7NjrNrSPsFzpKickhYKo2Ul+1Ny0NyPVpmhHZNmrrnbZw5ZEaJR+08XWruy1wYo5QSGGV+Z/blkz3rvLi1IeauT7/aKtFB/n6LcrbU80f2zmSa+BpRT6f+lyluJa7cLrlepNTvTZE+Dg3SwydOmgEe9X4Nc9FiEjBSszeea5qkW/ouemeqR5Re9XpVEK5Ear83dPFdKDqlmNZsRn6EeYZ1FFDU1D1WjawaqQ33GAv0n+VPvx43rMDn1HjufDB0OVB/jLSCSFmRsldbe/5YMfEec08uh3+t5Vf1kHb6Pyu89aIOLGjMd7Cdd+21/ciRt6M9jwkq2uz+f2+shPcluli7nTTqp+Kzx1A2imD/w2p4GS/FMk8sTWYF5mmdXkcWffP7/JuU3FPs62ta3rAVwamvPBxk1HadUTo1zXyjpUprbdWmfeitkz1joq/5NtsWONMjiZXJw5rdpcLuKLePcB68fRxj5Nn1sB4CzTR9sN9bRkt3Lv4+loDWrY13cla61kr1QlaznuSufTZUtPNqytK/mOH+eNfV2HJ2e5cAN/Q25Ph3anC/otaGuwbtPceyOuf/Eq1/q562fNARHc/9UyAPSdaHYPBb5anx1PdUkHmqf1HMQcrGEIaOx7nSX9Be81TSZVR0wgzardre95Q93410XVUz2vB91bYc4pBf8qttkNz103t8UGPf3E+nXW9znlqtTZFoFraEB7PlLjO3ZoSMGutNZNsxr1zQliMv4f/+PO+rfiNyxirtELmWk6A1NaZLiG4X4SoDfVXje12XPpDxhzoRwjfRdxrLZtmWTXkDaqWQZNRq/28D/4KMQMN4BeyKX2RyU3tpxTOW2u1RKr0U9rqHK64JKAWs40lq3SDTglWGCsOseam3SpPjT2NViwGr4mVsxZ3lWB0NzJ8HQU0nK+VzP1/M9Hi5VKCa9ysQkyZsosIyE6YpZbLn7CVXAmp4R6hjh6wSYeKwFGhDx0qfifj9bXhEnJDTA3DF2ynVZDjqLiovMaMh9lqmJln0q2MTGavfsj0pFpcrp/0xv25+itt7B2sGx0xyLyJVSpRj3UJ00HhGr0LOODBZ5NoiVDJGPvX5q3gAzIbDAPpuHF1Jd8GBnwXj1jTfxYuqKg1WJxfpUYuThzlmeTZH29xfgmz12Xd8na9aNe9ylRcjFpckRZh/fP179tF80Jn6Vcg9nJYj2c2mRI+w8pilPdstrrJGURqD02TGiWDbajP2sdQ1J5VKT97utEU3u7zq35hjZatFzeuM5pVviQ4iMnjTQnn5dO0RNkuqRuZCdNdNJa0lo+3aVLXJZRWmytl4JsUqdNd7su3M0ZsZDJvGj0Zc6QIX1tHPWFpzT0UzMf+xUhmV2K1dPWu5mg7822o8+DR5zmQ3+3Tl4272Wn9ZyyC+nPrLJrCnaPjJzrqWnXyUyNSYsYcwGu4ipfHYyCnQbpHzRcD1JEdrhkNXQJ11OZXTmOI0o1jYJZGuwmoOZn8fl7lH+vSmpqUe3HBUkCluD2AnB7OYWSsv0CMNIfuvjyQ4lOsHLo0ElSpdXecFmhPSn8lVOsMK1PTu8WkWWpIAuhtWguX5hP+D0Tw8ZKthPI3olAPXY9FegkgGROi0+DhSc0jAboJSqp2au+FXCiAeBtBLVH1XTbUy8ugNHpVqoMVHquPW0ggbZETkMEnEJAiCeWOfzJypL2WZjoJIGbHRDkrNa84oqrqz1pUH35aVb1XY25XlTtiyrZUy+IpBA6a2QglyPpQBbIHTc4FXAuEZRBZVAZ3Am0EN3SNAT146arevkJcxYjyAsjJsgLu0zLYa3vkKTJDBjb0lpA7h0J6Wce/j0H5lvM/JsZ0oKs3AEljaAsTRQ6fWlEYjy11+gwryKLn3w7m8GwBgmEtVpBxaCcwP5WZlyxEmzxi6Bu5nMrssVQuphgyK3FzvkT3aQne8OTde/rGUekM93K+nIrsxq0GuxrUOcEpQbVSvFK+5K/XXvr4iYDueZJM62DmKC8rzQohNUPr4aQHfr8qbTytBBEV3DVcOuZe+baysxSkAriNA56KawKa7JXzm9mMpLcSg4loCRSqHThXEOZnb+RmAKRCro3aVdDb1GcWIrtoJtIeflqtOg2QqiGLJV2KwSpXEjiUkvSEIoVBCv8BHEAlXRvQS2GVFKjZCGhL17EJxMt++z0C7R7aF3K5AuRTuMQjXbBu2+ahORxElP2kyq6MEh8IaEdkLi19CYgBzwNsoMKXkMAADQUUlOuphwA0PSkdfdl7ByJxp+ahWT27Q9la24Ix8feimtTfZBugQB0V6FeZWVJ3KMUsTsk9Cn9x9vIf5GuFvohy+e/4a4W+iHfE/nv5VeFQixgDgTwF+faHeryKUeICh4MQE054j3LzRw6/GJYYpr5mpGcixRSaQUAKAZih79y9UcU+1B8/Tl7rylCLp71L8IHDL8WxmFCEoIh/w9gUHrcCBpumqSC+NfK4Z3981OcnbI/erEuZb10HLfzzlfR+PLtlCtcg3I/cw31Vsjpll9vcXjNNS9iHmlE9aHaH0yQURzidpkL6LbdxNQfObw55aLma86yd5f9DO7q2jM8l/me1jHHaPLY714IzV3+69tDpgXuDU3oRd0sHzXrxlFd1DWv8fNirfueaQCMqTpMMndP00qnQFfcGZoreWoDSjsqbvQpnbc/ib1ADS5ykjTG0u3r26YSJ95xtDkrebu1Q+dyXi8tbfLVv8s53GlMTcO7iPNama8YO64f/IzvaqWFkaNCNntDRWLBqPBVgg80D+4N2D0k3Na68X8NlwGQP25r+vprdS28Hd2pB9bexiMvrZSAyLSn22fPDPA3E1Tl9ccNUBUXKQPKuWIwmzWahokPPxUKeXHCapyS+FWWIYHnt3xGCbU3Xkp4OZFE3nyiidiV9cavlvPys3NVUJysw2LAnIiN2Yz9JPsvjDOmqCCSUrhEZ7CzkJNyY85+7rd9PCXQJ1TInqwHDSlqomqYyLrUeYo1Uxhl/ZinH4g09+s8+aDGsi96GqSXREm5UEaIAeSRLl2EhkbRgjHlthUmRal81u06MrM9+gaETL2z4H01uXyppP8EyNQUk0bJpZKb0ECiRauYNWwM8B/xW72JHaOLt3s/YMFhD1e3eHaNKx2uBjzDcWKiwu75t09+FOk8z0VR5vPtS/12KK3ENCu9NLiRRlsE4cVEUCFW1REQWiufhY2+iN9HyMCWczWGC31RO3x5i9k6XOdLX9gNaGd781Ri+XjF3rRyMm8VFDOpACkDnpL56m0MMmmUl50tDwO09qlWeOpTrJaKsF2+DMynhLhUvyOgXh0FXTR+7dJbsXv57VMxmHPt7xtQ5sTeuVS3iKenbW0h9VqXTDCe1ykNteg1OjiYQI2Z9iYDluoNXZ6XASjMrlCuz3IJnl2U6k1QRItXNfDGgMXD0iHVf8W2f2Uv1Q/1s+XEKdocJtuNpEeDYbK9sE0LR6hGkbSOf5NkNqu59MGhUvnE9G4pY19992Dafmcov/wrwcImLWfO3npis9jKVXen02z87B9F9oeX/WN83CvGN3TcPVHhov7Ke6qB2N1ChuqJfTd732sww5I1QDWfSrebs5EDzRDCAZ4D2Zp9JcNdDij/iBJbdma2MTMzx2vcxZcN3yIUFCbChwI/BGBFxCLKjqt/Uy8mPa9z2nzYm6K42QXuXS7fBnEXIkrwW1fmCvdND4VEoboKpX+r3UcejrlKo/iQw4d4H+QLyLJYLi/LOEPKY5sAiz5dDQ89VYYSAokRQkc62lYithSt2bGzuo77mL6enaHZAvDzSSt5+vH/KIPi/rNLZfS/Vu+nxUnJajxhURIjO67RRUslJMj4NvclvsbMf0Oxy+qNuerMW/++CUjZaeeqC6piPVZ/HOF9AMmc/pzBpM2DmbJNP7F5Hu5yGKrDe2QENcc9K2LRbATgn4zA25vzA6bj0x9xIBOAMIGIsz2TAwJQH2rIVyGTbrin8sw+DG7MTbF3Y20fAV6BXWQUyGwGDHBzcGOPYXY4LyL30GRHUVZHvNF30s4+arDUuoGEF4mkRCuxhqLISXpV7oWN+Ks2u6QFANP64d7ow5d3aznmR0HCpQW4WDjFYQ6RBa74sDicpYOixcUqfGF0G9F9PTjrwV4vuLG+sG40Uq+cixAiH00iGkUxJXDrlWUxukof6DVnLpwSy89ZO9+II39R+EQIV0UsOtKYJs6J0KbUHNaldAE7S/PcpBSfoH9QOGXN8Z/MK5+Gt2cahaPtqdx/eazuiXASIVGUgagRk0uoJTJ84aHDdhYempWjOdcGRgjOjSi3qkAK9pjJ0fhRaPSt3AaJ/7L6KIrAA+B9OlcRc2MLtTNFWBfqPnaotv82+CJUTasQHT4/XuycQiGcOXr/Q2395e10/oaVLCQeWegd4ZY5gnyOLWwonoLlrVceb2eHQ/l0DEFYOVoFnuyCD6EZTVq02MvJh5ddpmhxY0szR9zNJ2aL8A5gXawbude/AXmoEHjcwPsMVjskmcefp+YGBRrtZwqXGiPX3ag7CfadDF2hTikyP2pu4oAV7krqAUIa7LkQAOyuCcXA7k8QKAUWuv61ngEH2xxUgjk6HDoxhJIyGwhWKZnsHAs8JlhDGe0wc4oSrshNAMhiaMakegAghN5JMsTfUIQQGCaEkMnt0C0nexZS17UONl8+Sfr96daNlzdYWzPDAxOfTYm7yzmaU87L3hQnPQd/soG2vMazr+DqgmcmjIhKQziPrIaBkXGhbqrfzj3BE7us7O4ZPfOIFJ3O8wsoMhcz7V3IxPzwxRYtTi50meZ8EB58cH17V1w3mWvV7vpkd6meY2EQhyT+zCQ+BeSkBzZ+mFvUe/H9Gj0jGcwBvvSV/QqeFlDewC5RKtaobeIoM08yfB6BnptRi49g79C+Is4g1Dq2mqYQqJhxbdLOlXGLUuyqMnKEttEJijxyRlOSKBvH/CmOpwE88Sl98C6Uz0cwX5illGQeEtS5ACFFTk4SJdp6P0lIXMK24I9u/eBWmUKCvKjkhuC4S8mHPmDxJAPrssWuhl1VtnkBmxYCHiFVjRFcSYlPXbY3awnFHLZtDlu0cCfCPnfhzUsXRWQKAT9vmqFgRtGNpvta0C7xdAZ6JiFuabYLU50Czvuzb5Malgnp8p7VlTlm7trgnyVkMk20OwbPAJ6luFRBpdbScyrbpVBo2WiYuLAo7BHJthTU2raKgd5Su/zwfbfyg9PTWGoE6zu4Guapltgjxf98thPu8KlAY6pSTPETLN1DWCtVC6HaImWC6kxnKdZ4mQjoeKU5XmDmu+oC3wep4oBpeNI0yCeZMcdbDeIHGyd7w32NhJBc4brXVkEo2ksRSdxi4C2hLGIRgBZxD7rRzahpkR2GTPFWI6L82yglROGlDAQk8gUt9pz2wSIhkQzYKsoYgEUEaV3oIiVaqWslhaUWQlpK1jpKHufmF6L0Pse/MniGaVHbKBvujesq6G/3WJlpsqioKhcrGph6pFgCvRS0nYzoQJvTAl+DWL/MkIkb2Io4ocgkzCyBMizqWmXn0b2qJI/aS4GBh5gKqkDQ3kbKl04P0pTJ0oeN2E6d6WyUtRz3DkfE8XiNc+lhZmpLzdOO4RoiEJrw4Oz9hNLCnoSriGc0hIhammnK3U9mBD0HIm50lVCuKc3Npc+MrorGT2xWaA3Yy0AxJwAZ3HKt0bGe3JeQa4gTeD8SX6sWH0mlazb4MonhAoNbSyb0yHkkQ0QT59A/AQBbZMiHzwKZS0DnOpccFAlAq4dLqZaCFwhmQ2W+40AOGMCycOTiHbNWEZKfzCZsk0mqAaNONmAq0wqQ9OgDf7wjONIcSWSoBCsd6DRCO8Ma6qWZu4xwpcFKtm1z39OjlEDWq0Tn+qk3vx9BrqwIqWUhZpSOWckZLXo9AGF9+rmTTC7tcTC3CbALvKZSa+rCyTr1c51l05T+fDhAnpArKdN2rjhQGpYLpy2Ztu/wPRZPEzyP0DOOowai4rkbLe0h+T1hKqYKHbp9E2ndrxtX53B4v9RfP1d4dJiudDWqWs2j0joWng0rZJXXOB+hgDSYd0P1eKNkBJnaChYYB5rO4KxjdWoxAlXu8oHLFUVoHKxHPY7FhtreKLrRNBVqwrQNSj/aGmvvizjrENrOUBJ0S6mMsNqrcDrQpI9rQDssMcK1ypPnqEhZRx1HsSXYYiSRdBDRgMQ40TdNKy6uLJmbYj41ZqHhMw/ckWLDthgbFNNalpTD2RlC8XTus8Ed46MNLdxHsBqNVBQPW0sxrlTKsp71/CWeGvOQw7MI4sB6r4RjkjK7RZAe/2KSjhyjS8ckiqTRjT7vw9PB9R+0Uj5tvhUQmqjdEopz+qMtPPscV8+4PONqh3vrt7yTo+nYjQ5y4ifztknmHSvUV7IWX5+OANzqw/5wNLoJIor2hcTxaotRo+hG06XGTuHmKnsGlabdRgK5xNAIeKjUedyQx9rkxCOySl4/k/ieHM2d4YhefMLkACbxgLytzuGDzoBzrZpKBxJC+fb/XgyBkvStE534pKUCeNbUvES5ilTRqmn5lzr4SZswDgPwH8x4fTEWLRDEHwtrW/LZmEyjsxFRLckM5dQq1yvQxrWao/bY+DaSArC61GV7yzzH9n26EBQtB4SkQ8ALyEcWl1mQMPuAF3HX+lE77ZCW5mE2N1tnZZmOe1vjOYaXJeQalKSU+GxpMQdYl1BKdMRAYMTE1hVsljPUQYLxgWmmJhuzCE+aBtXJt8u/5kizMcgFIUVkhl8IGywXQS6b6axllh7FeGbG1RZXPZ50uKLxHEH/E3JyfpItztolrZqxA/8oHXNdPtk1KseWeg9N71BWkieJQ8vYxX6w6CzqSS5y2Ttjg+501+5KiEHedy3ZuMNjz4noDgsKKlZYljhDaJNxJnMttwbuskqMNY3zTERSqdhVE78N1EwnB2Y1x43VU6ysqAYoldkQ7k0NwKuiqhR9EGGWLjC2Vq3ssl4JC49sPFtwxeOyw2WFKxLPEDyHyOgpc1Qjq6VSzxI36LLbKCmi34dKWtnBexqWuFnFlLmG40C1EocPg41hSlNVxDqHIyeBpYqK7RLShzd18pTXXAwhgmCdNy00b4lgCpHTYCmnigjH1GWb5Pm1RnP4reS/8zXnCt4qhDNxuPewA7T8t52LUlyFIO3O5MKQ8lcFLiNw+LrQly9Px7qAo4D/D36ox09wYjje4X/mEY4tC1BpFRXKAWHBJbIiPoyiMe91hhp42uVKFC8UOFsyTbnd8rMElBQWGhhs/97eKGHWmzHNeZdQ8S5OGIgP0epA+KaNrlG3zLdJ5gW0AwREOd2ArGBNfOddQcm7OOEIH9JE5qkqLjeKX20bJe9QxDO2CVRQZzpUshlA4IbeEUom4n3oJnl3z1ACWXeet35NQfcRyM0nkvgdrt6YGWLRm1nP/xbGZQ2h7xa7H1vP474WAxZ00PHSzbXZiZHtCqfGliNOjzmj10OyzfG2RMVA8ysQC665rgxc0YT/oDDCAXO+LeK4SCkpdQEt04KTBV+B7X0ZtMCii6Xsd9ozUJQHulHos1EKj41dE6LAWDZEEu6qF73kSi8eOoJAUrEqhPVjNSmKEsxfCqwwdxZ5928jrLv7HNnSdIfHpHRxnfKQqrgLzMpchyX/Jwr05w0toBzueO4kv9NcvqEVgVSQmd0Is486EYrxsjo4EDEojbeFrHS8xCIpOusdpBrKhZxv40lcB9buuI6BPuqjP3bKw0c91EeRjEfKgzxTUotBVvrD0xIC3J97Vyc7QjLspslgnS7LcfQvVCBLkjLNJenC9dUEA0l2GobtNJxWNh6I8rImjUMY1UdRS7zO+ZLVrT6JIjcIJHQ3YZoAIjGoorwN/i1i0wzRPAdAIm4670hXQEooZqgTQQOGJypCWrrSldYnaZJ6ATl4TL8siAf3cm6kh0ESeUhKuhSVVStmMm3J8HTAchVJZeCDN6gIdW9o9xXdkUG81PmyMorhuGG+aDzUcAYKR/DgIZLSNoZ6q2xyN32n7/xdl5im9FAfzan7lVdHg/f5lABsVmRLSYOMte9gjG82FqowrIs+hoQgFVWhpnWoOG5mFJCRXpPQccnOua3rszpV1YcFJOPtbcm/U0HorPrbNDD0bz+V2j3Q+20mve+D1FcJYWHewpErHthLvqYHRNCz7O9o2gkRdZWOy5/FPviffavcZu+2rw3i7SbNe43fa2QZ2NMA4KHHxQPbT/vjPwzgpYqnrHS+8/MG1xAGoigUn/CR1jTVFHMseBE7AbHWCPk7ckUu3EvS1AJZS2d128VIz1nYXe67JcG9y85hBgo7zj3Tym/QRxPdQ3soSEliBpP4XgRn4GObVeD4ew7fwQy/Ln1wx58iHbSiait/fCYFGsaLMuZtV9clto0YQwQeUwuCYRzi7Ta+k5717OW+4GZ54MZ62HBF//F7E7NF04XHbvTR0MmCfPBYsmI3nMTBQB4k25hHof+tNKQDGDyloNGiRZbcuLNB8jlKX2PmYres6d2U7Nsnvwk5+MJ7GxtDptBu+RGUaid8pns7fZuoydKzDagRTg4Ktx6t9ds63dzY8EfOyjzcEKeJvsecWN6NXsMA7O5GD3zh2USwebhCl93O2U+0acIZ/7PmwZXwTSNvjzft6idjpswjB6BIYl07IQSytVXrPckPpAgbOBY1maOYvhlYFYJhL2+/hyf7mHYxqPEcYMPPZIm93L7NmccExcpnbsTyk344bjmFWzhHjrS7V99fSvajg7V9+xqC5vGds8XJ1LUFeADGpmplqtgQYgjtKkYGxVpmAYU5ynO6hTazxqSM40SLTjoAPdfHzOG4OrLmDPTMEsGYDg6DofVMILIh+eaGuAVmcoBL1wnYfzfe4ogFNR0vvRE55MFehNP0IWKurupRW58wRpk1/dZextq2ThEZg74w7+INK1UW5LRDhl32FOIqg3YtFeXBZdUt2oyyUgUo/qoC2XpxF+tSUlCnFQTXsvSg7gz3GWDclFKk9QZVk9ND1QsMYYHF3ucddJmnnO/wnFFg0hdc+3kDtMxwmlYHx3zMiFIOC9lmbdQpfS3xrVTAXaFQrwWu/zGt694lZQknBRuX7bdqyJCKt18Ska7KYlCJtYuVWKHoCf+EIIPqqmZveDLgGddj8By9BZG1L8mQxKz7SDdrqI6OpyXHvdZsPyb9xFYS/9fBQTUUkCOpwJ3BdhrLaBvIrPNLIU0z7rMFKtOM19ZpIFYTUujCAKQJGTPiLNMEWlsfB7tM+7JNeTwl85zU+wkviT1gxi8xwBnn116CRhoGKUEjWZ+C7oRSU5OTzZq2M9Gu9mYbhzEipwh0BLELuiUDy5C2FDqCQGXZUuaPTKtdczxsHTnVseI775TTfKvrvCKXXgrWjYVPVVGDeKSdq5+2vP40qCxXMHXtCi4qPpzU1lhnqEfJQJ419E3Z9x6dMUzL0YhOGFjPYBKHAfjOD/UpUXO9eOWsYeBTNUiF+hFnbr3H5uLTvDIKgAZROvqhLh2wYh30sYRLCtVEJL/DBGIJUT3sFPQF9odvA5ZNqXtmx1ZTazo+pvK4tkH+GqjXTFHKcHc9/oNlOZl046Ymeqm8RZ/YgrywhRy4SGetEeVFSgZ8BbKtLbixt/Xc1iLYa+GZNS7Xd/c52cEu70X1MMWVQv6RbpK6fdbuWmEu+P+k6zGHE1xcQmzC2ryVN5VVu1yz07d6zU71Hm9PCQUcjhrNlsAnE3yBr9scNmhZQWV5uynzuHaVPWD+83UvSsoghJNbir8fsreubDfOMrCr1GBJ9Ky1/Eaf2a43npPs28UqTDEJWUsFnbAG8gHppJdW67nESYlNkPytEbbHRRRcSAyhFzERchoO5vnvAyNHCVM4eirMn7gGgdUmUlNKlvUB0WfUCGHoC3ZKsLfP4HsrFBZTDHh+MUUA91rKlDUL890GcpeRNidGjmuWF3iFkptP4+R6XRQQ2YwhDjQsyv4nl9afYDW+EU8cA6ur/boajhxM1bC/ua8PWN5em3jGyuipTOMkXl9SQ39gBSXTFpxQJVIMq5zt4egaeDfN1cOJiEpJkCWj1E7nCHqARZlpTzI57BtSxSb//LBRxUXSY341b0Kk9jabh2CY7BvcO13tAFsUL9aF9i2yyXQ7C1K6N2/QapVbVb8325S0ZKkoUfNdudCvpgdHKXsK9sl5svCUYHCvRUkEvLVC0IhSRbcimK3AHn1zizVu7uKSrxjd/N8qCqq2u79fdf+XOoUVrRuk7q6XTYBKWAhLU7zTd3DvuExl6Ts3CCf3pE+ZlKaB/WmbkIQYNjI6ySue/NJPBBCbxv4pgCo+VMx3TtUMnTZxyxJyWiB4CrMi4Gm3uYPRjrC6Kzd1XC2ocuFIRX2XHjlG+kcQXDf4uI4EepzIo/rFnUM22yOFBu/hSTQfJ+253EC5uIhSGd9u4ckFn49Ea/zzj7hyMe8KqcrbOWru5UAy5Dv7ukvt90OeMXk1F5rHoGvP8bOr3RoNBsmN6QFw66vOuqddI+O5YvERsnAwD3aSU9e6O2aanbeGVnrVU2W0fs2q50dHeEr8BfKeBQZ1AVGM4bco3FaDCtwuorJkLrja1pX5oncGpWi6qSLC4ANHBQkAiJ+Ubv0Orc2V2nbmoV2KlevFdxR1lCKTqX5WGlCacDoWb6tZ+fB22JfoZzz2n7ApaAG4g2nsrtEiQgo9n6iE5EwnVyPTsLv1Ds183JS7tuDxCEi7kzpuI5YAQu36cjilZUW8vs8LajV3n47uRtGNpgf71tqrt04rDUOFmbnHKZmgmgXGuu4owDJroXB2X4uh99PdcfDOcBT2O+8kV5J3NvKQNBokdPl73U/TteG7Vq80snenlfozYq1pNKzPmmqH4yK0H6D+kDUA6FYasSCOLipPFrchvEVtczWZsnxvHK6v4eRJd+kL9++7xs/R4ueu/jTd+PTHouPobMZez+q+J60s9RdE+AXzWcHg0o8qKfYOLRd29lv/Sv/qEGvu1LBrQfbsR1TYtZpU7vvTJ66hJXJFs9R9L9P9kibw2McQTjWdjx4D3zZXmdfDY3bqPuVWNsxmpWan+Nt/5wQeu3MOIYNxLYkpKNX1DPjULnmm8tbTFJTAvs16M0M05RfqSQifuaFuUXcrHUJHsaAFbWqktSyZBRpKLx4jYRogsURHklFDA7JjmSbRsZtbECYjbZI0yNSmO7wCDsBAc6GGzeUCA4LWS/PiBoQlA5W9gWF9OGZjjmDll1rqKWWBkYDA0DMxU9ZnIlYBxDAIwVOVdCM96CEVWmzUp/xY16O1soJx2jZSAdNW64JuL8WqtpJy10Kw4xpko4fZDqXKtY/aHAanS+iqfSdpcZJdvjS5n3Ip72s8FfC0x9AkrXuG5rCXKFNmE296O2mFkGhDDOFwA+cwFJ0DQEE/6NLY+qDFbbrQS/5hvRt+Tp/0yZlAaLrVy+dtdEQw5HGtzo9LgGLLQjlSbNwWIV24Bxh0SIfxPRjZdISKhX4TZc6bVCvHAIevtVrd/S6e2uPpBU8PyKGdyLx5LZ5hTZ2xi9C59aW/b3DNqHhwLnHCYW7Rg7fAcS212XaAWobedycDM/nWldYFL0AXd+VZBsV/+k5kEalhbw8tbtDEWN6QdJ7hjqtLHCTZJzO+HRzcuDtDr/BV55jE5An2XGDH6xU0LKRrcSA+1oFK3bcctXQdZMkJjbJu4VhgAs4mSTVxG7jM4Kp1OuI1/4S40TQmYGc/5gw67qc2XJ2VMc8bKwg59BwtbF9QFMCCyxhW7qjUXB+FOYMLSUhUDkgFSmWiYrOdjIkz0FWcbdupkFRUXTP79Xc+xlV6mlYpyaD/NdfkAZnc9v2dsxmDovBdMUsqwosUPhEYjjBXtPjmzDysguZwCFYvtqwJyX1YPRY/jF+0D5JNKEua0umIpS+LElwSwT3aXQlSTOxsYw7qDtodaFUAMZKzhf3OnIdKeRFr5U6IpcFhGTGeaRnA5qjjdwjgnB6p8VHMoFgw6A52iGPsLmnykIXw4luyBfDCnlQQADpiMWGyFZToFvpCYMnOzkzRn7Fr3cY0dg1YpRTqLgHwJN37ErWSss3SE4LBQnsz3CmZzBL+YnR620btDhYIHzlpjKqSO2rAHqmBocdtID0hYm3+5m3t2aqlVsvPAO31RFOtA3S4wWeELbdlUxvln+5PFaHJ+I2Vgf8VICwYrnnjyux9Zfxm3JsDhkat1GDJS94NttxznqT42Z+vV/UtTVXjfpZ+Y4hBlsU1pR5OXoZv9XKmT3Kkq0JUK80l5wOdKrG43w9IrD4OjQ0/6EmSMdY95PSQ2GKNHhvGqW5808TkD1bM0pEoS7kvd46YxLP+yxBInRQZSrV5azbZY6vY49HPsGuLyuwkKFYxMD9r7oX47oJnJJ7emmfglH5gtfMlXH90P/I07ORPEd5WT5unlHy4wuPB5f6UmQawrgf7mWlSbAzTTQeMH71I+VokXMlYerGX9Mc7Hohz8UXBhUB9JmGdLruKVG0otDSp6NN8ZrKYSKZM4p5UZIYwAYdqQy6u/PjpFZ5aAHuWU3marbNWqEQBGbUZAErKdarTQdoRe4eNBUkYHfEk8dcruj/R6dim6PCmww8dT/OfDYx0YD5WAjJvnLgxFiXhxydO/bHOjQ3ds0wr/ewLjNWc7INuJF8/hOJDmuC1P7nhe9t4aRyYxN1dD8/7QN14SUE9seBYZejhMGRg1lZa29lGSQjSnoKv4mtw8/q7W0EHcO1VUEaPGcxOiAb1Na+2RKRi+c8gkAClETCJ7F3OEQADFAW7dWeBsxnNybThM+vQbukwUY9RxFuTZE0BP1Y7ShSCRZxRlZW+xIJ3Bg5zeJ5bljawEc+6XutcN6PvLMxGTjrv2CkztHcH9N+SNrjKMgPebShhpDmzQ8sy2Tq4q/QyT7jZ/ocx/0NnWnDR6mhimPaKf9VTQ227fWonTHe0i4Xz9zBOpNfMiQ3Njav64oGAEGLS4PRRWSHl2r8iq93W1DRMNhWwgnDuiKKUE/ty1YwtVAvJhhSS5bgyBgbAfssj0b6JxW8FEdbQhH6w4g5/A98+Y0Om6y6T+a4mjMJvDdnX4rfkY7WraDabUk726L5RjEGf7P8qvaFvPlmrkqe1WWth4frbzZ8sm477UnTTZTXUCe9l5bEu2iZRAiSQqP/nBjEYq98gLaVYlBdJyoV0ZjOjD++akl5EzhZPXl3WrFcgBqBn+7SIDfBN024b2vShN0GiXAz3eQ6VMISaNk23kVvf6tv8trHJ6FYvzzdva2uBM7qU2siytE242PKsZijpX/QY4bEGL1/KskOGEkAJjuYgM2QhzmHrRUx2RDm4vpZkpbPGICTXcg1N0aIzrRcq291N4HC4oVRL6H6gv9fCy/sulXn20L+/utEffkbRjaa9LrNVUw/0tRDxe6sMuvu2fLXspOOJlROUEK+59usYUh4X/EAySKA6cDRFyv3h8iZ+i8B3on+sjNmciK9UKeCrxr76F76aCCJme9G/Nv9qCn+/u+H9PpVEo6XLDYJkNcxMWSMZKtLnn0b/u7tx7OeebYu/VRBZtNTqpArqtlO0+h/NNJ4rtb4VIJbkfph/0Img6sTN6QJMHgkA5BRDJCiARYcVGk72foIEk/S11ILauvXLiQrvXEhRMcXMg0wqAfR4Q68BZQJUscJn8p1G9+JfOcB1ivZ3KaSp+KJpMtBtJvxRlSerSTl6iC+E18ONwJIkXdp0nnEoz70bOdw7faZL02n7BmnGkQPAIKwlTX74ojaCSZ0w1UaADQ369M1E+7ZZ73t/SE4sGRPAO7vRw6rOmj4tmDo68SjuCLp6z5eUYphiG7PSx2SX0DtEJ/AueBvSt6gtI4/3iruBcmnGoyWqu+DUQpH8bDCd6Xt9P3ffo3cNV+CKyfD3dU8WYBIOiHGTpCGJzpuWPuV/w8RlT3gRSQ1rZ2XTNlzllAgeAzVIReE+h52WSv1PepSZ3mf7cv1074vILpENYOGFPmeOLxfr59ixLS4RWkWSejuxxBai5cDTuLVec801tao/gxVRaMA31AGal/X3sIVxhaGxm72a1A0XV4N0cluNYQxVlfSnTqEPWSkj1njjbokPdSblT13W3JQGL6U9bSxm/dYkpB3/brZeot783Tvht326OXY4n4vRjXi61BPo/GvfSL1v6HU7en3f8597+DX4EF8qF5qCMGp69P7T/ukmmwn3hj42XP9Fw2yenw3PVdxXnVKZbKdSBNBKjFzA3SSo2sxJe10Mk4wf5UAV40wLpAG+BF9whF7cWHPxeagVI2vZhPKc4yURZaLtDZmOnJKEmj32tEqjJtaOc9zhvd5WA+5sNkG6KdDbcCm3af/aAY8zoQ6gEsXuOee+NfO4g8LgLnFAvJSyu8YLB3KpCZqqXfkhjl3NRCh+mCYqPmv49QzfdmkYGbXqdOvcmP3Vea3Y/b4YX20e78dN7aP2zH6GPghOAXsMKIdgF+dQ+vnZoGDI8012clwe/bBl7TbJpiDT4fJu2XP5vuba1Dvxqw727v6OQkWP1+Vy1fhl/EP5v8LN3jh3/6ebvJpfmm0Ax5B+du1/PnDkU8A+3f3rAvOBC+8BbbaOdDGodjyCvo7f+tlldH5vLZH7wrS0w3ofS7jxma9x8F9+W94oF3bKnEqrEO206tg9Sd80sfOGwPjYzjBHTI4TH+Vuu8aDKag9FHiCf+vtwNOecDAIZSwtTnD8vIUFE/ug44/L/uBEvb/OWAyARkj6+9zHltBT9W/Zs+Y4Rpa04IZb68FbK4kkkkgiCR3a8FECjK4FCKjKs+7q6VSBrCFDID2wak6j8qonaDDN7ZCzgYAedpjBqPe2r1klneQoAGTRKjwR6JN69d2ZkgDXCmaA7XHgDrrC0YtKdu6gM17s7KH0G389Q580Xx0I6Yn/W/ZqN9sCZuw7T6dbsL6zUWIf2sCdi1TSwF0yWZM+EwPAfp5DMqdCbksxgGLGmKr3+aexDVZBW4nn3mJbmQOsvRS15TRtIRgOoojz1ZWuDsO1yo4BXifkLEPM1XBUzdaV3HavbR6xbZvMdf0X6O7r0DoWQnLDk8RRSpgVHQLal1i0Da4nnfmWJ7ZU2OFFY40C7HcTN8eNKo6l/Rbwgee4LPGMRaXnXwynG00PdKejkyfgmLYycdrsJ7I3vG407XU9j/y66c8VEIpVHIn4USqtx6fub4psoILyaSSj0Bth6I/UraTSd4km4ofZcikHOrnhTBmoMFilybKD/Sps++jnnHjSOm4oCZSq53XlbhIoXT7BExJ08pG7mGFmf7t1+mTB8SEKt/vvM/zjFDKOayS0lFgZrt7F9+0yB4ldR69YaRWHLolsA8y91XCWBRNTWXm5FicsEZM03uUdSdU3K5hVVlUSvUMpbnNQquM05OShwg4AtJD10Ez9KrD6bQ1XDa5GkPK2WVLU7bAq3s5HXqAWOTc7QwmHeqAQQew5ccpfkP6eh0bdNjHNP2cem5S62+27kN7evh/K9p2hrd29JBbjFMgkNUoer3jvNMIBcuCIX4l7lbhNKLaOKEkXkCXW/tzMti1krZTEtdV5xLSXIreakmCtUhkFEMZTp5YBzn2vNYo1OEh9HkfeUwjt8fM32LleW70Sy8GRJ29wgDRZ0qIpDqf+DdVmL/VnrZvsO6WtZ8mGi1WIlfr6tbasydukJzzXj3M4cSKS0vnfEbFsqPtLNmNuHMYwtoiFQlBy0Iad9WSp4yW4GMOoqoxQBKHgetBwFbhePRH9XSRUZYkvCPcLLkEhjq/8c3yXACCLSAwh0z1pI8o1Gaxgomd7gp36JeTBp7DMQ8sNLiTTAnDfu9tjfO45BwoeimFPZIjWEgFa+JkGsWd8CQrSSFB+ESP+i3VX4xhPfYSK4s2nqfaC8wIWYDIk4F8VkjaJInddrXPvH3KMT0sXoHfuewpfCbPKIhjryUrezS3SFYjAoHwiCSCqa4U8RTAozKwf9UTxI4z47RonYtna1DsiJz6G3WyYZJakkllkOYMfqeo78AIsOk+n/jGWJZ1Xcc6PorFieBHjMn7KRnltCNjU35JVRsX+0AMkg6S4MWHQTvygy3NvlLn4vscT6hB6Ynas2ZmQ+GSSbCWsubNlXZhv7QIysm3wLXgz2emFlgwQS76TKZtwgAVu/a6zeQ2bF7l1i0VPWk6Wb3ttjWeRqR9a60hdRAOMSrfWPNLYrOEG2XN9nDjwek1anlCAUaSI5saChgHp4ndtIinE+AvjLvCc5cNRnSX0eJshwcJmFNJAFGej7mWmERkZFu938NZ6v/KOaOBNhQhL5H3ucd2rXC+jVldKYcwi1A2nsBhAoLVKKdswplUL88ASQMswWz4wqWiAckv5nTcZLtrsOAZa6xCRH+joTab6NK2ESOT2STGZTNy2cmi6lHK3/XW9PrK7ppNqzDMPa0xSo4aXkS6E3iCh9bV0mS3Tnlpljp//RoUunSbMid8mayPp8ErSssVUY4BVay6s1T0Zyp7xe6k+6KczleeDlINjn7Mtq0Gl7yvgcR7x0mbBGHbeV9+bFEvfu1xeMdEzzO+pAh+Zq0nOB67dLdnGco9Dz7RSR4jD9aaDecO0Svd1lVC6MYpuTNgPNlWRjJb39xgf+A/6GVvR3waCzHgjw61XVjloUWCDK4BmrssdwzwLvmdoLk4NDKxkZbHuYUi7BRa7pHWvG0C04vq4trVD1L3uR313bnJcJLT9sAfu1kAX2HBZsd3ZNXojm6trm3o5ORe/0NgDJ2cgswh0rCo7JRRRK1kKHaBntmn0i38uVqt3lmFEmjs3toIzjv6xLqZLY1JGph8AGAjldVfHOtc54xaQQDzm7+/RGINOvQQEFpYs1W+4juTQuqwTJQAfVKnmA11fMdl+hN/YFyGuGkU3mnY7nRjQjaaPVzcJ2crwzIIazT9zCwP/8BVr4XAlwe7oLXgBCCDmnNO5EK7+du/crtScYq28z+oihy0jx4UvXglq/i9dGPjwpzRkhapAlaA16Om4lWS7H1pydbO36/ijnjWX8UFXSUEH4ZVSu27SGS40KUai2Z8sJDzeJgFay511dJVQj/mxedGQi3EYaOUnG39lYB9jwh7E+eoK6Rd9ggDzZO6W5Q1YDgVRoBnIfBhcwM6QXtCmLkdA71bAPZ1QSvfFu9vLM0mkpAxmQ0IBKRfdltNvmdlMWWbuU1JQqt9wJmfwBs7eR7HEhQHH36J7+cnBk/yZh7cfG7+aIz8dr7coW62y14TqZOf64vib/VZ73CgYtZrELaUknNt+cn/j/nz/yf3Hct7bajTqUfNgVO88F0oxzHy0aEL47RaREbE0QSeF+0azcd+9b3PhDU71YPf8vaFkVSQev80XdFZcX4i/DpB7vmo84bCA03d7PQcWFnMZc4RhBOv7zFrS/zVyHy6FcCyaW1vZ99teBQARnUF//BOsgmmX0UAYduAvqBs3e0df4NJMPKKipf/jEHylMkYhUQtpTKiCQHWe70Yz5KqzlRwpedstA3e7vOu73W8+PP7m/MnS3Xv3XLd198mTgVFVhspz4e04e1/YOx+rYgg8LKgytUM1wDS98kYJoZQ5THzfrn/tok/uNAc43q2qRQhgfL2fQ0TChgjIQVDfSBTOCC9YXhZ3fxtB/PYkNaFkW6h8mTFehplPln35B0opSsyraU987FWjX/oFUTKnhNsRY5whVZRxgvhYMTG/DSvytznI356kcLJNqp3OiGRMZoSq7fNPieckaXf5PFrC9o5BJ5DeZ6yAULLZWvTbKhSuzeagDGcfwNVi7gMTxVgQTQHEYA8/2btRiG0zIvqrVYUgaJFzqXjtLraxk16QBR5nq+dheYo9KJrP8bUq9zSNJIM+GL7m0ieDNdpo2qNXDuqhzffHECDxKZdUCI4v1Qvtc9yQDgNsFBX50mZn7WiyDaf16NoeRUsuPcrh2RMrqc+fcGbDNt/z4pUV286tfOIYLw0ioZn+inlHh54C1P9fjpvtXoiXrl2Jn/TN3bj5WRG/2WVjupoZYHm99Vgj9Cx/ZpkcGtT8/E1Ykj8Xf0D0bMWyNrFB2tpHUI4uRXGUQdB8iQBDCFI1B5NoZt+1USYPb4fPR5VZ9h6DKMZToHhgiqtLagat/XMBo7shroywcXYY/RgTjLw3CtYNbEAEhWVVy3NY/t+J/GEH1mdIn3kvvb1LDMQhRpWUclLTQqZH544UJEyfRs06fMWs1Cajy0Z8LX4VSTpjdkOSJ6E2+s3AGMCdCYyw7qb9KmUrZk3qHWGaH+abclPEi1sieI3hxUbPuoWPnTN4on5agLwQzgH8MFy+has3pb1khug0DnCHw99T77as7nvEl/Yv/+iXGsEvgd9nrofaMR2kupLDcNRa0/dV2peh9Kw4VuFlupKtC6as57aar0PJdzpUNOJgAxFYLil5gLSw9bWUU4LvnGvCSOZPeq9Cw30Ft3cDcNmS3HQDW0Za8O0vWZJa11rxoNrrZ6E1uvpsnXyfzF25jgViRFynJwIpB1x9CQqJXh+pi6QhZPz1NukG6Meq+RH7fP1CUxShbjQ8zp0OO4pzv+4jsRXHXB3xtpJIENE5DfopkYtgw1xpy3QWCqm2tQtLM7v9EFyy/8VTa70monKYwPrPinmHp3039aZFrlGOdsXmA3meFX5tRnAMi0usg5GgwE5r0vw1v4Y9TOtaaI5bkrwzpRzNYtjvc0nwTljnuXDHyQK4SNgVjU80k7EUW/6NnlYcp2yGDPyZMxjkH40CWifc6idzMHDd0QfC1qmbQD4HJsqKtayMVsidmSl5DfXKZ1/hjhLbUU3Waq5IJG7mCACBnpjvxWqsa/CxMyNlXGeQF0F4eqMgp7oa6YUIBoktrz0CmP/DsPygDy9BxJGi1184lRMZNgYK+EPX8Mo1rPbywn3YZbpTeRFe0ftXT+988c7Ur6S9Qe/a1Y9XfkU78ql5lu68Pc6V486nLkUv0kx0l6nY6r59Uk1k+e0YNvLsM0b+6NGK9WvpSRAefhtoiL868/Z+tezthPuHl17rQXyarnD3jfMiv5y/9rafzCun+1YQmczNfNeo0E/ekb73aDoBs9zLHt7Cb8ZyUzPeU7qm9M6SvwGenj+VJF10IX29YTLte9W6lbMqKRf2Q29NPXwOrdQCcPDW464NG3/WMOkNV4hkp47H17Fj2BCcktpTbPK3UWc6xuW1ZwPvXOP4vE28Nh07QkiDCuz524DaKwnr6SlLFdaWA5ihtR7Z28fIi4QjuVBffjUlzVgBskj1UQ0n+51xpO6XnLHrfJv+jd7xIxGg8Y4AtRBTF0ZNXiKbdpdF2hvtA7N7HibqAVfbdT/eT8qMCNIJeY6L7DDRCyIEgzezA758ky68aRo5T6u7FRduRADK3fDiJVi8wVBlRRMHUGjgJqMkO2makVu/tjmxzbjNl5hKjkadH6TUTydT8uEsK38NAck+dFfIcR6Oz8rXl5ijvSUlZHfm85wl4bmTTjEwK0Tyo2TKKKmCpcX3jtBp9n8PrtQYQt5eLUTxVZRU6b859Snp1YFYU08f+LVjskU2Bl3b7Ve2rE/bFPSm3DwDlHBD1FLAnFkm4bsVrgaOY9f8pwHxMJbyCpWdncSir0HKN3AHhwCCwHvOC2qQUzOKTQxH2PXWXXdCHutqZfA3CI1/o0qJY48z0lRFnN1dX8AnkAALtKMdkCcUCmNV1bL2jlPAxxRC+36MKuWRE2Zz5ZIAfqkFBlCakHq3fZ4iRonqSoskpWfCv2EgVDwerIQ/UC0QOhnBpGQgz/irP4bY1mx5DiI1QbLsnFPRmH2MOx8ZpbQHaI+PUobGhm0sXKG1Al5Ms26g7c/XRQE0utOd51oPCtac/XzQ770jjlAVUQzBLBIVx1SQc+Aa5jXRSocPqXwcTKFkfVXOzJEbnrrZVtMfYS398HcNeYWY2AXF7AktF8mEd2HWt3F+Anjd7cZ3HP1yBaeJA2U6hvWK9flhr3Y8FghjBEI5HJiigEoVd+JeK+2jgB5gM9AiT0IQGjZM+lpvK1N+wq/OKaL2ySDypjTZ9PgAUdGu+zzA2LUgfDGa0jRydJA6W9fb0baLoMVEpEVOyls/do+rKGo0UM73RH2sgy3ru4/Ta9gpd9o0dP3sFboh0QVSvrbY2QOMpyUy4fRhALBNpJOkxPKjKW2C1fq5U7UUp1d6WV/rqoFjg0pQwGjmUO/gse4dG/YmenankOqiAth22Q1hY9aNxJrVmodHlMaJjJ5mVkzUSqry+ungVYRD5wWeHXslihwpJOhi9EINZL2T61Uv/f1XYP5xtRL04aVoncCig7K40c6mXQMXbfbbw9vFAwft44ZYOLpHXWxjLC+/l/Q+jL9p956UUenLcYQRHnv00UZa3SFaxzo+Qc+MwB9SZKP+GhjlA+0DhGcJnmpqHhHNJyqba2ypllJKQaR3bgjHoAheIpu5yloikCSxh6vqFtyen6EGfgBxcWKGTKG1mRNKOVpwdiLsmOWt08PqR1zrCU9zXKV4GkE4BxtHdzxQKHDxMN2cyhCPPUsBBHzAVEW22HnSY9uiL37Y/Uu/g5CcGn5/+7NyDGxHymI8a2VQ+c7QDwovJNCAT7aNShxLTLAkL3qxyVtsgZcxGep38DMMGXZodeO9gr7b/OAz+TZ1nSlcBSBvUsiA9OqW+GZoSbhos+MY6OybrJXRRqxOjCgjNDszSVkFubQ4cbYBPkOFKtYeEnZrt91tTz2xzrzeZJ20SRGVO5ksQF0KgRsf18mWLjq1VAfr8BQ0qGM0Hj+9fuT6rX67/rbTNQVIsau56Okqy7TenpOWgwEpaFacaNKpUyW81fRARNVJ7yCMfUmc1mDro6ZrT5e1ipLbB2+zmiEzSjrN9CIPLtASRUkuDXyitHBfVo0jicxcGYhx53xdBe2O1YJRiLT68bj1y+H3FiLyovfDZJTvPUyOI/YprfwVPHioZnvyfgZnhY5f9agT+UVEels7oaLf+RVsol+lSOen2S5SLrkzHdlYdiji3vueymjyQXOcCCP7QL8K+g2LjrGjTipFn/JnoC9e9pEeSMiSTGZvUc+xca7yHA08vopjGYqCy0oWhSOpOCqjZ3tckUjMnUy+Mex/bzKI+o2QxzxOysoHoNJlEs3O0H65a0ioibBEORVeSIKLQO3khl7UqUdqGSdA3TqLX3F5qBR3lnzBB73zIizGfGDc29yZ3T3wmD18yKTZNspWrakHmkFhETG97HhPwhZxkdAx6pHScMDqcJ2M2Ne3zWvZ0bpJQX3WPWxecu6r/AzDVYJnASGkUt9BQos7y7TQeqhorwfhSyIe5+jYrd/IdY/Q3hFchyEVt0mk9LAhU6p5fUes9PKEchEmIrsHhn5K3G4Vbe4vYv1U8ZH+QDSfAiejhl+555RkFhjBzZq+K4iLP4o6ZX3rr6wAr8F6VBuVhXnZ3oyBj4dtc+H49Yb+ckscsuXDh95fedbZ8xC3jSg2bRMibWdRAgDL5+yoDYF15dkJ5TCrvju1Lk7rutfkrcFMtFN8YYWWldNhPhtzeqSZJtwh/5KAJkxHEQnkFxEijK5kmb0Q9t73yfhrgL9OQR1FzbO2JkV8eykXwUHP2TfVG5EsNW0gxz0/ZfEoBGvLCD8BjRR2JLJEp9LlSyV8YcI9LMcD/4mlgKkqPUTZxxQ/j5CPYtYbARRyO2K/VYFQP3hZV9ML6chtH5QtvKHDKv5aG8TP+qIv+aXlFnEKFBxjQS2lYmNVCp43La6B+39aNITwnF/ZS4zLAZnGVkW5iGneUgjgHzk2onYuN1o87AlrSkTLu1pQSSjFgwKrVzALV7fMYSJjIzbRCCJA3FtuUgeIZZaw3XC5Ad6GBKIoGDO4gKDefCpcv8ylX8Q1TDp8j3AtUJHayZsKQEURM2mShDVxW6n59b0gAwVTwZxcZ3QJB+hC36PtYRQC4RBJBz0YujbrwT243cyFICXTnyCDWUCBHZSa5jJiMXxTt+ahqylTbYVEQHqM3+Lm1xnzVqYdVh578+Dz5P+rjzo8skILaU+1fEnmGlouHET57ZMw4ltQ5JGNDTwzKS0Cdu3c0lKef7tty3lCW0KTFgKi8Z17GwAXmg0g0e0JE0+IgBK9XNYO9pFEOzPPDIgZdI0WXnOtpQxv4tY8CaVpSRCMHhjHiZy+9HL373ETOPCBQ1oEI10+//iE5HyEbcm6jHqpV8eERcfW7CHit7j5ZZrJsuOCt5Uc/VJZ6bCJx633fdIu/ZrtCYi2NHwL/EURcNZe9e/H6PXhpxMKDz/twE1hyN9EUItDJL4HfQqdHmviyJgQzfreQwZFGAIxsXIwAOUk68XvUQzsqHTb+KcZj0ijaABbfJOS6YQFoxVJGBCLx4xI78yLhEIUJs2yywwfpri6weURV1stNcu7iXVt8TKtvJdMTEuXjW1ioyy93jtAjxOkSF86SNyQlIBkItGDJh88NNPQcTk63Wj+SXcShZhmoOjCvdhcQkdAtdprAavqI9+sSo/6zqWlrlziYTBEl2ton/WbHITOqIJg8YNJfIGRrVIvkSQPjiJKOoymq3whUJuobZoDDZlDJTkeZO/vE/dyOZvCKu7sEuOZiCsC0iPcJ/cKTmx9GSz3M02VA00KtfS+uZ4VCl2PT7HAwcJ1+dLSxZUAl8fWf4XhDUuAStWy7KqJ1OQiB5AYUSz+lC4QC5tL+RnhhDN1h7BPAIBy6OcIxYByhKt7XuRnFaJxz9YJfd3PjkopxsNAFvDPH3U50d5LYhLfnXLuAZwdXiaSt5zdBsCteeAoKuOWBH5It0R2kpNJ2saqi3BOS0n40WhG2RNqbHuxQ2vJodcOJd+1CA6QGqLdby85EpEQ0zIGylMInNiOxujtJwnRMND3wVZFQM0ro7riqWhnMMcRMQdYeiddqimf4Gpbl+3m0oAymT9sGCHfZo8io7qHVtm9wIxraJw+iYOcWzOzj3oi16D0bMJpXIxsTBU1P71V3JrHHrdUy6StJIEQ6paa8YZojl7q6NOJKB5g5TrbBk7pOlqj5GTC4sbb59T7McKtS2QfN/etoxvghPyuqX+H2YJhNqtMoTPUzTK4NkbM6tMJfR22TMxpIl+Lev97kHiAI0W68ScA4MnFiS+ssTxbZsI+Hr0qsLPLmMbS+QL9nnOKvmWBvun+vqiZ1KEalYdM1nQzHETg+EGlUzv8CThMPGXMtj4LUVUiH0csOwZwPdbBpVrL6nQB3VKK1PQ1L5uWxDZsKxujsSIDiPA61VOYW4UuyyGHFpCUSAJ6VnoFdoX+7M6UG5T3qoqrqgC0uY5JYtr8piIi0naQigTFtQ80Yk/ChSah8/kEO9pLYHKl7OhUHBJQV3iMW0pHhmFbhSCmqsfJ06ZNwgVdwkCz2isuEqqQATjhapzqcApNhUXJjX4R5qPfMQjQFC9EFtVE6XY/16W2pjhSxSbTqaDJyvv53zRH3NKzBs9pPqFD1HGO2i4Bf9SgbPCs7qsBzyiMesXr84PODbZwrlkdB0Gh82+T0eyMpt2WclCL83KTzuqolcOS1r4SO6PKSmfiCd4BOOmSAlDU6dXdUR7Poj54nBuDNre0tFwRIht2krBAzYsqijLbFv0GS36BWjEP/TGQdSEpbIeu6KCoFOkBDxohlDLWRQQf/64cBFxd1/R4FBJ0RQ38nl6tNNpjeSfOjnhEEMu+CRtHRwr3mqrdIdG3qdYReqVWD0Ig8S+9fEHSXkbSGcfgJqfnQSB1RwqnlJXG9NejnfMP61BVVQ1S6H3w0z0mkxysE5EhP9dk4xk8TStbGdxrC4LqRKZtlBVEiurYF6HpFyhzlBrjGJVERdBmSAxihAmip0Uks3OnUWhy1Z7VsZ/YMk+rvVPAigJgF1d5Lr0HQ8bVtvVM1/+w2iu9YapQhmHajC8GzKpZPzB/Hpb8QH4jJEXYYLbP8ZWCz4PvEWqWg5PqtMppzK6mDGm309CrRqk56LV+APpaX7N1rYuizuFdoKGwlILqxjuiX6LlZJ18YJJIDdrJ1l5V9UpbPMlxleHbNL6TQJHIOg6FOpQ1OwrvoeCcRLSydU56lusBuh1+T3B1BRq9tIiYuQqrTuctUcDozJFfbbB5Iu01aRpI93nwSU1JEnHmk3UnoFC0tJ97RkWQf1wgR3VvPsCYymieNfOE84g+uuThni5J/LwVFERc8Kt8WKKIsitZe5HVTcJqAwwgUSlOxZvseWozF3MoJnG9h2uGCdiFKOxXTuiJnvSdWzDHv0qxA5mMixPaZwtoYbasQpPx4htZeInEAHVaSW0vOrp0AGDU17rvDGGNcy6zHZ35hBV7EylnDUqsRp3cw+GlifYoKk1wptcqkUIKcy8T4JT5EKQAnb4VKd/eBrGmS3HSl39yVZXzX4BDCP3RvFLKLvgxqroKhcZwYKsn67lamq6arvuYpXPEg2u93LOnpbH6ziHPLiWxH4WxulXnznhtohPe9R8IyWy9+J19eE4AI87V8uV+U/H03HaUk3FHCrGrOrVeB45hhrq+Z9+Oca29ktQ9uhhY+FFDGA+JPkdEq4mnNdJ39OEi56BwQPJJdPCSK2ucmuFdyStMdwbqdA+YEWsQkaD6WY2YY13VwTSie1D4HZbopPVrUW9gVS35iXd47G9MgxS19tLa7AiyxGnNse4m5MmkF5olkVWTKXzbB/kKtL33LBWbZve8n37CVE0B6tZeJm3UUZLTDRXRbnf4idcIOpnp0XbMJR0UDNDVXYYFSvP3kmOhab8eCMkhORZq0wikUTEpeBvUXWqZ/Zc/Spj7ODpGc7JMZZXI5laMR9nVJYFMIJRKkyduUl9kYj2AMsWFahvWBBcrrLqk9OZmrKY7StGZDgoRqbOLzGz8Gt0TxyiTjtp6LfhRkomm3vGv+hD8Wa5aknqb7bOJFT/SiqaJ6TIP5KCubtAaBmmRQGHK82H5xC1BJCCdRi7xBM0wYDcCpy6TZfsKss74apwUdkJQ5mhxvNV59OSEXot6eNxhjRe+pZPwwUMAq4vknlcLb9+RRKe8fjDrKCzrf6LgWdR3/YaIOHSEQDbOJKBASkMfgp8PjCOU4pfdlfteAjl+Hw/jpKKWyp5eQl7Vl9zG34MIEZYg6zM5J5oZwMtRwNdp3MDFPwfSWK8OYz52iIPy3A6q3UIZQHpnd6MoXBVAM4hH62yWSXiIpdTxW9pgtHxtyi+O+lJt95kCvsOMUNSHxhS/HwkWkGJtmsm9/nKKKj+l/CgvvKrDS5ee01YA63JMymDZCmwBCD2MHbdRCj/iKpbJDyAzaRlVcVvQwjUQrrfdS/sIzP/rrfsdh3Ickop0zlUdFJ1p8Nz9Lw08uDMgEVjOnLBZGTLxoPMo0WOTogAHSRKyEO3unzRgjcqjG+xZKaOKoAEqoI/mNVWYdVaL2NG8g8IYk4yiG00PdkPMoO9kGMSGSSiLXRAPPbOYzBMDK6yUrAeTajYYKdUXfFeiqZBxomROqY+XqbWTb3e6aX3b+Hbp/eoptsrZNBmBe3DziImML6LDB2xw/UKFNXXpSGpH5F7XE4xFw5xb+/R/wE3ggZkfb8SXva0RTkJraxkda/PSlJK5MZJ2FPRx+WyUOCVBApP8+yHz7L3SjP4W27b7DUzihNpgOzHHpHlXoZjV87HxT9aRQq+zuqYrek+OtyVCjspPdP43Uzzb47LFk0T1/ly8dni7+ASAfSjYZAUNC2tleWUZqS82smp8kdLNkdfqs+x0rkk/aWXHyX/Y0+ZqGsHCgTbJuvpGs+Xm+htuuqVIxlZB+Nd2FCElhdC2iMriwCHp3trtAD9WVuYadHcTDkj5AtQiGABz93OX8VubSHLkcVs9yDwvNstCquEOIp+obItlZPQbDcUSPQZJlvQo79fnjd6ZxHjZJk68XMmEo+qbiERSsgZARDql5J15Ewq5Ew0u+5ePW6Vf4DzyPa2a9AWE6nZIqLltKdLb7fuKTt++JCpM3tEj4AH9WuWxZ8UMrAl6m60QziOkFGdnCN4GSojPdcWH4aM7d1rBo9ts8fbF9Rxw/aE8NeXbzd27NwIeOyJvn99eaty9Eu5z8JwBj4CNiGxe8BYJZX3ux1UWULLjQxwcl2SEEoBcj/T8raBuXjt3023aGbm/t/bCpPHTuDaPAvxmok84GTIP1VejWCP3bTsnCDIC0cKnFn8lvxOb22hDzU/aIlpT3uMXkr2hlYVi2IjARPLx+/KYD2jr0nGjXxcTpi516TWujde61W1VylSCwUd2OFYFOuDSiz7fnU/d/xrM2LXd64tTJ3nsfWNsSgDpG1PqueUSYaA7ZBh2UDkFnNQ6XExMbjys92qyUXSjabfzYIcP6dXXAMJTVeQ5jIq1sFnYH55vGBBv4eGDhd84rKh7rS2fYOCXDJ6O1U2JmTYc/9HBxDo2b6IVPeEFT/CJenBZsqGcJ3aRHWjFcLK8piuOPDxucD3PeWM+R97KmEHMHtZboUXwXtyQHWh4BGrd0CcCxy72BqcQ7qtcSnkxvOiDyv3VzpVn3/hIwH/hyPdVqmc/nbtN3Jsb8qVuIULYM9nrQt2i1Bp0RIS4d1BkCGRGPxAp2Qf7FdYo01zP7ABT7NA4d4bwQ+wVRtktNevdjbnsKWf7BE3EQ8a+TEv8kHxFUnmLzWO6w4tzgDHzEgNc3cF6fr+vqsrHM81zrOj98mP5o2C4dXSukWnfXRK4GN6/LO2k8p7z7y2RN/d2RxruNwJ8ObxlpLciYAwx9COWRibHUU/JkOjh4Aci+jB+MSakfWCxfbdWrvCklvtdbX9XWMxSb8Zk212pma0S1a0DWMT3MWZy1LU+rjTNZ7HlqKZh87zrVPRB/R/38y2U3GL78SVGSvVDEH916d7AWF0Pf9jMfzibWY3EPtgyx28rOChL2XX4Szm+YSC0rX65p/HcxzvyalP76tGDHx4cACv64XwuhcaPMGlgUuAxwnC70uBLmMijGwNjKwNldshfLZQSTTrrIhKa9pRm+cUBkO+5MkmsiIE/SASRc6KDMjRRlGdwUD4iBizTYEmiKeeZU/mIWjBHw0XfruwrAKKBOmuL/BYzAlEOyIHfuWHgIG0ufcTlveL7EsOqp+SfrKfXSdrvlVGovFJiKgeRIEkbitsUJguvL3HGU9ltNonG4JjUGetQwdhxss+tAX/Y1As/ilGjaGLRH7U+PcUzSvbFIWFFKUpFTcivBmsd7OTXQt2QmznSq6npihawE1CULqyZK6QJcvzohX2dc6XZumL1DFV+4T7ufMRUct7vpFUvFeDi1URd5q1Y8iGR3mcsWk4PvPUTg2r+xng5reaqdAVsaZQjVVWsnlStegtUKeshw8FYN3byPC0Zhe/43PnsbAkdsE+8s/ti9+Tsp6Yne1s3Hois4vjS+t44S+BrtOeDj8J70bkHd+Jiu1lQFCe9BaRU9aXi1vbG6YqkBOG6gmhBxOIKq8N2aJ+bmGF6LF0mob1bG41P89zySOaJLI2BHVA+DkplYpd7c5Am+3CXsxzDVJXHBAC2sewZ+UWpu9p4W1HuVuLxZIcsV4vFBFmsNqeHyFbVLY2RpZo/vRbamdMJzIb3iCwHEOBj2k49gjbyVpZX1HCRGfXUIO9c05YySfKwJa0eI5dPTSYrb3SekPrDLXoewmgZ0J08+kpEWl+gCW8typ0ZwjTJJJWNEtUoJpc5pMf8aQQLlpcQC0JKK0sfDRFJoeHUW+oRThm3r2wKsK8zlE6uYTNId8xPg2SS1gYeLq4hdVE5CJBq3wSkIpP10Qm+EEnQg9V+EKjWZrJxt1cw3no1DXX5VnVjhyG/4sAW8c2g5tanQszPPLe14hqwRYfvo7OpJi/uwhv63OamZUXtq3xjQ45/XgJlnnOkSVfi9ba1alKk58aZYBM0L8qTJR+5uLcJxex0z4AnhkPJ8yMz4xtnaVhLUn+CIFpf2GuLpAF5tD3dp1ccc+LFml98U64Mqn0D8sIKo5H8eSGMuzI+nfrocq/Eum4cR6sR8NxKTwV+/NWoTjZEt2rHWrEnl2tDrSkNRxm/3j3x8IfArvRCSJax0Qr9vTFJLLNPxtwiV1ArSAOefiN20jZUTVedqB21+d9i66hUEQMGjlD52NHaZqZmrzNL6cqgYW16ZWbIPXSFLrDad6JDe8udc6bcd6vSwAr6GI4HKA8VGRdQ1eHtp63YqTZgzI+xHiYjOl8PLDRQffIrmiak6apyOkyS6oSSBayRNrzd+zAKqSklzqntuFb3bJw72H6TXiJQZLor95YWSbtot8+hh0gJDElmwjNTFQoU/6eAPJl8yc+NwBYG5/ACt9Drd9c9M1colzNTGVkkqasP6dxw2XEqJw9vvkpF6Yn1206aRCTWylhruW0HIchyue+h2BvUYXVzf91e33/XgAveENUc6DVb9M/8o6tFLISq1zRrCYl8ajb6mqbw5QYH5XQmwYnLoAShaZPJMSaz1ouGaRDSizbgE9PBNm3JGnplT8/r0SHVLEmEUS6lwlgrWs4gmB53GFFCQqJCRcnB7FXq9uHzHpMT2aGywlSAs+8iJ3krJXF7yPepVgTTKF1aGoITjFBE6KK6lktLMS5IcBw5h9L3YQPLgHOAALWqdTWLr2HmEHMpei+hV2SrDpcldfD9DvoGDNkAkTacW6J+9SNjMhyTw81vsBcaAh9jLzJijESPx+uRnNNpYoPlBAVakefVoB1GKUk4h3Da3rUpy6CDGyL3wfNAAImobc6iAz3zhyyVKCD6NhG3QalQnLYaT8R0M2CEyF3tsKVGUSpaomv053WFSmPCRs5tbQNyty/R7XF5GrFRGl0qRxTRVgR6Nci+ouGC4AqyuP+hGMowGXaUd15n3cOoylEx8EzsHho9av5lvaSqzf1YazR2Isrm8f8QuMJrimxBJpUS3qIq77NthDXCmbbZjs74IQrOC2VjRd5hgMmRXy5H+Q2IxD4asJcx26c9PIAgGv0rpPxfN1r1Yk2yf1MNUOSWitQLgtIcarHQqZCCkPcJ6x7CbDsUAlk5mGkfIcsi9c7GUbSANAYNeFAEluS8LqHjt7BZ9dJFn/BDNXcm8rELEYBn6kRKHivFt3VgAobb7xWXm09y8uwdzhl+QuS5yRCCsGuPsIBgzymVaYWMiYuE1i3t0ViYtOJtUeq2hNJotkwrKSX+1k72Yz0743jepJjhjLngjNRZCpnW+mC3XnybLHHlIakJK9qzPJXbPFFpRSL6dmn+vMCYGatOCGSkkG0sCtszHJaGIhchZWqefjyblHbfDqMJNOuQaNxsCQJpQcKIxkRLRsKtozNBdEETAjAtz+RsmzMlTX4EWyXxG1C0n+7qnZRYaFf/6qSeKZn/g4fvd4D14M0Ow42imQ6hj63rBumaXgFfHEOsp1JfC9bmkCemKEMkKq8zZONAnaL2JItolyQkLtE/6Ku6nIxwgo8hoSpnIgrBWs3KNmZCQGAf2+A0Gz2fm0SDgm9tgPVruNcTFUqcgjQi2q6SnI+05ZxDpY1Zh1i1++qpyn3xQ4IIYSBz1OuY5+1G9PN9u5ERMn5GlC06OOCI2T3rIBvVIiGMLsVoBatayKTni8n5WuJdCyiulx3wt3QPHLL1oMJ+bj4nEwL296TjmtvT8Tx6J3w5htJUY3TYG3YSpBIYvBHx/v4loS0Ajpqr+G12fp7iq2QfJ+rDTKvN5Qec/G0AAGdM8VnI/ykvZ4acDL7J9f6atK9D7uTbX8V9sG0LcD5g5J/9YpmUit0b9qXaQE8vkany9QueEHSUzIHl2i2Z3Zrfq4eVjfsziHXMBALT26Gym1fiBmvc3dZA9m4DisDZzLM7eELnKd9Fhf/a9U8yafi7hOy9y5ZMYrtDXoDrQAAOe6s/CrS3QncZXkalN+RB3fixv+I6fzl6HewCBw7bNMoG2bsLaY5leN0A2xtiqDmx/LWHzmi4bDv72jKeciJgdzM4ddudLmM+n2JcR8XGTjA5Pl5tTt6YHdYQztFI/kHnu+KzS+WwliBbLoDdEQcPwwaxRQ+S2dPr8vUKmLPv6C2tEjN7J4s6K4yGI3tLHsmhNpNhdz+cOZVx6tblRDW5m7UX5k3Q/oGOae6R6QNZ3bwoq/l7jxt9sAwvLBHeEtRDC/QwcrLz1yPD1yPXTfJkxAlkeMLTknIuBedKJutzEw+WuRsoMyxIYIGebn9puQrxSrLyDT24UsEkh9OfSKOEfO8E9/Cn/2l/ELgAICA1OqgSqGBHnM+xwVlF01VktifLcNn2nnE2UZtOrluEi49gOsE4Ua+bwAnN9ILfWEr2Zrdm3pGQrfNsyR9fWDWc5xrk7l3dFgEICiedZzqN9XOrQLrZ0VrsvybA0JyMEwccuOElnWSZivINCn3XPltQ5+Uk6/PzRWm0qC1RI+c6SFUpVp1NmmpQjHc2pJpWZQbNMb8wUVBhHr86hanr7J5RpJpjomXaK3Tx49LKcu5kkwVSb6sRNI6xmXJx5uR5s1uNHftnF1MZJfJcQQ69/eVEiBO0bqf91R5uVmsCmiupUAjOvIwf6ZLyPgpgjw7bYHNIRmM4f81UzfuS5hk1rCsKeNZ3RZ2v5e6McqGprBmRoGQiGM6FKVwdnJRqk8rz2Qkj9MweRurtBifIqzQ5pPjsUAmP54FPha8veZ5OQ9Wls6v2xs5JOe9I8LzjHzXrVfZ3rmAFfx1bCk4GM9KEoVPTvLLPwHIizx2HjgAIx3P4VYMmtawCpN19PcYYTMUle/3EzadB2BUkRb3uoc97BLNDQ+HDK6W5TrHme4Ezt3TKTTCptuZEuFONI/X1CKPzl4SsChREn7srXtL6ljGIGGqKDt3F1G6oFmnZRxvre5hQ1C7tbAsQVjMaDMexQ05gosoB5zJWFupql2wJhOV+fCoEU7ttJffKdtyxPoewjOwVCUlRGhoU2usKP3QhqnMr801+1kKVUUwMsfZsZYBUwApvHePS7YaQwv2D5Wf2/hgqjudZAkibzOH6IW8dMxtIag4WD3hnYVN3fiwTxH/0is4zJKekaLtwqxFvzAkh3KgYGPNlAMXpam7UO2rgF2oZ73aWs151DqYntHV6kbWnuWu7qr8IPTe1k/SngzdAczecuDGVEw5G2LTOHIdCBg5kG0d4rmCr4Wz7JsHtA/hx1cX0xMP75KF5K/KBnBJqW6dCfnbE/4WetV0ln8LiR/EkyOD//+mj1Yc/fXgTfTiFWB8LMdgXJ7npx4bSSKjAumpKTWRlrwXTsnH1Zj3gCBFP8IlBFCYO1CYOKHRyEjxRecIyOLjs9woQotp9hYU8RdL+CtOKAUaeGFuXMUyKfVVhOxOD4KslA4g/U5PSK4PJxiLmjF0EgM9e5URhlFm4AABHbkCIvAwrDYX5NwI9nEckDVdQ13KDfxC4kIynSkv+W3A4Zza3T/gzFtYat3Q02Yyl805ENQTZvHuVTRsSKBbD4FHs0lCBZgWhElfCuoS3NMrlSE1SPD+OS2KuOjG7w8MkmHibPYmfet5MkhNh7PPAAJ9ReW2+8lReyKmVc3lPYfBvV/J4uhCKvNJqNJ7qA0qYsvVeXlSXU0g6uUJbK8vVHOGU8e7yo9iyYpioMDhJ5cwqbIIn0eXTGtm1gRUwsv3qvc1++hDAp/6lvbFGYBalGy1Igkrp6mpjZ7hzL90kDWviu/4E+yxnIVbtBWZxUKlY9QDEZy1Hx1Rnh8plBn/j3opCKkLTKViBzpHxhhZu/qlJgIef9d7EV/3j069kAWQm9HafPaimiZbHSXpicJhZTQu1hU2qptuupDvE+jFkdYa/brDOxd+4iQUr8ObTdl+vORKK340Zy/DmHx/82fdEf+qSpw4x7l7fTCQJTSdlKXaMjLv/v12krjauJ0PkeA+UTTVn7Knl3ULDKAmNP8spFptkNpB7mDJLRRkG2Yd10zH18o4y2nil2My2oDnDcnAGiWL8tIsk+gGAmxcFbfYJNOcGxIEZd73/HPqDlkR4w+OjBTXXDDfhbGSNRtZGAlxhQcM1ZmBPP9LE7GwDxht7CudKiZmtBlx/9VW0lPx8QbPpEcH894P5vq1lot+Z2ywjlanhJXT1x7wKJAHU2HCKFFbDq/6KpqIBs1QxKOr2HxLsKxdhxZW5Gf8Q2JuH5Q/GrUgkCZ3Cnj3TKFJW3kyysKwmtk7GV2ZD/ERgJ4xSsm41rJOJuxEbgSd7XHRjyrZCg4CMJPjMiGoIXJWNPvjQx2liudmWjDfWquUbklhtRAFqLdse2wQJSv7RJc/CxAkrSOuYVSLNOr3L/xGJLNV+3qsUiH+8lMqSJFuXg6mIoqGRRYEEy4yqJcliJejqkzUVCIVlB3TTMUV8R07ARokqNxvVzEDwRCqstnyCImZtjQa2VRAM9UpmbIgBoVOA5wZR7TwTWP7jK4ByQZOMY4s7YZSiFrTCl67V3YOURKaFlyFF/9c9VP0ztjYi/7kwXGmXHkZVYIaWiGIJutrJTRQHxnvlBjehcW888iEW03MPCf+1ymGUMmueCO3ZKKdx78DJm3YhSttFvozb6dTyMMCk8qZqFlYIXFIE+LLItnp8YBqim727HO2LXYkrfGNi1TzaYNkxA8MpUlDZvvqTaECtAWn9Y3KpjFVd0tnVp0p/lt0ca92MRiWqrhXsqtJg3C17LxINiQ2SD7yVisPiVymKP1M7YjUlLu+NwcLK7ibTifxdUQTAFVS6cnEUFoWV0MX+QzaIGaVo39Bizh6UEPLJkxLVevvh4d1VzdtwLs4jSVSV3phIxOoyRyeEitvkkeTg2sSOd9bVQNS3uVh3r8SVrDFUJMcaStU58eCZFFTWxgiRNsCABqT1RqDeANkopDKxXuzg+piPnBBx8+T2yvaLvFCAvs2l8wNMuELlX7VDIJ4ZuIt9nv/mz3iFfFk9VMmSULFmi+8IE1yQ96to0ejG8lsVHTf4RDiyzfrNjrspHwFc/en9vKWgeSBuaKUN7iYjSRZztzCQ6Hh743EA7hS5XARopWF3i0kC8zuJXGUzG518dxeKHEStNxpQb4DsTahiIyno6L6JuZ6sXGVzz+EkFogMnDy80VgtKVrRiEA845tXJaPrPjFtCgnMa9DU0gkC9bvwiwIAVXTc0EJtR27i4gDK0SWV3n5HsOlPU2tGAgoxNqNY+WqyjhpsKkFNVkXOcpWO7/0JzFvQYvHNyrFFhXAfAqzpmmVTwdHsiFv1BOjkKmM6W2TxEVQvhlZDrTyMl6U5b39EGr6kwkpUkrO/V39j5A0OXRWqlIyGAIP2E/f55V0nMH/g5Jy4sC7c301pqj2tauyZsqzK2y9s7DLKZSYxJAHyb2m0npviGLUMZNjRu3YL6J9ObF/C7MmGLBz80WYuSjoQD9Ky9C7lo9ycofYbX6Slq9ntvf0hHFndNdRHg6mziT+7tHUDE6pA9fvMrjkXV1D6D2js3WBFIpdL3RcCJk/HYB5l1roKTW70Inoeh+y+aj/97kMGOPXYkSLO/g4pQvPDhwsyypiNCQ0yNvc6/M5agJ1/bZD5UAPGID9Qx30rODqZCFn5MFzGzAVr0uXpela/kdI3t2ki9/i4fuGnSQb5OHEOhz6wkoLfHWdjqYAq80yywlUvqXzACb7hMgljpw+2etYjZXOn0VST31N8/Oqg4Iy87J5aSoxaJgC7ceyQlS4JE8xo1z3g0267UP3EdhEcy153o0EJWPZVy+J2xyNMZw+fYe2uf+70hJFbCG7894Y+XokXnRMRMxHU01s9rHejhlYPBGibu57+UsDrLK+giXUZ5j8n2bLKto9zw3CL9E5Oh/W6ZA28Ooum70cc/MtD/qWXrLCH6pEK+HYrzF1/f2VdSHXVs4IdZQkcvWvOMIKv7D967l2n7HZD9tx9oKIxa8Fl54V/jkMcA4xy1eu7Da9FJtVfZxXAzd3hmuyNFOQoJ2Z//cPXm0UabiCqscEG1ID8oUyLY4VUHjdMCL2cHD+0Q8vlD5d9RzcDZUASxobR2M64k1Y3SDcy+dAhbcbsUHYKr4xcdb7pdvTuRxQxPxju9CazOAeP65q1psI4DSj+RS0QDeqnO66+AicEgItlCPA1P9J7r2uIhg1WNMZZQkvEYBfUo4XUtYyWkwsCkV23t2B4I4fWjsgWV+g2kGdMbTpUH4KXMkBX74aEbxU8TxD2dBUG4hKENMIJ8w8V19IItATJ3BiqiLL0gML24cns0YVurtWai7SUntaj7Hd1novMB3oTDbjG/N3p1aVwS9oUrH9CDVHkpCqqkJGfJibBRRJcYLALQzjANwDGB99QyINy+IE4//WJFvpkdtf5oe858VsVp7F6owLeab2S7+vGYj++7Q96Hl/+d8DveZru9mRficeCEkindPVRAKUD6UAV06DlHUnLOrizCevln6y/Ze+3cLeCgfqwMtDmNxYo6t8t+o/W9OL0kdvyu8prbtHPiLsY2aHYVBqpEk3FwcJ4mmD/NnHCBvLXVo9FPJRbEUfFKJbpRJOgA0SqNAQZa2ZEf3PgIE+TvQmTumN6Efd15TeHFHbwnwNwx/31Bl+tIlxdQF7KX3qadufQ0uCr3a4DTXMBh20yRXHADEdZTCFOfUocTKqcjONMHrYskR2Iy6hPgBaxdEWWKVrkh2pou2aZSxwZ0suROtEBP69Cqu9wZNNW9pq33MLv18Tjj+KYcBLjbzUgIv4+Sn2wg7Txk/P/XdwuRRSK+FGanQToq9TcbbI0oLAk0YNu7w2AqDj0xcOKkejAW4LN4j1F1iNUIC5+eKMg/lOM9ONXu1z5XK2TICZkSxT+dFOX0S4LSSBDtv7fJD4RIhuZy/Td22EMVztI33qU/wV/kZrJR+KgPbNxfMmnmAlJsz2c3/4I6O2gEoPmbFRCpmpxL6GVPC6QVdpoZjr0JEAdE/9FGWXfUNTdCN1Sh86WJOF3QFuNapKQAb8T05ivXpznNAgn+L1+bmhNq0jZLkAs7ezidiXlu/7VfcbKnWt+2BKXFGX7qQPpByxiRq4MJqcrcX6+jErOLYtPyXwe5Zy0re9n2yif8gSEvmTHO7J/upHGWq6hnHgCkn9iSDWyl/RddZ5265uX/A5s+4KvxtR76UpZmnk/gkrwXvZPN3NFiQXt88mMu3mGVOiOTfbJOF7nmOlsH7kflcwfcIIHCsC3f+FjGKTlN9QX/MXWjtv3YytDkrZvyHdXSeDI61oqZIW5UpnADnLFYRJsQ4CpRvLDA0qGAoicAyR8ntmDHwoOWERP+rjiRTFPZXlwy5ncI6gjg7+L8RWTj4+m+6WClGALiXpRhy2aQzxRNsNDQ2cu33zTaZQ3mvKokIlZx/P749udtatH4QrWvDJUvThIGa920cEJ0yjNvfv8vAKNj8WvUhWMH745vn8EKRmWvXvSvth3jT/FghIMYjmkTdpIxrwDORktDaZhuq/TFnRWzsSTW3EjzsUBWpp8+5RNRSTZLEr9PpTjqWvG5trv7WKo4BJZQcjH9oMSECnFiV6l5zuVXBzi5qZCTtxMwUzh/vcY6pf7XLC8flxfqoxqo+gCs7KWA/fOZCYmGKPTsKvWaqUFXQiOx7t/JdA29xUnUlOY+f9LOEgJVVqM69y9GGEslNljWibddMO6en8BtNEMlz04vgLhYdQr9kiwJUpQfJSJFIwbJGLaMAPNiBirB0ZLZtHgPWhV9T7IzzGXYDqZOcyltGwUZhhzpzmZBoqc6PmIIsMj+HOSu1lU/OcuBhnVD02MVe4dhzoMVFiE7ddPFbK9LEtV0rEuwZ+WdBYoKjjoiXSLl1YCROaWOWoOru6g6Bw4TkbrfWW9XEPHbnfcXxNZ4fQG7PttUmSGmmd9oXegeKaLhs/xw3C852HLYKDOCeamOqV/PQ51kfGi/VdMqSmMB/j0BPbR+oFHE4VQZSa884OIvx/ba7bNieY8cOgT/IKkFuI3DdCtO7wCF4pnjt7X5kOXU5fWvQrHu73qpAIMx3CkM9FfZZLB7Y5ho4HQyUUZhiVsFaV7imBA2H1ubu2w1ZNYs0MYla2yXXe6qjQSKRKxk5nDZk3fKRNTC6QUAKZVdW6fDck63u51c0WE/CvUgztA3lILKVNEnsqe5GDhnihGU8Z02BSbxdDQJcs17HrYHgOViIZtdkzpXOWkmC97uGCsN24RRklJxRQ63vpRTLu5bCs5jHV2eDnqMpkrZ9ORCPPH4CQb8ooCcKG1nTvqkKDj5uUT1Nv5E56XsSDxXJ11mR9pDOakScBX+WhdUuNziqf5C+Fu32VD59dtSB5ViRiZRwYmxkZ9fyyEtDl/NW/0tT6AyTNd8Nb3cdsH9Ro/LNdPVEBDcSwT2VzlHdtUYX+cMxhlBoTAnkwL9/L2oPFKjRQJWwauZEbWskqvgp4mQBZCFz7kUEQ6IJjEvxkY9ouhMAVYMudcU545tVYzUY0AVHzksYvSiFdpdBPaI8JaQ85MjObizkg8UlORUW3xZgqT1oxgXogkx6m604hEgmDmwnlcpzcgtfgo3W2gv+1DPR/aqD5tgkgdoqTlgFhXNGwVIMaBookbrb97AJl8lSha+aZsgj7d5Gm+F7oG6AyLbMSVWWMyma30cyvx0jMuVQwjXSRqCMawAZpdUxIIDJmBWVWYNZBCj470zrX7fVO4CeZVfax9q92O0N/mU4gjjFbhZr0iWOQK2YVWj1VngGOCNn3uMs5X3jUn2z7aTsIwtWd8oO7YC41yuu6FZeVn49ocRqXxpxgx9MmydMVYqAnytISBpJoIXGHqVaOojD0thYAB6KzgykkPJ9cc/5Zskq0qpGDVxAjnAyPlEB657SsAI+bMzuhoSpyVbBvs02CpaY3teFWXoPIOLtDcROkYnRj7FqMR4FB0yBI/W5mU6to9Q3Zu8QNSKwi1slFGNqYemIDkcKPupSmV8hjmkyC4ieEcMXbpUKtKidHVykhm9yjf5iqJoKHFxSkkpRfoUc/hUMmRL2Qhti0StMZ52Neb3MOF2OA9kWo0YTtoV9HU2lw7LbL+EsBogtHUJIQKgIPBth3jOX8MEkn4Af9SAyObYKtfBHPElu2USsfNfG9UPv7RyGX+rjZN5fbHv/HNF+8yl0zkvcTimzAhVH7A7o1nCA+X0iXFxn3B85fnkmiSRHIhbNhVCQCvkrNBwnbruiX/m90h2iJRii2DbQOSM8eMfjsUC4CK4uMdmrytfcJaXgqA12TZBjYsoeaCcy2rvDX9SvWYUYtWwiwEO8xQ9tt7VvZO6C1RVZpQyovTcFnorpBWk9ArbUDMXdM+dQ82cZzomSUixuMLKd3SKZdVOQKn3BZ/vcWjIM3cQGfLRI7eYsAjDT4c3SolWvFe9pACUimtc0l0vunWoQu0omhN2igwOyH88cW3VT/FCZaj3YkgkzGufWD7AwPlHIOpKn6v9czxvriape+cNq/kmZesU/PAkAsMoZlg0/mJ5TAyZnnNgg6ZtcIf5uO9VILCRMpI4FKoCpXRuWUAlleGjEHRN2WvSOH1YNjB0DQIA5hw3Yc4BmMII/dmjRkQMntGkUKjtK7ry6T5WHwemRLAZSY20z6hACqKuAhAkHZI27PDGF1OBswYXWnlFEV6rt6b1dzuLTarEXhz0rgDiJpXx7tx7s5dcuBxmZBej7NvG/p2OI4mil5SRaWf1iXhl6kzeq7ZdWzURSHzkFE8B6wdw8EGGnRQLF04ihJYBxqqVs6Nabfd+aCKsZx1YfLbPFvVbFA6F3GfZK6K1QWZpKPfWWV14lF/1OW6YgjlxPBx0N/KX4j9wuFbRAJ5rH2E7UkVMJU0h0w2uGUhpQ7PYQrAQtjunNeDmO8vxaZ4BPA3aiNl5w3HpYJ7oFi6ErQ0fta0OCRu1vHP8jWn7+xMKRtjqZxsXnGAHtH+9/yw5io/tp70v7ligpOi5sYRnoM/rKiAaIAoWKhK1s/VPhTRO5Wky3KlfO9nE6xZ+rui2noxgJWH411qawK98G1OEIkzG6vU1i0DabnpzBkugQKNB1GtcT1b5RGAiXqlbUkR2y4z5LhESkFYDNwfOMnCAarGqjq0DJ1wBdUX1PcRXHCMB024AuiTlGyfchB7DE0EcsNLR2B2qHg//R/gL3DEPtSed3K20mHIUqjox4BB7Hj9/6q/sZS1yOmv57lRaJELzxT1iaNSyE+BK/z/+6vApHE1wkAYwx+jeQg/Bmc4P9JYfZmbJaLCPbZL2bZO0iUcv8AoHW7Lel5crNbhNutDAT99RkeVXfTO243/+fDvcOKHJn/zWarsuJvu33uVA1RuIz98VqOrLOpdKuty3rbZ0M8nZpp94H9Rp4xXP4wK50PDwo6iSRFnjlt7vLQ+UGduLimBxpVcC/t8uw0eHxEX9U4/RMH90nvPwk82LLlGr4Xzyn81VfaPDX7drauuZ0e5aBFju/fMe/JHD6muppBQUVF5VFRRgFRCEJ9Q/FznO3UmH5/CfID5fpb0WZ+9YyKaCP67GWJWySVcKjWYeIao3o1KOy+1F2bCX7HG1wBJtd1sbibrPIwlNvoKt4w1z2WAvy/ln7Rn8yX8xIu9RLvkJm7qvMnhkMfFuCls3IUjk9o9urja2yLANivLgrsV6us+W815Z85egVk5VXmguauiidUp9rrZFVqgB0AM6qAp1WWmLaqE0m5rxn/BElAqC5peyKYgV8KSPlNl62rPD7Ma27YWx5z412eD0HovfOFQ0mQLOah9xYqCmBJPPLskpFUPP6HMNF5ZIepmJK7vGgrdnJmgRdKAoop3ec7/3XcJ9wfo76zajcHEbGx19wfofpdu+vLylrto7IKkSR13ZLJ3dwEp8B4rhwo/y6QwlocyTMyp60iIbSZbsvC3YasP+JAZtoJ+3wOvtyyOHyauFOrdQaok3zDq38c2J8XfTR63/QResfQXP1vT1pt/+L/4EpfvPY5mkCYX//Uq4AO+4+afOvZyrl7rar7s/ZGK3cQkOMRVKvSm1F3P29QazUU3az5fbQ+Hh58XDAQevBmQpFE6/ZCDYKO4bwgJVHRf060TiDUJILFXTDPNph75EM9KqkFA1qBK0BBdJv5i1SXQwWW+K+1Wo0tHCwTEhAMdq2oAWQsn2ST5Jt9kUv8ipRHXWOpdq+6cBjKLKSZ5tW9NAvGhFz5dNDRrwgMS2CiBClunSJt9AKkxp24A7Vpg+l5qX7zV9B/cZxUzQ6YVpzN37MGJtUp3uZDCco9VWIS3rOZmjXTS6BolFWhGn+/5tmlhu8ZeoS1UZq6umuNZlXqnH9OAj4O+zmQK8g/zciIfuAyU452+Fw1dKBvXwrNLAvancrvB6m57eGojw856AWvZqMhCX46kyu3bLIglnQ4/5VdKln4LV6F836RGDnl9l4Lb9bU9W26VR4PV2ITO0cGImLAcNb+C0EBF8ut1kUA9VsOW9qzKcpwZRSQBroYOu2osTbxBD//EAGNiJORQxt3q+nzW5dmUI6ds/A4yZNooBrXJkkEtq+VLp6iyrHr2aFCLF6AE6k0Ni4eb1XmpTaKSE8XDsF7uneE/j/v8/52rFEhUsxixvJuItUFBZEzBtypRwib0O3CLexxc0LOZmyoidRdDn+ZX6F/Uksef+F/iFJJtf0z/fP9Iapg9nz5Jefgm8nwJVePrwr0XjlcFeXXIPA0OIGuOCUClNH16Va9FDqPkb4+7zEenR48JqebgHMxosxORqW5/N/kHKc4shky3nyKjAIpEgtzLTYcz0SCjQYEZ7yzDur53/JcMUQUK+BGXVnpw+0nv5YZ8ZOs8slp86sBAIG3Xd620RgMJCAQh//c2mMh6Pkkv+Wd8bnYhSKyTGXgeilOYbLs1t6L6jztLLzwNW3U5PfRQ6+6Qr8N53i0G7kIB4jhC6SthDFchOoFZq0Wp49cyEUTjMCcz7FmDtiOGFmAHFA+JNlZ0fXqa7+DWnnjSse1KvTpMa594vwUB59xm/yW60Lxjj3y1f8w7VjjiDzG5dk1/mrUn3ofBPBe6OLJev6c4FkGJtZw4zEvZ4OO++3Y4NFuqroZupbnf7RU7ZM52cMsdVQKzofMHG0U5kNHh1U18QhisbNKeztVpxV1fDFfBnANtYeA/QLxzVFTVQhzbDW864/fcvX89iwo5dMtQ+QDsfF6LWJLMdX8utVYycgDSNBQz1fn1FHc50LZsLNC31OC0s4hGOL/TqJbDPIkAtQwKAIsJtp2PXCjRuEo1jGuKRJQ6mjqRqsCSeRTu750ayJdKLeB9Sj3I7dqEW94xZIxvqlWNtnEcec5Xvbsu97XwbKi0LepR1dcoz6RR3oOxtRJkRyrvItZEA4A4nfsNr31JuYOoDsMO112C/5F/S44/0iD+Fwi1K5ayThVeSFdmE0mUcunZYMuspACca3kw26HNJiQvtR6sUk0xsYsrb1Vw1l/0XPO8tNxpFKWlYD2I6ozjgkSHC9hXo/2nxTvKrsxb9fFuSNfrhSl7Wadz12/eWwnarkyntTyRNboEQEvdJyFZi6vBPnXR5ZTsw7ljP/30VPUMeBzCwXHdZfOiWtZieSNdqbhVTaRjhdRsmociEjnt62U+aCAcrb7qqldqikpVaqq1IFUxdal8wIi0kWJw2Nn7QCaXItwki0LkTW10n9A740VAYozS2sme8V9gmg5jctKfy8JXcoyVie2Bh5T4V/bN0HGjpIi7H2jWDnSyjhInRzcEC25Ema9KWE6rDobbKmILmY+2eg2VUtKk8zB4oPPQuPGujcDjqXp7T4Y3M91R3oAlx2oaBFBVpabSZiHkTJW2cDV9LUgx6k7KNYz/6E/EEVe2ILUyKhOJWh8CjVobcuuIWKyDV35tJlvN108v1zMeuuVA0lz2yiKtgc7rn37I2l7WTBQ+x5SwaM5Q1Ui1bqhsEonSFZLXUNifCL/Due/BOV9fBa3vTXGdktYsumW8DU/729BT3xGNWgl4Y/jESxbW5suSalwwWawIkgwbo/Gd6SIzxCB1mkAJ8pqm9dNIQ09QlSXpZ9vAfLRLDanu7pWvaGYAAHIEgJmGaZNYp7rv8nTGqQ7311ipNEwh+Nh8qprwVG14XnRUanIktrYCswcAVeAQTxERIUMcRZylFlyHuEwvo//ccEF9YFg52UAHa+XEB8d8YIz5GSdnwK4uavRj7Zo8PKlCkULskpEc4FJwAGHJdipy3qYg0ckN96YYYaKpWLFHUKqghz87eyyrpdbIajyoItdvBe681m2v/ANfd6KvppF47MLrwH6kbZsHfV8/2PA7Lle2PTyK7eVGHrPVHd6pWa2snVi/4WOLklqTuT2zbcpA1JfoJg6CZtGFFFeaZBkkXpA2g9AnNMVXCmDFQ9PJ5Hyf3klboUn4+tU4JstEkkx9N3teloZkWSS4X1E88YYHhkXSvwIhoj4io7LjURSFhk42E+tZHjxm5DTdZU9KE0hqGn2ZG3nK/MK/5iCAdDi/Pmrwl1SeiPoSEi6WupNirxFtqNkAwC5DOdST4B33iNrxEvWINDyPyE5SzWXVPhEuRq7fQxSlXXChSiUEDUWlXbRcPDok2IrhEbvGgw9SSZXjpeWWbGiHGIGTe21iimDy/TT7DZSDE9lWEXNSI2QqEKmHX5Q8j/3E8jl7DCAKRnHqJoASbRKeoZpu9SHlZCv10PYyfIwSR6BE1r2OBGJYQGFfFZTV/iTnV5rPQosiNOjppCy2ZfGZEcAdtQEGv6U7LffpO57zL32ieAueyEAthgFwbBJQFI6XwaDTomNXznEfW1LLlWelYYZE2chcKiKBEo4AZvF3M98/FE+MibrcMVlZs/C7x65BdL3Xunr2gTQJEOODSnDVAMCnIS7cJEySdGB51iEvXcLnBCSSIZqu0bOU6GTKNq6ZceWOF0UlJ6KxK1BFvABvVsV6SOQC74ceHf927x7xOqMdrYXm+r8jA/LAZ5GBWmqDAJhmU9SYTO2XcDtYRmr8VrIk6zDgTqrSiYmmvjwLyqFPOFcAyneampqi9hFwfsW5jrAnnE+kgsSXzJYojoOAWkGw+b53kcuVH+gMEQt7Y1zzIoMYPTUjeahO433KFImzk/fAs5rQKrRZMADYTiRj6rpl2OoLY7GIJzRyXdY8AUqac174nMAXhAoiv9jHIpYEAUJRyNDqVZSqpnXWEjZT0bsk9DVf+qIQKnzXxOZXOAXn61i0b4Nt7w0KQYJ0XO8TUTX3kRukVDV7HhCiHcwCFTXubT+FebUjtJod7C+C1QIKL71daaHKwJGrYSCoEGq8OhCuX2cAUcSnORVhfgE92BCVDLRPunWfrHQcEKtLZGxRM/z9ZBfK9Mw8YFpl2yOASqpjy9rmCeg4al4BUrbN9IaFnAwZUgNWpuAWWVLnXrumDNqKrOULCwQaE0NoZaQT8XFnEeO1T1BBa5WVePzEHAWg+IWCQhVlJGteIaB3nKOJRU/zVXb64Yy+aNTZ+XAZqMoXlTxNHrVaajiJDrYLNHG8arBw7zDwjT9h7P/qnYhrq/oCNgoq9ePcz/GEV6176ZL1qebqI2J6gAUZ70Guuh5rY8qWC6YkV1qb4tt/d0kneBFRWGevBdDmZzPmHH1ZXuA8S8nnHcbbPOrl3SXQzR3c901reUa+7DLyM0jgrMJ6l1Laz2tKFaAzObg8g21Q08hPdRLWcxWnFi1Oumwky0kge7zwfU+kJCmm2F1W6srYTYohxOfhCrXh2UMtsLOpP+SDnNlRzu3TVB8XSjiaxXJXFM3wJBXEeucqDqoe3PUKocpj1UyRtM7NPw/QHWecnfyQABi0UysLdOxEg2Uy6717V4WaGLkLrnlklAdRDYqz8NxmniUN/sR/5MPIJMkHdtV7nOiHJPdVrcP8jnyzrv3VRxMv/mr4iq2w9IpUgdtfkT6lv2JtWac2nJMTpV1cVSDJuFZmWSOCL7qswFJTJKl9M3CvT5MsSZvlsqhBVVe9DnhZg9nru5JIp9VTA9Lw0Dot6YrsB5qGWAtN3kctZzKe7DZJKPsBNisjNxTgx7NdNgTMEu/URHn0GW4/ncjBFp+Wmk+G9jSssAHVgAoZKauqX7y44gBnWfdK0ijFwXGhHl9msExUfmDj212eRGWCbN+OC+TWhskpah1JqV2cUnbHoS/eUednsYM3zERT5GIc1sknV2Z4pvvST/EzwXFd17rz5VCoXBPBMvbC20lYrR0TfSawprXuwOOTI1YwqR5A0AkhIKmjBRuaQKptf7SGEPdun881AV6qrjRVVMlIp+WAy0HBeImESBbQifuUDZH2QRwdVC0aeTawADiVcqZe365p4NCU8SzXSvRphi0kJ4hIDGCvneYMEpXmxmJ7GadaczupdKkUlsBctngpA3PAggiiC8GcOQOQXJWDle27Uo3b7gOE0JeF15KPSGuLw3YzOyl5003J3tCMe3mKyxa/lBMpweyOZgG7ny4VtKrPoH0D1C4HUX3S46FvuWJtfQNPyBXYRlFc8ENQ/j/evui/rql3vhjYfcF+sYcfl/6oxHwRpasUqmiEC2lUBXjTQr54y6muPpp+LVLySPb4StYUAvAoSeoWvEldalskLukImgDW5E0N/9w7y1epH82pJES1dQ0CavffuPj+s1suntDTzhNRsgVUVLMiUmXel9/tY0ZLfOMhlle+ntesZWzreLlD6kzOXONbHYr3NF0uV4ath8smrrHthnN/qW6BPtFJTyJdUtYSpRCjUs6nxircZZhvZeFZvsxDOWLAZacA0Mle0KI4X4a5GMRANky26lYRTljVu1af7HHhg7OkPcWLeqGeL5LL0x1nyyhgBoasPe+hlCPBt7PHEx+sJ0MXrb0hX4sXhzd5zEyytl/4lQfMrFsPmwpt4LwwgTtjxGC0b3aZSM/lQlZBLGe8n8uNwrneTzfs0gybUf4qDlZiSlyw4o/EvbG4ksidXXwtqr5CQSt77oeZeAmlH/ywAb5fDTJcln2EP3lhYYVnjps08iRWkcRAASEVEkY4rhfKVZQdTGqJXHl3V41t7o0msNo7V01L34SVndgHqHkp5jHUVQM08igQgVSM2kq+06rG75JUZE7sUkZo/8XMC68QpFMX1ZkMsH39cqkkNoxhEpTodGiWpTDoVjbBUIWZ9gpv8A5sduD1zr/+6FFJvdKQC3mlrF+/WD4SxwEbl3I82+FnZxv12tztMqFUuD5sxGXzBtrYicUL+GiE/gULNIBbYsYvv4tJoahbtbFxE2RYsqrSAvDc6poIaAAkvaaV6ryKjSrqY+s88WFpHFcIa4BSPhyiXd57cDV6cnd9fWxN4rUPrZWs+8FWJlbLnPFy9BqaTLomqIOfygqkJafehzW8byxMd9mE7Gu1BPsHgVfW9iFUwvB/3x2l2U0c3yiKNokSZIfPy9cv6TYeEEg/JP8OgJyu/UNWX9nRQWzLs2wI8RkPpZxqI0YaBJO2+unj30tgMxSdsIpkHF8AOAFcTPQfAfc+z9M63Ibxri7lgezI28eyujLesh25Cpexzs0f4PGYvN0Nz2ZwKWJ8Gw+jyOp6edVPc/LG2k3+4W4U7vlbqaCeymguaHqFUsCS6I1Y8sTeyTIPCYDVibRrVvkwOtSo9+Wh5HSnkZBVzi6HhxI4gvO/gTXXl0B2w5OcwqeRNYYY0r7isytrQoLiFGdgb/6bkZVPlcXnmReOOEyRsEwXyIXoacZj3SuUyNgT586yrlmUPksjNiXi8Iu3Hb2kBLDQ6v+jEcunKQpXv3pKEU5qinfPxb/50LFWTSHG8oN4fP8skik6NQ7l7uUO3e/oZUh89o7Wx+LIZz9IO2uUKDARcm9Qr+xrTHTFqEpqWKK3ZsND1NJSJApzHhXP1qAxgICoSJEUm4VA+dYkkk6Oz6QRTAALTjFwCjBjCUwNwKQPN01UtdpPmtfkuHbO5GWfJXKtSF6qHTDgSQlkChGWWcj55KptJqKLALjgC/rSaQMVecxw6RdlsBVig8nC4df0QwL2z/jznDKpK0fdLfpaRqhDX6OQM0nEjYtu7B8yXzBodEWsFohZ9A0OhRXWj1lqonMhjLfI2k/xkLPjJJTXStdpdMmafWBVrsDazH5btXZ4UZOwZDf6XAw+eX89eBO2t4HrOvLIdC4ZEd/uUY/zamQqTWxrfL8kHO9wjZE17kcCsdS/6p/+XzY0VjgrKEUD+c9kvWQooygf4qOg2IakKOpp9+1eNgBrxv7++sPkPyChIryy7/GN2Jli5/cn5fucCKJnzaPGldsrFe2D6mw21n7pX64qSAI92vlTgqPdr1e2Xjc9e+ldVaurcRwuH1d9niHu+BL2TvlJmtjvWAsEIZH5ahqjKzxQnfxOoo2sVmmqYyEZWBBdNEv9GR2kft6sa/J8Lms/RDBcUAVPQc2o9lKOqHhKoq03j0SzeNf1+kpei+vxSS02569TxQBwsOSOBQlUYkqYO/wPgO2Sx9aowcK4jYKRuU4Z8HbWDqKqahnoe4SWrDezFYRsCJHDlaDXl3RpuTSx5ksdowGyrpxz9phEyRXbkAhcxRkVNvAJZRwQr+onhZHn9Pup+jmIZhYAehyrWZF5dlXyQ1m5LdMCLlTv6Yk8MVaHnsVFmfSJOnZ5YAAPNAcf8bClrcHnNDSto9x1S+8KXydxGTVpUzy+/5Zr117j9TTE8sbz5flyuXz9AtCA8Ev0EsnrrexlBjM1P+yPQBlVfIPNreuGAi15nKwbdJt9EI/vmaRz+0E8Ht3AlY2w3WtwlyF2fBmAIZgNyTHddpRJ8uRp3WAYU+bQ3x7Jo9gDfIXnl3pHrv2Nalf6GSI323Tl+9DPk345UvFZz1cdKnGLOYy3N7t5B10VjNapwZnP7yVZyafl60cPU9nCRp3XFdytH63Vq3W68DEH4Ow8ZSILSbUQLsKlHeT5aBI9iqAL5u7TvO963E7FPn0tRrQkuQOQ7U0Pde1/Lf/DwuYPN/+80b43/v9INnmdEhwKb1XVKSI4lNqaEBzUTZ7VaU2v/O8J3xts631e+MuBuhVeXBlXOTK6hENVGtvYylDMBdGV+v0EPd6qGG9H5DStazV7jK3LwspWtvCqmKrcRcOFQ27AvwJtgNPHD8++PbQPLVi8vyb/5pqdO/MfsAGjQCl1XIBV96EGfhk8rYAmb73PDv/D/xVlFvCvV397b/KTKyUVygquzRRBXrIbMtXg5yrGa4kTXJaBOmSmTwpIlMxk4mVWewu5TMUXuZeFzPbgP8XD77U5e5v8iPhqQaxaWbcW+VkOJtajHxZLOMdtXTYlXKfKDGGGzyZ0MTYs19jAk3bT+Bzp0FPpI+3Dh3AGUUsjRBOgSAERMGU7zaoO9yG/p/iRArv2QT+mndnWZ9JfwLJulzfb8QKfyY7edy4bfqUDf/7U4ftfU17AH0REqKXD9Xg5rQ+2X1PuYn99zW3eBniBUK8QnQv2JEDSKGNk1AJkS/whHgEupLvae8B3oi5xkTn7UPnmeWhaRZUhJKxTptZWNcg8+5Qn9ilnQfVltt2Z+o4IBixyvnbEtnbcngxCa7pdy0pKb2vstbUzuPteIFdkIXi8CfMr73qIOReJ7MKmFOT0ZbMq5TKTkwEq+QFGMsSHSXFelpXYmrdaVDaEz8O2XCsXIrb98tK3USCVnpvZleojqMplbxVFjYReVngkD5DIiY3WkizZhDFUhZyVBVeblzbYxRIyz35wyzQTlCbgNu3Lj4Letxa9oeGy79o+ysb54o3mKCWBZT9KRZbNTXJo/PrL1lcE+2SSCnuPbYQUo6hRGzHIQHwyEwCtJY/tvQB+5g3GPmjiNmTcts1oODJtxWiWjrI42o6RNIIFpRJ5GPvCEanXAaqdePN4GCHbYhSlSOzP3mn0KB3lpjQM6JCkA+tPQ5xr4poh247h+DzrufJsGetztbFcwazBOaWZVHpJmuxqZVuXIxFzkcY861DQmGwA2DvlRzCNEYFZygAJnscVMXVk8rrL9OIwREq5vytfQXGzXhf1yGl4Ntv+gUtfz5MPNCad7+QTa8LQDDp9uBv0mUAHZPKyslhXrV7myA1pZONITLiwwQ9MowlDUhsfAo0hcFQqxe7ZNc5b667DV97Sf2/gp8Xyq7bwIrhorA5QaruAshf1BG7U38Qv4se9clT2esD7tUltlCa0zfPMkNFclmpbNZZLgZQXhm0mZ7V7+5Vy2XM/TpAniElFbYx5EicFvMSTbYhCSm0oHv1Nm33tF8ywLkhiqOGsJevK+EV4qarn5Nu8UsOD5LdFdVgpEa4K7PXj85rTTfNQ5C4WMLZprM+0vlxTn347TYirvzf92whTLx7n2QfoyTLVo1429/U2DGBaEUyu41VPYRd7hHMVg7HGhDCkIpnH9jk7Bn1pdEAS8IKHFXGOa/gD5vdjJIrf6/WuRzfWQxLDsabIsTh452xxIYuwwNmxiSaJWLXmfpt7EhXxAwtiFGGkdUecrXjl752RbeSSeyFklDXYWLZP47vOwQI/U57xLViu4EQkkt+r67pZRLC2qJKgiHbaflPNW85ukhu+sCcma/9t+BT9b+JeaOHB6mi3MMMY6Cm6yla+cpHMzrWpvThe9tnYPkaJQcQ0cYswBHDJ4eNDGJKCsFKs9cYQz62LAPP33BtzAhFqR7tWCHUio3Ee1ehJoRJ4ijcpVWNlmGDj61mTtzKPtQS3OW2VyuYxjJRspkjVB4G3AH4Xys5fYrQKs/2gg/dKI6Vrm9NzMTa8agUTp0ILYylxvmVuu2YvQvR30W7nZzMdAa/DU+CBQYen4vMujcoQTyZxrkTtc98dbfpzX/966DPwz7199cbmMnrnEG/pO18fV5jMmEn1juMEP+OdGJhzQgE/kmIO1WmghLXuZOd+OdLYaQ6V4+Di5D0vvtWAi2mJoRfxmZiZsozrOs6UqH3OO1qv0KjJ49e+Fvz0y4tIDvHGfXzruGGn16K6lPG8nqtnsw35dHleQ5AIhjjzYUov8FgkNrIgeM8x4TAOXa5bY5aBNmbO8yr4Qs2X0HkqCrs/F0u+8v3M9ZlLFlog7pKlXlm7CrQ/wON7G8jXhWkIFOwdBPn3nwubZKyHlXdB0hXqBeOuAmQW7mIEmWXcenDmho/Ah7GGXv8gTQwj9GvAN3297c1FvlTBB4ItqWNZ94N37sUrlMmprIFXBC8kqHVyU7pm0+E0wrH0W44ApSwv6QL1iMxFV8QKwa2VQYMRMVcn/PsebnI4wD2DRg7fXZNjKZVCLK+7s6ogDA5/j42O7Mz6XmDCNgvU3OZWhLuvV8PNKoKfZUTtCGmsiOLN48XVgZ5tF1FZyweyIjeL2Xw+XV5O9J2yWxUJ6LzjdblaLts0UqRHHlHzMC1a3ulY7vCSoA2HoZ29/s3dA5+WgjSHHUyEbDO+/Sd6VU3+09AD1xWv6IVJJi/i1PyquZlHRSWfkyW5mZ9PZ7PF+WSyzL0w76pYLhaP0xB4ApIBdup6zIcbbwwi5CzAXjvQPSwTTVStvvyHXRUlWGOakjF8ZtihGivQyLreuQHdH/rABtApmWlug+h13uEDnNvMEG2wlf+9/jv6G+z9bIxK/IoX3wSVrqpMVrhnJTnt/KonY3vmiFsAqomySq8oPUsGyZIEGP/vbkTW24J893vK6T7hzW/+mVe8z36i0uyiSz4fF/vl5MEYjgf9/uuy7/ge8fr03u3Z6c353J2ViyORuCol5VkVYXVI00xRhQHukuGdIg63u+PkMOfEHY3/4d/MZlC+/ga5H5TvsQoS/B1+Ppztre/Bj1jeseWeSWjCmu2KjskroADgudGtlrMXe/Q2ANBpD+nWio72LFMGysSZXaUh3/Lo1Z600w01Js8nZT9jmoJRJW2FXxnqoRwPX/QkRqzYUuMKyMYYgdeRCpwqhpgqWUayoko2l73RBWd8yKmCAxytE20eYyYyoUsdKV0YrLNRlzBSaWwuGa1o5G3+FNUbLCFS3BwLtCFGUSrDh9Av316J4nZkBz3A8XOUQkq8bfVjTUqEGNOQdkuBtyN5vVMNL8vyKTX6gNjDDRC63MTxf3n+aph9tKgOQ+8Lh49tciaZKqFVrvJCrtlkhO6w/wIU1BSDpeUvoDrHvPCuQNwbQqkZ5FH3T+5u8t95Sv3wA5oFyZl+uF31w4/Pt9k//Ix5w1l2fPf2278w/eT4FrxFDh8o+wHgGD98QDLjCxeH7hZfP//JB0T7OAof2KA/ZXv3UdUj5gNeTYJcNl0fyTIH6zDI/WtFqbu7cQ1XV56zbn8A4j73N9e13xDhHKd5nMc1d9SdfEwSwRReBYs3Ta1sMcEN9WyKTM3pMqkKoLZ2a9dqj3q0UleqDYxNXWv3E3vtF6/d+6bhXP/UvdikzcFdhu2QaYgzeSDin5kX8l8ktcFX7aEFoZJ9mNQEgavWpwRhnkiuwyaEOSR8TsT0s0aJEapEBoGSAup6NEu7FjAbiSqQmDFeXncjcrxBlNDBCl4YIFa6ELZqC4GFJFyU1krBrI0rXxVDVy4kV2/kTXPs8T8iIhStDkRKG02n4WyxnmI1meh5nesRNIijA+moQVlJ148MknKuEESMnnPghNGj8d7mLqSPYs6I2272H80V1rWM0A5NynN7aVUvm0lPxrnE0Dch3bR2hS/L4n+pwj3PIV6e75KbJV0BRtmEwdq/CVLVelmaOTyb3lzpEv+Vg7/SyZHu0m1XnFVpWs1haDreth2cuBeUh7DfCx8ElLWqZdBuhq096u6s2mz+8+0mlnU+95byspe8DCMxLLcqb9k2WYlVXQyo+icR1ueiix4xIIZEVgOrvpb1yUZXRdSjXun11iWIBxqxKI51BLBMLVcnkI9WHtv7FkMcLWyKENEhc00isV+20fNH1ygDtZoC1BBEnWuIYI3vIwTQYp8gnbS3y9oO0jvQz/a05hBTVbThupyT6yWXMe9sngylInd8KZNvhhKX8FQQNE8O7UPjBFhuZrBzlBfXeERtVbkfDJoQ3qmeMr9zgUj1JUccudnxwnEogMejpcTTO6KuCR4W1n0FmksUrWilzSemH2M2yVHE/EfAbs7aMhMUrfUx0Q+bEPe3r8mYysWQDQqmaWMvPcHdao8ubfgwpeCltMGdUNaHbaYba1+66fO+bFt93yXc77rbPf60H8B7+JXdg3F6fJP9dPJZP28OGR2NW45QLSGYZSz0kQugDDTCsHL2577hTdXm8/qD33LeeoU+GW8q/Mnwi9pT5Y/xz3LKXsrX+I/Lz5DHNiXF0EKCOuZcKzuuCf6vpVnbf6kV/5xw9ChVFmk+9jpJPFOghWpa8P6KMBoTM1B1LbTw7yd8EWecGUcyw2qucvwfS+v8ud9MAcBlTx7ZSGtZFh6Gefrpm87rjQPstFnuU0B1m8Ky/yHwqPc/jIm9FDxXCQ4rca+VsOQP8OEDosKjlJVNfFSMQiUDbz/AR7Ksv/7FFkO43Jyp/P3azS4QXk7iidNzpdwRLe9Vwxi2Qi9OsButru2R0po6UtMhGsQAvtHg32CuaHGVd7o4pU83Z+K9IjzXIwKZI6R2+Ly5rvk5Xca4BDe9nrLIIUNAeHPFzcSGI6EtwOR6R6sPXcH2P8SL95RfU9m6Fox8tid9E5qWZMS9MtfjYJ2Nl/1kXHROSdW5fmi+VRbwR6Ky8LBeL/HZlfL8eI9m99++AvAK9sBw0NvbalhVt5SKT44tKmO/RAe5EH1KLRIvOXnRmgB8USucgz0DcxRg3y1ib2AjOM7b6fna7wmy5ul2unnPeeXC7P0KpI6NrNU9fX46lJOxYWEaQzGzNtnnNtE2pwDQh+gGpQ96p6i04Mr6MMXrolz/0M+IUiobFmQxER8sd6SMnX5pVrGSxNRGj6PoGYqZjsdC86CaoFl8wqig0ztIQ+inFPgBFhGSCCXYJLGsUk9yhIs01/FElzLWHhWTWvmJPMlZ2yidaXtaHUBT7EdVo+gSNqMZC8oqB7FR56032viw7m/3hDLGw7FU9x8u+A32OCG9h/+GMM5gSpUbDfFkzpBGg+S8Zy4aY2k/Z5xeA9t4iHGqwfTvjanZmmn7W9nQmIiCPIHdmnXx2DYjCZwTz5c9nyLuA4oiku+A/3g7DilJwbOlj4DJ1mYA+y/EO3OxjuMknwjsxdoF1bNGCdhtzfocAtKESXbmQtkGvNJgh53e8SjBmdW/UPlH3WRndojI3DHbO6U4csYZ1HRQ9MoRJ0BkwFpNWzI79NPM9+kMPBGYUVleXkWtnpd2zO/ksdpQxkalWnJARu/MRhIMYcOzGiPkZv5gRC610OA6RJKkQNjajCTVRfB0yzQNJZkwPNZFLnDdIvTUAWRElS5q7rCftanTsTO+ZNW62660M755yXjbgdXILjPDEdaJgI1TwytWAVLjlxONpM92NkPKy8N4g5phcEFHamdVK2JmMKPSJpEHFo/5PRU0VLbI5TCO2NcwT0ZaR73pcS9zmiwfuKg6txxjK5bRNDSC8s/B9SJ1LxggW+k50i4kDa0WRU5zezlMcjsbjEnsPrVEkold5eZsO3I2n/isgvE0RyqFteh85VSsOijiom/PVmRyjR6TaXBv83iy8TCDy9Qqpt2MLP/jnaSaWZ3wTaWaQnDfzIZ9veD2gEo+SnuYNGZVk4FSmMM380cjPTG6DkkrSF3DvLsSu+k1umdNLiycYo1QQF1fx0bBYZwmsRfzDCRdG1nYYP6uCmX7SvzYbelLUK2KxJhbrR+peGG0EvZQLK2xQD83Ga+8oyVF10eZGR9Mlok1r7R4amazbp1IqqEQVVMMi9190lfSJExnqWLhhQX5Z6/tYjJHnUaNEUuSP5MVel8KDWPfZq4cJ8aJOAaYL16Qg2nWFaAsil7+Lj5JqlYtEqebNoFHoAhs3o+TtFKNjxhb62btvOAluB8q8/6hK5jmIgLioOx1vbQ444C/3D3uqB3YBB7oS3Hy6mywepOHF1pEn2IxawxjpZnjKsnv/TUhJIylicz4RaUydqAXYWlD0RRkstQPbs4pkBVHC3y8sQs5kH35RACqEmPm/ferbL/fqchoxrOBOR696/IXP/KjBYro08wI1mpd2kL/aqlW+D8jEYi4QI9kzz2zYLNZLYZytLLkF8KlVBqBkkH521Ece1HHaTnjlSsdf/QHfxsvv2sF1Xm1CQtaU7qtMEde5E6FBK4BFWwhgSDp2kxurtijGgnUXl9o8t4zJ/IOzMq4zvzl0laap8vOeA37uRhPTddxHQHm5yqiMn1+/pFNYOMIRR8XpYZba7nvHgXdKgwRxOjkqNrqLkjhP/AWNCyr04nNhrgTGJ4SzJT8URsjsiy4+1yHDjc+07L1WYcIN008UdpnYWFeUSvO84A8l4+ZrvusFQd047vvsQYa45cHKhAYsfhuJ/E+xsBdv1ivhiVxlKB1czpClN4brxfbEHX3OZE9s2qdSwNEngWSUc3z+TFzxRprvffLXjMpXeIsxFWxfS63k+nAD8bnsnTugXgPmy2/qOLJPuAZMDwHjrW8MmlnrFWvTc74WJpCfpfqNy+0wq5rO8pzHSTPQjl3A94CwxrUJrMFYhWhQrWoeTIznslG5n1sh8lrQGHXMnI+NHJF7GV1yfi0J/s1q7Gyz4KVHkgIMtX4SnIkXUSAd0zP48hTeU+iaTuug+NZGDhP8lfmC2ZdBRV7wg9YJG2Q9Zq7RDOK/nMAvoo6TUwERcp5kGcUofGRD//atnSP6ZjKPpM1kP+emeYeUef8aE3fbHbbpmKWTI0Vg3BDNyH8rI8oCCq2MOC+pV9o4XkWNM+A4rlcKslUXp1rvwj5gSpQqUZxU18j6huuTLE1Zzx/uIYQpYsz1tJG1BuAFAOGEA6GMk0w5radEzXH0ROX5vh9ngHGc/gEB50jEPPHBBhDRnAiNZIYWxRoxFU/cuPQEyILsq3R+RHGIMPKtp7oRAPPgOU5bGapcF1a2yAEVdbWxIrCFGkejEORkHNdOca0Bzhy12QX7EhkYtwSeUn61TpVRYERYreq5w8IkGEA6KZgJel7eDDnZ2gy/8wko8yexBV8FwuN4YRVKi0/HNYXM8zWlBvHBAioyZRzMLPjR16wxdjrXDhLlJeU9SGbEbZrSUG7zNBtbdIXHJNPKs/OCimwA3KLie4mU/EQQLEJCwq9PezramRDysmYNSPymVTwrBvNQmzBbsO0va1+wgEWsOBPsvKeYxNqUht9JpIkOhCd9tCx+oR3TDvhwu3qh6KY3OptVdmx3L4v8J7r7kYAZO6v4dSLi6/UpPO2PCOAwQKooltNlpXatTHpO/z2vvEpXwYMKhKP2P+Yv/tgcJFaZU5NPkyegh5HsSA+S1LPCDtzLSJPPXDqqsONQmnVE0v0jIjelfieq8DsJoZksuxkWpoTAMaMVJwLmYZY9hp+K5iQel8VjJEBF9aBhHEONHpgHH9k971z8debvKI0AnZDQnazfFJro3NnWfIiaWveI0BERZCCiHFdAT6UVVcswKUB5tlOmVZpjhlvp/PdcPJCcFotd2KzbNzhFMUKA0IjgSEEcoAmN4l5QzWd3CwuD3W40vma4S9Tl4tIKyQSjoQwERFwUGnkghmZCSQpWNikGue8r85wHEOFb/uJC3buDpL3EgjInHnc7fe4DI+y65S7gA51huWWdI8CxokEu0AP8l3gXkLBfkSmH1EahW3cT/gHMqb4L//UcL3z9P1HMmky8M9Tb46cLfe9yGZc6SolgcL5sUwf8ycbDPuaIB9v6iogMsk21JN2ajE0aqnSY/hhK2QCHsW44oEKjYyl4DOmr/AsUGWSI55MA48BiPgVz3vGXucNopN8xjVsClLOxepOypQAwe248DXCuB9Bj8nPYP3S1+MOYHNpLClGSjvxxfgdYaI2P6U5v5MIHcYjl4oIGQkntCNK/+d2SL7zC1LCTAy5QRWq6uwK3Bbud+XGyzA7p9ZNt/wBV6FnbJD1rHvAGFTtfsbVwfopJwwVv+Nchoy9vUCKOtc90ToF0weWOMeTU0OWGbWgGRfQcsIAipaKBesmUy704eZEFMtEXX/kVrWYYq0hj+fTshnsDJ8pt9D0J9mJsQY+TMEO4rwuIkpmajiqcj3MbDJSMkKuMhoUhxXT1ACG/xgDmOJggrN7PXdPcQwe5yg43kEfyCXrHGWu7DNKw7wctEB5iChomLnxeXJ3iP98txlh7ZVBDohzKZDelnfL0LNGLBTZl8r4jqvYQLfMlwTQX0KCnzgapAnSeZeRGI58mFUDf1M/yoX3mxoDsQrCqBxEy+hkkRurXEYApWGsj3A1zceYNNF49W9vCZYkiWcq9yvMCPDiYhQSFTlze6/30ufdxi3zQJgAwAkcOleOgi5OJYcawcHvzM9bNrSJX35mz5R1EPfChuSirLHfKa1LDzPhHx1Oh082cPDLMYmCMEWWhsdFyUOCa6waLZFxxUoH8K8Ty+lkjVi1hmnDxSsDFHNMWIQ8gTBQvqyIBnxkjEPUG5KnxNFzwozMngyrBwiLKJmrUducUCEmL7PHM4y5r+JKIhGIAkvrNvgFogAO/i8Mzzvc3zAOo1w8IiWECkwOmXyD5kKxlS4I8CLBs9jGlf9mYiON1qFZaFIPCsAxOXK6vIYxvOjpoFnkMCL9HMwOJM1P/QLi5kM4xZ5VveAAv0mcS68JwbORnPYNTgaVKo6nXXxYUrwn5MnKLMAocpyfRd7GMi4xUQBG22I6+20uubxbir8eww5m+hHBZ9iLsQvGjOiEfa3vY/yGc4PHaSna+8919wkAfj57XJngPEPbUkYg9oFn84bP/GSJnqdif5+PwHncNDkak+50hSotf9RYuDcNN6P1zww2jHR4/SchS3seTgqkyGRS4QEXVypSE2Rzl9x5ljrCzXAtoCqPyCObic3+vuqjAn6witYZE4JaXgK4wLlMwACYxnre4EENl5ZiLASJcUgvyRPY6R4/O2RgOeOvncLrVHgnqaE9adiM0qqGHjeCrXrC8wz0tlnJUQdcBhUcAh6vR5jh8wlHJxo3XAqE2cO1EttSv/gs2lStRFUq3XkSlDO76pzGUTxhCzLOso8Mpj92HebBUMce98EAH5bm1XgRrtjYkrJBKg4rtt4cUhFP02Oe5TIB/K6hJwHifg75BF/R7kXXElQlp6I4CPb2bQoZY/4ozAQkGmUSnMNcSAoV5Y0xjfHjWXDnROSNBU/SkaHoXA5FwSGACVCeIeRWViUmGOIEx63VSSh7lLaDjQnfYPbhYGBKXouTC7BxHqaLL5HiwpbMU9IBWAuS5pxWcr1vgXKVFXX+EGwKhAJkIPAbzsz1c+gfFkC50WkF9o4bwXJueH6/A6NdemYwHz/LYMHRyB4Fxgs7i6birClumt6FCHyUmLYQOsQAWsVR6VqNHzUg+MhU+mN4Jjzhc2TkeEH2aKGJyhYGwoEI09WEDtRI/XkCHUZjIi3ELA8ZPN2SGvAy5oc9kZ4aPD9aoCfeR+15RMmLQXO8bPWbYt6txx4cAcaLJcCMonKMH+tmVdMJF+VxADDPcfV63PUGExHIbiLAeTMPGc4VwWUVUAnRAlA7IbM6DqXAi4RSQvyIzMsoxVjojx3thU/KUurMABwwmzcsgtjrCcUMCHBnBYDVnAHzJ3W/fx8v29F+dFaVRAZMNbevXe8Flw5cYqOwxcV3531SbOxwztH2D/9KAYNv7p+DY/HKnSmkphxMf8yf+kHvpNRU5AIoCQI4HyUYX9c2NzZUtZsUlfMmB3QGc6CgOElQXH5Gk9FqnuSCodMinbyy8sspTR5UG4KbGwInrhFYDvfLaX7PeNP0IIre2dV6mZMfsyXCA8WBNivKpp1y9HRgfN6PI+W11c6jmx+24QOOvkmCPW4WdMd3sWyj6Tn4vq2uWGjKhFyNvaDCqAiIWejCg8tyATKuFe3UpjG0mAuXNEXgm2CYEmyESiyT11hCPSP83pmXnIHnplp4Mi+Rl5YucZhUHQ0ik9lDt9v+icbdViMES+EnFM9ZBI2zM1M4yK2HsDdWyzCyS2c/O/aPlqYrTfFzU4AYyAGRfRsfvYrykCf0QwsKhBuLLHp1TMc7sn9HMqR++nHf2grbB1LxsWbmX1Jixli30haBq/uFHOeNvk3b2XVYnmK0X0w+1HphAk82shqAL/1hr+n1fBKNSejRcejaAz26ybxR88SV7kEo0zryaj/EM0ylNF/RGUpWCAFsK6TFPvIXClw5kZ7YTqk5gACv5Ju6stwnt7r3Am8+YlCrYCqy+Vt7J5JszXVIhYSlB15EdfEP9aKSvYrEXo0nZkEkBY2B1XursD7wP9/1T1fL1Ym8BWPkwbFXNULiCRA9LJnw7EYJj9fNzHjIQs0IVAEAAj8gT3xYoHRTAvrgLDbrWoJbGDZPqWLu2+0CdDHunSgrqlR/0MLcz6uJQixR00QFBAxKiQSwecjfc3VsfoJHLpMhKmtXpMIw3EV6L6tinvpKrLtLOJt6kw4OsSZ36hk2NozsHx9Rz0yWVbK9a8GdcJGnvOR0LP3cPG0CFOKY+jaU+ZyvQ2hAMoTAfdZYreB8E9y0MtPhvbn+/AbwkPveOxZTqlHe1rihsQ1WNXmNaKRatp+bqBcnDniOfYU5MnlGiH26uxyxkJpiGFxAfoA/LFxJrev8X7rKmW+cy3LGyKGbfg3pRq+24zKUsX0gbcT0u5Z4phDuZu72ygBxpXnRzOS3zleq2MgidrG1Q/KXog48FJmt9CQMlrFWPecrRg6LeDz28Zd+TMFdEI9GJ8pKx4eD/OWXCBlxkQ5y41LV9k+HxlesnrhsC469UPgf8XI3WinPKRT3YBjf4Zty+LrdJgOe5zj15n4EyPZEAas0JxJj8ryhUzIsHVS0zNIwKq1m9mDoxWXoa732WJCvBEibu4BatZQshJJxw7uIE/UF+X0h+foy+OC8r6QCVqSlIUzlQDjDMOitQ8ou0BDCqB5xnLlx/K5fjLwh1aBFK1B3tgua4wUP0gH8KxR8CXQf8vdZX5ePa7QA+c03MMgMHtJvSXJFYyRx/n66EwAFE9YGAfncT8PPjVaNFPUh8tQkxJy+hVA4VxRlZqaiEVoUu8my5jgDzQGesxdZC0MIJUw/m7/NXEIBtVMniPeeBVZEwo1+kDf1ojtbJtEc3MNSPehVHdIyK7ikPVzOhsq2bdSDtyYHBIhkyBBsO7KKJ1wfVYTSrN1o7d2QmLtpc/miJ+bgZ9z04FfcgkLiljU2E+rcg8iLDnyUN/upur+hmv1Fg8PQlhM9zcgXDKmunKN5wVnhrXnmCnXpUzXBDQtk2wfr5+sgg4j/ky85pnomYr2DcIUaMMhDNdCULvMNzsUOAwpHLiV0LxGznTD4AsuZ1ZdI4DKjrjooO69IybyLIXe9ISe2H3WqYJpYp0Vym3h7wcK7Gxe7Ad4WohILKuayLtDHhKRMOFAIIOfgGrC9F9i2oA0sHkgSw27b08GMwZaz+bAqLe5mwibYCeDvxrTqjryh8FELQKhvBM0NyGyQRT4Bz4fPABtB3H3hgjmFFjlkc3Y0oUcaD5LcExmWd/dd7yv4aCGLwMXxXjRvWY2Yiu24h6B7hWA1Uwz3eLZecVU7PBBDV3XU63C/NG89B3w44176On1cwQCQkshl3vDQ57Vg+ThJwS7J6Z0i+AQbOKAf8k5Fe8GLn2kMeE0Cj8DuuKo3M/5LvBS2KtcaiJFGNvz0vu7QPbmOHqsPzHhuxGhb9pJJTP2hehMGL3ET+XgitWTGYlQMeK3AgMEdIiX//eU5u33LLLeXLQ4Mnq6fbPGTrGjPmly2NgZxG54kZ4Zw7wUerD8M2ttRatvxsORMQ50KlVDah7kcLxuxqHl9qV0sJESSM6ZyEjrmgJsmUaMUMHqHYBi5xL1/JYOuGeXksmiJMpEEWlGNnlyVTfbi/vKJHAltUYHbl+GWgnHMxFigbj9GILKOE2/XK9+FBZPrZZsPsmA241VAGh8rtvMuDOyRzWczMRVaxjw3B0BkTJ5+YroyEmBF103IaH6tdgcXphIhl+w3w0wUUNcjU8IRnF/AG8SISbpCYrz6lEGdXwh7hpTnjYclsrQjayz3za8cOnN9AIx4pInuheTU/ZDWW0EMC5Jf+97fx7VgFflIOUPlAAolTaDohpUqQdxZDQN+maDyZtHuvWfR0tEKkskG4iJXrt7GFczAZk6eUljYajXjfvRGWH6/j79DMqQ04wC/oEIHZ2W9iXQOj4d4PfUcG8Ef50jCkh7DeYQ2dGofDtmodJ9I6Vrx3O95F848PRINJuXReQJuYmgYaeskyaYBxz1qaXK1tyhXq+13oyMTyRIOODcYBs5FG7jDRBjgE3gy3jVz5TAjYSNfBu2QqU5JokdnA4ufE7jg7CImFQEZ8/tPeiBRGV6JpxySW9iDW+2PpHiEewEsoosd750IiWPt/HHq6m5JVjaTSnAboe6bS/HUy49sdAz4wl1BFiKwup111gyNCcyOLeoAA6wox9ccfCMaonNpa0GL0u3NzC5tseQ3tJAvb/9FcB8WqlgzB8Y6P+ReWHOFTf8E1/H9awU3iCSJJ87lPpQYwv0eFhnoAhd2Qv6uYZn2+ix2FLlyqD3P4/uDLxaAEbLmVxZhBt5GX6PX3TKTdHOXjxkL1PcS/dWEMox/OkrSTQKoc+rW0hzFinBEFhUz9Py6lkufykIYDBukzaIQvgXLFpPazMAcPkw4FfZ4rdMazJtc3VktHkTBFb3N3zZ3UZ8BIxqMM0bWNrGCyAJ4EED78EtFS6pXrHgjBUBVmZN//AK33MLb0eluxAUVbIdknqfZlRnaqpZUbUqPW7AkZVvLoIIsFjMTTSpf/gibwdF0pRAYXm8cxgSMZFZPkeHyjANMMkGKMuT8DhptmtPtlMF1YkwovN1o7fHB7QiDdoNg6M0zoiSMMel4RAiH1ukQJg2g8f6g37Jci2hDXCtdsdLZKGLPahlYwja1fHFp0n0eBZsjEmmjzulhq5hvCJzDsmp0xA5eItv3ZjObbB26hDyiNOyOtvnlG0CTxelhUipV3RnIDVN+D86PSfHdBBIAMEgkoiMq8X4osCF/Aq87naXA0TD84NWosHtwYUw6q9WoWCErioVmSs42IoZQy90RO2GbPeQlvadJWTfnWd1MZGAJm98bA9yeWlVviZtaD/sQfsWR471CoQP6Ls9h+M9K1cT6P4VLRd1LdgE/IK0zQ6MxRAmc/yrs+5ZNDcGJJUNykuwRQSj2YQy2PqSHzv733jdCf3cuPWKf/HgMSAB49stWi2LIwH6K+V36s6BlxhPHTO8EAAaNfIlryr7UZ9LnZavzjQC0RDyPzcqEMdZjW9K/ISSWXNSIP46/gL+Ifwp2Hs+NivW5UC/biQTtxzV+OP7PbELrul/hRjl0NYEfiT83hIha5TstuRD1D9946/RwvM/1/kfyO/zxbnN6Gg0KYFf1apd5bWzLr70J+jz+6Th7fiKVO6dwL/kbM3pzabITiRF95QXo0/itF/+7mDz8AqfrTe/FA7x5sIujNvdjuAnoLsl+uTvuYqnKdtyle+sqOE/n/ubpwWQ08g66ShZ0aSlf2Q+zscwu4MerCoY2Gb80rPW7mO+Vey+5bE80oyyoeDZQWCX+1GJz+jJHX6D4pdobRGz+M9q02XynCl+BQsQhmpXxMWZZKf0VT9gFVJdFhziwGj+yfx6QWKOuk2wHxlpsQbMpE9oymhyucuIH424papsrdrIERUAHrwxQVLDSvfiVDt7sbCFS+bU1DB9LdfSIXd4PTaQA65S9ReX7+clN0lQ+kDP4JBo0IfxE4DjlvQ3a3yxmdAGw9LW5DmWXS4VPDg8Um13obkegM7SJ/ZUJY2zAptLfExIv8/KP4s/hu0g3kW6s9CNd4I+I3xB/YShZFkux7eFH89hN4t5fj6hXY/hoOJ4fDRAdHl7u1/rjI1C0fKi9saYrzuSuY9NIXrmCYgWu9JaDF0/w5skui0n0tWewCZlNq1gng5+Cmph0RutPge/vnh5NJpPgQEWn0paDjxRI2FWDQCCAEog4I/6em+CabzdJG0Ac4hTzlQljrGAj6beFhCPmbJpZdiDOR8hQDKLxxNaymGrGg0/JMKt1sT0tvk15eLropeOVtpOqjXuxNkmjLmj3tTNMwbKpi0VSHOCKhr6yhcK2Gmct68U1vPn3ZygaiUn64jLs+9PTfNI0luFWk1gn4aDprG7QrA6DLAKoOhN+0PCAebI20MTqsLl8VLbCeUVwQPOOl80B1nVsHqiob2Yl1cFZLAoEoD36wmBglPuft1J3ulysH/DBoMMPcGbZ76EKn5NAK5NvCXE8mHxltJdS8FWlEtjI8Fmb3WFCbs4e3P69G4jIBft47jr+A+k/Ee7J8ULxyTLTsknmkwoad5vFbkmkme++Ps69IUJQyDnsDyGydRO8UgQOYNWs8nRueSyT0x1BjGfG2Ux+JWmEtN335XZej4yx00RKGeyOgRBxJ8LmhpxKgSs4sPZnVaC5i5pxOU/SVCAzrWDyz9pai1Zl00Ghduqn3hLfGk632P+NMWzLq8wUPmpQ66rpLVeRjd5TqHbWT1QWmVnmmTFOOIPWGQ07/9fuiKw1F9qRQQpfXjlRiJlJnDJBfjdHqmUELwH37KOAUob3twrmjDnT2Zf/y/nlES1lxF6gHdTliJV05ChjdElpHFCzWfAv6YvpO9JHXukMI9Otf6F51Hy5+Ui7OXYlbjnNiyv5+8yVHWVyTlIbEmfQ90ijFTtIaKeRI7FZ2iyTnRRyaSagXCHn75TuYcLvGsO+4TA8GKmqGQDc3LFO8o7r/YzPO5QZKbneSLlhJYW9apkcR/r0lCBles3D+U18PfLKllegMELtb0x/UqIVdqT+EzqxMiiX4ARv4K0NFQPHkWjuCjYy2on/zIyPss9lySpk2qPPiHuu64RRiEXCU5SJZKN6zin5oFodRE2JRbtXl4dRM2fLoGeOlXlPC8egNou/UF9g1DlKpgXI1HYTQg4Qq4cZG3N1b9N/GAWjxht4+XuuvLest+UHW+7bYAGYfFhwkhPZyQ2x3kqniMlV6OvjhTJSpGpsP9ys3gysVYPOhxy8OWbGoSd+NUSWsEvDECMTtq/xQzSOjaWrgyNqwgLJWj+ebyAdraVMXFkMicAdAOS0q5ahsxY6HF92Ath2Fj7bU709G5EFSRVI6OT6YHXDJ4ZHcrIJLirU6P2Josx7XDjVEhLxtXlqw8SltaBEry+VX66XFMRGVCgZPqzm0PkOAbVKa+0xFWpkwypnSCH37EwRCqbcO1HcDz1fcHNo7thNEUvRzvfZqf4W1gch9NU3SwkTULOaFMskDk087ZkoRK0JTEXRRbQx3tsOvt2EVpQotIC4twWTrQG8ZHaiAEswMllTxMEM8DaBZiwbd+5jlhhaM/b9eeVx/BxS6jMstjPabkWTemADm9n/V1Dzld8E66k7TMkTfXahAej0/zfcRulhSjvPGPUUHDPXm2Xm1o68os2309urzbGtDJh1WRXF3FISY6KRBkS1SWFRokOmKhsRXX7lFh2+ciEpALWjRf3Qtsv64fIdeL1QwnQWRsrT2Jme6LWgb6HfXl2u0P9l8dbIcjs5JDhr2ZELeCYXngxXw2PAt3A3qPq1i+s/o3diEGRaauUebZNj+ctQJzCRpr3UArmUMw+AWk2FxsPtdFEaEzkf1i3wIkKg2w+P9Ub50ZdAi6Vz7kNenBRU3YQPNrNcF6od/bBWdJS0d2gLGGTiEKGMXZEiZv2KeFGrllcY3GStIXEFC8i6MkpGtJu+ikWIQh5bRVfHW5VntxaqVhY8ykiNU3cWs1nCSnENLWzKqAvYXr1fQoSVgPOxqDxzDyV3cr0XBLbo8mzgKxBd+f90T43xT4wlswVr9AkdGPyAfvGrbPurfUyNrd3Z7VS4LaLNrzTGlBp7YyMsNJKgF1+i/0fglG6uovorzV3r/5llkIeJu364yPfMgmO9vfKLHcn0f5KbAR3qkVedxK9xLb8qBeht8YRI6Tm1NbfG+yhEtcCtb2MHoxYc4pvkGwjstsjklnRh7yrwmhYhSh2GUawLjaSK9kUZFV6Gsy+1eEkNtQaHLyRRVHXQD14md1Hda7UivmF+0yFDtPf5l79rKMow+WQOMx5UBqBSVZ/VLfRfxsky/1gJIU5FQjITEImepBP3UiZiyfQRe5wRSnPQvQUIgsnU6ADvBI4RLgmTQalEjt6amxmxu+QTQcKluwvwRHBY7Uc8euEUnGbErTGTD0qFP6jA7viUc8IeL2+tZHw2X9RvBpYxYUacbiahVca91pavNFkrJv5ZBMV7jR9cVITSRpDIVjsvTUrkQpzhWw0KP3XHxcRaQ04Vem6tzbhW90cLv4q1ZtcFIPa8uGqfbwZAhcAgICfJxKJsuhe4KauOo34AjS4cdlve5V0KK6C0vO+1nXJ6RVNaxfyU6YxUuzJ1e8wIwP0TvnP/0pIlDnmVBqeBqE3riJBpRbWhgPps0yXg+MlY1aPeogTdO1Ixxi5hKIEqX5yGmmDM2QkkYT+Flor6lLi/Ht4rW1DHPG5qrTkGcodOyh+tETBjxxnbpx7XQPV7Wnpu+m2r7PBHnEbtHLuOJrp+PRj+oVPRdMKECE1EWepCpZiradvkkzPi9osr7z4WLQKTojnsWgRAUppGxIARWC9Z9dbK5TkYAATRmgy8NGkIFQhnMeZvnbSOUghToD4Cla1eIbdHKEkQhmVKguI6lC7PIGYpXJpIOXwsOh1HbbVZq5xBYzTdi6ZWX9CjAZpoDbOlSUVVQOe6KTfZhOYmsvSTMaeum5SFnzVYCYg8ibKrBb9RosBAdAC47cnPFlhwhxuK4UcvWoSudRDFkeDwO1NuBbRQaBwwVsLgjprQV2fg2gbMhUKFotEXovilQgyT1hE7tDXbRcignw6xFFF6KBC8qgYvHcWhZYyTHKifMAc4QWA6VgDdQYqUWgCXVPkzFpUQcQC65iMoTkbUlAI60PXtTkazUCHLJQCqy8hobGqQQEKw4BNy/BQmCjVi48ot3tZw4FyxN9FRV3U3ycbQ6ROmm11o9wxu3VittB0KOs7TmQxQWuOS9j84xGW173B4OJFgCXbTqSKxYeTPrbv8JcOM0Db7Ow02uDdMmozd1ARQOLBoGDR95G8FXjpW4NRr2ODkP4ql0WgwPAgXPXI+MNdvB11O5FZDE9tOp6ntOQ4sunyIF4wRvRnmbsH3bNvUqBm3hX3kzjE8Vjy2SOY638svmM3lZjXYlRiAxrJKp6z5rU/bMLlv0fT6LWyr3L1NHevjd+ZiQaP4iqNvevzkrt1kOQ+7hy+8xBjNQp0c1xW5sBz8pXRdTuYJTWNJLdNI9es2UgbXM95scezWDIYx6kX0jLhaYBIgmsithJx+VgvLsuje1Gjb6UJbd52qs+2gjqPQe8OExkE9ByNmKwqw6Kal9BxitmN0BawjOz9JoQRM8co0l80mhxps0KIiOaVxw/tvUxoeXfkd9X1HPEKZQpq6iLu+96zDJl316oXGhjMVxPxp2jrxrhuoAA9eqE512GgQPgbORJGXUjSOFZhyhzFOOU129UyHDSt2WNR1y5P94W6nxYfd1Qt8jyKwaPwMzN0RVPm2sUaoFt2YFjb2rIZFrcr02s0Ptu+vNvr3/XzMKYvlYr5kk/sFuk2yOlTvALI+qRQZh+7ed97ttutwUNe1JwEP6rECchrcbiF2msQ64SsU9mKXqfJyU/tUVz8mXa3orXu43yVAq8GayV26hshABdEU/GiSB2OpwujJSTHLdWQmOmrUn1EPpzd2c67hgtGP6qZxkLwKeU1SQcHuKPJPnhYztAIYEZeG80/n/kIyaOGmmkIKqZSpM42gGS2yom5K/e7aaSFD1b7W5tikNwvA+C4Z2G6luo5wV/VhrdRSWeESzN5GtYxx4Uq5C+3WCbGWC/s0sCtdi2OsVVMmB+CPRTX6nb4ybToKF5mMyzm3wq1ypFOH9QDE3KxhnsB0MqfvCM3OD3PYH2GOvvO2vFkivMHlNRA3UYI2elQVD6ZmnNchbMyq8yDlmEqhpGGxmDFV1yjfo/ML1HC0OswHprkm2aLnF7w31lK9H/4HXqRHvgnG/N1Sw0JpoqaCBisY8WX4dMYaYey1lGcgQ0ONRtS7v0VGXdwdZcdlWeH7pHtXe03cUVrT9scve9k1VWcjG0hRB+R03OKGYAGJWUTUilZIFfG4rpWF5d+/Wmvca4U2iJOonS5W5lLNc+fdxcQPPXx0vRYJqM6GlCAgLpUYUbJCwa7vFGsUeqeCyAoCCeoqDegiT6eto0PXFqrV0FulWJ97DUYsAjhT2byWkwbUpNG5pJMu62ilyQPLywHf22FwWLDlSlAs2gIEhNDIMSh5QKtkzbQYJzs2tOUaUbJR7acFGV8eYEsN0qaySnURtZaXhg7wlnQa65KpXUp3FL8QAHCP6cI5PcRZcfD0AEu3dBrQyHoZV1lY+uDsti5upMq3SD7LNCz9aoQ+fi8eoK0/oMFgd0qdhMjbhrBBY4SQBq8qP0MLWldTzH54ugR2uTIMCAVRQGqO5NWiTR99C1kmViPkq9+LnM/VHz4rGLxpsjjRP21eP5jstZ+L9euRv7r6/J3JzdX/S2ptfmwZhAJGfDFei0aLvhB9bujz6hLiTNpMtW08JTET8Q8WO9D73pF3X14C71LCnf+8jn/Doq+HyWr3f/wWCKJa7tYcmoa808E4dAVwvsU4lKtQ097Bj6bjkCbNi5NtGnNMYGOm12HdOoAUpr3+VjtqxnBwnQkD+4ZYnBRQ0skjHO5+QyAvuMi59vKuT0aEjKB7vR5WQev6TWle3+zU1ZfA29cdc2642LsKIZcnAIyCbtZpUCo3Qe7wop5jsVadwhdX30jietrq8v3k9APn+EsFLPz1RXgZn2R47pGps8alls1H7T33F/x5fur8dVzCNaYzLXRWztYgk7N4upjWi7ImiBEdQ3sdLa8pZfkUaZYa2NfebzExrgpYZBJ/lhunOiTa0O+f+ADxM0ztT+F7aNV77NQZwHXvvrnVcDcrlxy6+KVOukbR1JnnS9e37gKcqrSXfqqH7o1AF2NGmihMBPc2/HTpZWXUfE/fvzEHGZHfMHDqobCyDosgTk5mhulweSkc44pvGidLd91d89ZdGxuYA3Q+4/NTABh5kWaZbx6UMRUPON9aahzsuln2H8spJ0SyO9BtGOdFl6OFhSmaIGcYuly7jU4pu6kVf7iztZLxBXHZOjKDCapeGrvxEmLRKdp/6cHA/zOJgwjZYS93WoiEhoUW4U+ky7UGz+hy33dDWJgoTqYjO11BOS1S8YVkqfNxN1FOOohODIdTyErdQzEfNIZTSoriYfCkFX/4oP7iRnoS68r5d22/uLO7Q/c/NH7jUqhEi8MtyLzP72Fr/Emf2cGI8whl1Sq6eHrnwlNXN671E9vWEcB5frNaWb124cL7g1Z1gAe2lcD7RNJXnqhfmGKhObGyixHpOsKGzb90bvW2CSQNqVa6O3mQn+n0PXfT5ddPPPkU+nDNZoK4JLLF5nDD2bDaKV01Vw2jI+nlqdn2KV565Gce4EeTzhKvXjLDpX7GhzJiTwrBSyHxVNY5RuzEx9BTVNGV8sX5nW7P5+tzcDSM+IbwtQ3GPy3uWWjZfD6T/bny6amqcdTLIhcHwFklU1+pG3TufMgT8olopnhqhnk5q+hJGXwheMN3al/usO/BMUioJkYvT8uR/4JsgssxhMchGbvRsUgdvOOcr9+Yz7H4xsPlS5JIuTCe0TiM3uF3cJ01WU0YA4YAKnsV7kbnGdGdT7zmkZzseJm2x9EPQucT3ZU9wwqYKD4Lm47cbyyvjvAA4HCpBv59W9AppXQ5Gw4AxYO4EBQZB8RSPci4udihWHr5JastRrml3JchX0UIue+6sexMi2c5AUNGaQlRnC0sRFp/+QKeUVwxTWJq0EJpVImNFXuMgoKFzw3HPlWVVSnSUcE4SSWtSk44LfM8FD1J6kZ85xQUeN/JgI82zgsV25STn1Jboav4YdI3Ft7MXjgl7tY8ATxc/4r8ue+Hh+45tDU55ePpvmVeNH9e5ivpj0jP+5jfxskwW79Qhsxdo2nEczTX2b1nn3gvcp9Znjvqp7W1S8/cNApn3NSWDadH8h7h/HN3UolbNd1zpsajeCsdnq9NrnQPiSgO1jcJ8Ce9I9h/ypnzZRfJQZGQIzjRIfsitIfLi385OvnDo0d34PoChUUapcZwh+NOnnCToTscHApJqrhpDrpu/fWyYeQn2Cpp1lELAa8PZtHLinT2WiZoPn+NUqHcgNnt3mTJmt3ZgubQqDVIzZPNy7Z9kF9JxRnoQXhEzaKgmtVtHdojFsOxbPQVnu3f4p7unJLTly/Pnh1+/5bLw/rwa4N/esvF39500/b04E8ffCBmXx4e3tn6MibDy+DjZAaUHXlVnQArrH//ZYjB9rjn1tj7rfFKl8aypOEkd5B3iMbN9VdfnemirKD/BNsAoG9wEuL4sbH3x9QXtitmqoy8QtHRS8Uk1ezSrmDroZf/qZ0xsVtVjx+cazTHK66em0hbaq650t0bevbstjQeD3r7w0rauu7tRaHszln8GDDzFE7XfPwYVjDRLUMGlpAiqbck7aHIVKRsxqQxhRxqdZ3wXaVDgVNNXlvoiwSXjrg2uhltpKv/jlC8WfvMzzbdvz/804EZPHbHyePp6bePGX9JU8Qm90e7b8Q2fheRHPGLFXK5T4uJFKbdGJJuSn6Q1liND8Astxa+7m60OSsmAAJpG8FXBKeK43ihYwn5OIz1NWM6xgPoBo/X3rr3/y1I6sext7VhKRu/oShpBQewJH2h5S7IMYLhoQIgJGZqZnxLpxw51D66sYNYhfxGmr2Q/eTiNvRb/a+yX6JfhIubX/UsP6eqVDK1ucYdHm+2Tq1JhzcfnVNIg4aNTofo/m63wZ4hUK/eRDqPi5tZaw0ckAiht1u7fubLwiz8cyg+sOdHW4gfCCfQ0PnXxMHqNyTTWnPa+aCrgpPV/kffbukd7hZGIA7ChW4tWfT9J25y84kAOY1WEAqSTT+xOpAl6XA/WtVyYzyybWA00bhkpwu1JaQYviey8cxvhCwnSB4orbomgSKfBC9yFIUaCF6IElKVycbl/Dv/B/hRmryQ/GTjRn9ZWudM8574YlXqv+CfDX8Ovvoie8O3WLJkyOcDumhynC/r41FqAle+PwJ90oGOD9+M8/wi6gjOTAyPbCA2viRt/pkP1aPqBXWm/qO6oUQUCeTcxILCYxpoI/YYz0wcoQtzxtQWSXn5B4/pIGEZd1jnix2xvFzZ7OaNJDrpkgMeXVjeAFUpI6DjYv/Fi3P9/a1HhaXZMGsPM5Qp4c2ModZ3Sb0GVSD1k5iZedTRDfdf3N2FBpImt3OWPBr2+4b/Eu4udsK9RMtZU/ggH4tiEK903kcOBuNRUT+zTWf/sk/XK/GJBb4OXjyRDU1Q7zhlOjiRWFFnaheboIo+yDeVctplHSuDBUt/EF1fVdIcWKbTyK75gEuE9ntVNpJe9F+3xXDY5JWl2BniFrpetaCgxysWeqapunAgp9NlceUAh7I3m3mSpBcHQ0kt4ueArSFdNTkiJ04AfNbaPMKFBel1iKn0tpJyKyvb6OzZYAFP/HPpw9a+bvd+++bm9vF453AoHnuLPLS9hq2tYt/v8I+eLlUsLnZgVfW46ZSXFXbbs9fj0JiBzV2d51x/HNNxMpmA1+2j0dWrq0J/ryfyst6LKyvdW06ehPeTAK2vg52Rw2J83LIJ+Lm4g7E2Xc5ctzYA+MEU1fVuIg/2iVJw4bjOOL0uy8ATEu8wL3SPiFVX2G1hb7vghnce3zNV7eGWCQ1pB0+TcbOPs48SubfGmBuVA0SnTk4xmfodPNO05guA0ZG9xllUmus4wYSdPOknp48sgCjWrEXCvnzlBJ5mD1Vf/yr3p4eTIktXK33FFhWWxHiBenjzmGoWfI1DPLBum7gY1dxv/WQPUDKU4qFykgTaIoUB1PPIOVDayFFutUNtLcijyXwp0TjlH/4PHEssWekewoUTJwYoCsCeSFTD4/Ye1FLSYCt6njBAQkVZOSZaaUJVJL34V1fLqdzMhC7SjpquKQFcTSCIiavuekhMD+gwqaNXuwCG9KJ96yKJWANSOsnH3zrEYRLPlnPs6EjirmpXmDBSpp2yTO+e8zyhGjvIK4WtRfvUtRGhUNP5clqdJIjyt4O3aSAjSuXjT94LGjNl/+2nvrmPlpxrxyMy2CQZe8bHy93l4SJKUQNTxsx4BfstEX/pq8GmuFTW5r0k9mpeYQqmzEUQ50wRsjNS6e4NtHzqPgq7zKBsmymRSZMfLxTJGaCCsJO2FJiF9xqkolRevBFl6mf+bhx0PHnQ/D9oqUSCE+JJEZyk6M57aANGvUM9nNSA4kDdaLcqwgFbmYs0xGghujFjDOavl2tWFrIELXYxSSZKU41eGiUwHax0qvOBNEZz4hJFS7mrtsygvu3BnqC35HdyS9QNivGButSoR3W0JM+wk3mFjJlmcfeGDlvKKb6byWxub/g+jrOXqKQoKtelhRdRprtjy5y8t2QMmzUxt2dyRyAH+8IvLD7Mut1KhIcglFAt4qAxmfBZ8c+lbDAk8Pts8yQzOTGDz7wjPYqXlQ/UQK8e3dHSc7XCu5ucS2Mdf3JSVYJxbGu2PYhNzo3GWdZCV27UdY0+tdY14xroaf/2XV1lb4iAdYEi90jKT8vNjGhmuK176445ChlrRUf1JlKj4a7Lq3nfrm7UkW8DtGmTGwg/mnadwxQzKZnaPTEw68mRcj9dq4oIGTQjJg1yBIFEeTdRFLjOnde6WqkxljvmkxEuyPBImsgdM++FkTPVxE/MyNxDodviWkQUELJsLU3u6iuNNpq042mS0uTuvslju7+UDVOKTSTE8nJ5lrV770mAtdJZs4uBRXPChu1dCygEoNct2kgVKCcA4qTMdafe5mJScN9zDG7kOBuixMp51xf8J6ZM9LTuLFJ9xVgbz1oHS7F9a96558jw6K4jnVL4rlPepNGnYcpRZc88N3BUGBkQeQo1HyoTTsvGb9WdyhJ3g2MaBdjb2wywtxDvfNUqNMjIQSsS6hYrXoyEUw+l6a7xbI8dHCG2Ncl2a7WG2lOb/ffMZTSsJ1J68yItrEjrsuKeAUGWtG690+4EQiiVggaeDWir7Njg9n6AkCqrBJayURUyWdd3MQ3AUf22NTBLiMxkDkRrA0WIJUKyMJqJeTmsu3jbLJYKg2lGXub5FvzOLzJKlWwQlVVsnKIxiKhMCI9LFAYI2xUvHFdse1kVNdC4bLbtV6nXZdUn2kAmQZUcBJrSOKQmTkTpGniGnRElx0/01v7dMei2MSUVQy4A2njhDbw0GLISsDwxkyNRy7oaU2j199glz6B0BnQu5LbtaavR+7lfoYPMOLyvYKE3Dan/itokUt6n2+PQ7ZROxgpkhhZnAh2XrlnJ3c3RDgiqUTZ3NP6LreBguz7lBcrlx8OuBy8J36YddSlzLmZQ6BTARDCFYojHlUp58kSwyZbdkym3ZRf5LgXNdW1ucD9nc+EbreAC1GYv1jcJQuoIPHdOjNhNt2/9OTmjwDanCa3MYyofmFjItRrXlbq8TB0l3HkNULRQ9sxMNWkZ87AlnoNH1srZNzMyWvGMb/qC+fEHNfs8t81sAufZgxUyLmR4d22ptZ7XXsfdPyxpbtxE4VNhbPVzuChyUpWVcqnVjEIpGkTDUSONA1kPpt7qFSX99Pqwd8TYvkRrwBhfS+i9U0MFjQzyLEmKsi5wI+XUOLhNu1k3F1V6MjyqHk2xpMJ64n9882l+tZvdRP71bz/M4ZZaoWc+/6b49vUX705WF/SzD/fn4qXBE2d3Rh+6KoK3OuloJWclgd/GPhq21tY3zgpnFzzvmSqD0z/fevj53cEF/fl9h208Jw6kpFlpq3UkvQD/BEIIPzGtadE0dUf+P8YbkTg/hHZsvHz+WbpLiZLMe+j7/JgxlQHoxFclbhb1VIF2JCe+gHPbaOGjj0a8D5VSEbEtXWQtWdpTnO4YwPPZzH66pibcHf9sTjsFHA6u+vMeet895ZCKwzxLEX4CerJfUt8H4uGq7GMQtIyW6pBCYk8or9fu6EtEzjyIPbcYvXCCmu4x/LWnT+Pt7juiz87KsKCzj8HoY+lD3Ieu6cTGgVgu2PYv9+30Ye7D+9+iZOTQ/HO3iiBvDyez1b/Pqu9zqwbdf8bmoO37ZhM4vJvnOGcX/j4X/GnuwhBO/jM3f06RcBuXsr+84MZcy89laDlw+IR7zRHDoTXIKP8YPXVZubXVPC3x6Ctnr9h75qocMEQvXJ9d29Xzt8bn+mJSpP9dvmNmLN703tl79sGpZxGchWeX+h9i/draDvPfwV/jA6n4wW/hx8Qv7Vl0/NbZW/bCXI/Pnd5V6OHuv0+65R/B4cdhCOo1n8/zyRGheh0f/n0a+oId06gfw23g+LHcFsSjRNvZcSTxCHiNueJ+vGo2sywRUsMn0mav4cOQAWl3A3mEMBW01vMsv/ZurFxtTU0Xhnv6KcmC1WSFeiuIXhfjH4qwYPfnW++G1uWjYiWkrUFAMKH9P6+79KUvIk2H3W69iUz6ZuuZWTMCiqjb9OGqbS5n19awMTxT54bjf2KkkVw+ubnGndyw2g0kbh9/9JdW18CpZb5BerPvjM01mGpEo8w3bZSJ0DeKVNHHtLaqbENk8hFFX7fTR2jkMja4yIPkKN758c97U0J9j30x6Seshsoc/Gz+DofyvO0b97eIWJ5udrnpkukGy0e8cr+Maeg1t5nKh/7f4sdh22FT6ZWpLc1XlVFPX19MpbAzo3yuXH9slDt07nVOlxQ2TvJCYuDUKA0Y6wF9AgI42ida4a2sHplWRHcgWq4WcYz1Kr8cn/qNkE9yY6UeAJs9XyankuEqXdXyL/7RCcvLG4YpDMJpTKymKzKtoaGZbJ+FifVe1wCY1w63vvqMhx6qhtZtzc0Jyeb7ZnOsjdtnF500a4/4PkWKdDgZtQqk528nNXWT8+L79pccLdc9gK9EI9JJr4ICagZLP+INFTrlNPYzOo00Zqa0muBb0rfFqrsNy9W3s3O0t2koHJ5mtIXPMbd6+/nZer8h3j69u/Goex/iuLj79OnpVfXtbUWTOlLsUUZp5Vr3Ndm6PTfk/MZrjw7fBY/G77fbOLr7pUvigZN3KXYm5mvc0li8IF+X5JL8VXl3jiWhbZe6e7PNG+gFfB1/ZfireHeascLkczjJjqU/FCgT+/QLdGTW7SrzLv0PjnMOjgKid+jso9JnQuG7jBr22FQpKt7B2Z9zzYJlYOIkUGXeoHb2VqoChG0h1FBA+OzQGUM6/JyHj/84PL7azkf+7icuJFpU2e7uVicq80m8zcnsweThQ6AOsJMu29vQ48T6MYKgcwSwwavo7S+oF0yqgGYuwTdH1/bPd1sEbQz0pGFxqN35JVtQdLy8IHoOj5wdTpPi5NW3mtlkPoc86gh9qoTUcPOwPoO5YTAdBdeW58ObLrmDBcg1xHBGw93HbOvmywsNda1hl3FEiLQVj0Arc75mJ0wqYWFANExobwl5wYvaEG2PLm1dZlQ4LnIsE3k4dEuTj/0p5wsLMMlq7kdZ6fM5mAfOcyu6Qq4zBXyPFxLtyptePpagqGyxIurXdLmYFlPXsjlzKTDicCqd9gHca87hKctrWmOWFbqH+ylm2hHh9tdhWXBkJ4/ebXDE3WEopjDRIqXugLtGHAAjE30Ej6b5Jrxgk5Vrijd4bePwhcq56q7Zl2Olof5BxbciKJZwEHmT6h/FypnVtq7dm8t2q4+4SQl+i4w1+1PpzlclfpWKr0hGvkLZ5UVDUeoNAO4LJBbkK/bSyMHxgw2P7szvLtTDMUnUseHHYm7ktviCQUw1mxiG+zKKJ3PMpfQHhPCJfgojyNfyf7eGLgofXxEYTbIt4x2QxdeyvqaNWYX21Y4YeTStg04XLQc1nJMRKyhGl4UghJ1fSHpQLCms+sgF56WAZ+SlRJ+5IdEAT+Cg2Ty5syFxL3wTCp0mvLI+S+JobPDawSx8szUFWqN80E6wKDhJhUO4wfETtK0G8ifmaN3gBX4utNjpVUMa0NTVwFQyBP5aNMaKvbzJqIdaenaykFVXH+RGCq60DW5zabhgwvusVmCgv2np8AZJIcWDDfHRbiUV74ePQNGLJ9i2j4tX1HbNeWm3a/qSh5H+ht1BJFTZHXLxBl78DAdeFS01NUUUV4rTabGB+cmWCy62cfeQ/iWb7WDgja/Ynb6p1sd1K+JRHifTGpsXWrj9t7CE+RalL1+Fxxm4QgI2VDGkhd10I2zM4fUtF2L6RKYwbb7iGHZw2tkNBwPfYpRk1HXkRE2enE+RwsxUS/OcPEwhQYNktik9pIV1BLL5meOYef6gbCLzqmItHdYvLhJDTEwwz85iS8eRFFWGYRVaOu4jDz2Us5FwhAvyyXeG/QwvXEZNS0hAxrfYvwYrSdW3cfV0zhkRMAfywW8uCDHwrxnzO0N2itezsUsBge4NlISIoF/3xi4MumrUCSseizUElmPc643eu5CxUX3gvul0oi37eFmzIasCSRMGpTmBXETFo7C67RzuIucI7NeFLSOkSpyORw29teVUIgM0i6pq5gQFUT4EHprKualalk5dyRWLpxkjDMWExr0gFXhlZO9MCo5LLBCCY7qxj3A+stuH2/V4YFH4oHefUzJtPxN3g5wMr3IKH4IaQlWXy7e2SyF9jVmGXSWDEVgS8KzrTvtyr5PZqniAUev1Vgq6FqYfUBsGAUmsmxoMNhw03HNfioNYYKH+Safj2LrLPJzzOpwQ9IcsHKG4X+ZZCLYDu4bRntBwbjsa+KAMGmqxiCvPAgt5fX86ZDgYqFiJf9Q6U6iddu0wArdX8pYRqHXWGLp/T3bQ5Jim6CG6C9nB0NRttqJcVkmVqiKdJVSeqkPVwSWUtGmlqhlxyZIvJ40kaT/QdKlm6jQq9Q0wbJmlCAwHNMqsSc8wiwr7GSwlGwNCuxiPJdPtTideJOGhbi+MPGJIAFqLKHDkhAY133H8OD0htwe0sVPxzf309fPQ0Rb9su5EOlRnKX9JXU3Lk8RxbFs8lXpjoi2x/LWxEXBBaHGJ+iG1wBXLAr7MuxEo1ENQaL5Ug1+4NoMp98T1kbp7pX9mjktbmuFLuIBcsei9/NHhuEXA80jBz7+BnTpjM530oU8iiJSfVATC8SOteKvJfaXAMBOD49y5cBn4AZkiGcDg22V6yeuHQfID/LAafA7LTpZFnGxkmAf26/klk/pV62AuRVZwP4664X/vvOUMoe8SWP03HZ9MIok3hNCRwsGMf5s61FW1WKy7vHoKWYM5DgoHRvjYmU8ewIPeC69BUWGG1eVAAIHEEGOj0WBZlq80GT98mjKwr2It3LK77nrC5+BVXI1olIZgyRFva9IEGbMg4Dluo4ZZkNxXd/nQRvDFqM8FRLFcgZpbIRWq4vhmA2JUQdtyWupZg2LClEgIIGXl+UI8f1Np4QtMKw/Zsob10WEd407IhJo0icGigrb5aC+YdNWT4Ww+VRzuM12NGKYGKYM7PsY8vUcwVm+4gFNXtSwYHtQvTjKHOWlDm1SgQkLi6SpEodqPP85k5MkiAaRiKioL3yiKxN0o83xunoBxr4dOrvm+XRpcg9KhxXrqdKmDNVwgvjuAZYFnI1C+O/LyPK9i3NPG8qrT6Vc6YzRZns+1QAxs5QY+Qu6bDFE8fEghKhjwgCcmXeoXC+ytxltgEaDai4i2LCL1yUxtN5NAbSdJW8WnEh6VgWbd6mXhLuBntveSjK5Npxqm7UmCvQbhNFFCBKNfWzkrr/LmG6iW1QK7u0LG1bOYWGKWRC0LT9LU1/H6dFuXdcgHvMkEtT6SrH6Cpkde+EKcOqo8eQhy5BmsiF6l9hDqwa2kRjHYemWuFQzzqSojFplQTa/T1rBtPcfdJB4XkcuKuUHpEpdyu1tvcFMIJW6ScDS1cBZk6BdWTzIXDJ4qaw9Hm8OdS0q1wLTDN+xOK8T/KKgPsl7vDq6HJ/rd4IksyCEH9YG+lYIN0jg3mny1jAOc5kmT2Vsuh6gNI62/nM0bLqcWW3Y7rYool7tKDCcyWg2yNY5YSQ8RtSdTvN+W6iv0KtpQZfOwCUK1dzUGXcX9TM1yKEWWtRToAkBxpJM0TQQ/jrv6vRS/i/z6lotU66apl+M4FeTiIX17nO1ossj/x1tUEH6C8zjZK2YotjMZrrD7Dy5C/J8SJelU5xFHKEvISBmzVqG+bAgWcwKK+zEukLlroQBL2sy8eWKF8Q9HCTZAV4pIuJQ0wpvrl67QY2ae96JJ2Ue+dQ4Y4fQQCdJowCd7prpy7wHGFfbOWEirOinbzkETirj3ckZeF4tQaOHXh1wj0XWx/xCakO4/fbQLq1IRefKKrBm78Xl5nWH1+kW+GA+n9IiRvMmg6JRlKF5fJL80iuyCTPMpNR3ZyNu/sY+SnCJCSCtFXKLdlwzVLL+/4iLOyGOY43I1zoOBREs1vKFAqDfkg8ua5bQ99rwi7qLOmraJel0zWfbMGhW3QcousEVWRVtx3ESH6xxbMBA1p6gscCzCizXaIAyF8MkqcecRJsBLr9FifXSlwlNps+bUMUILvasAI9/geaGfBhBG/7J7A5uK56W76FBkK2nrxLFtg8LlhdIH3QpVoUjEF2ApnOIWYgK+5YAUYRIyYcglYH9a3NXlxbgWERy/XscPm9kAjQ1PpRuvmBu7u5aASmqIe4MSVeVlXDvkOfAuPu1c8dBFn9tJCCFqH+Aqk5qkoNMYFxO0z2upTKIeXG5BSGG9LM+xz3HMYbFRLzWF9tCqiIT1TQd6myBMTS3aeWDIYilpAxA/aUVG59zpQP4JAm1+CUVEMgbPj42o2m4rzSGDF2UBUClzXab6VyQ86OLCuhcAQtIbYcrY4COlsPglODHRB+QYekXpw4Ga/87yjUqmQc8mlsgDOJQjaUepj2C04hNKZd9DuGRble5AIw1okMZDjPqrxx+Cuv6DGHAcBfUrX4MKwTTixvymBnLiHCfMFIX9uFPs3LmHZ6riZMeOyWgkML+ty5VKr1ceDkvlSq+zl8tIfUxVVRszlOHY448/NuPXEZoQikn0WII4NjpRYH/GKzfgYqt/NvMjOhorMqaJJ+Wh6/spHvClUXud9/tH7FdmG40rPiSbj1kV5fj33omfblHBCG2XhyRx5ibEM9YRaDwEhQA4QLFL2r/lG/AXMWc1VUpD5polMoC7WduFay0XfwpBMj0ASPq/UDkA9DpF7tpAC8bB56EfkSbDTdGXykJb+ygGaHb1z7U41rKx0eH5zsyMAv34K63JLaEQRXk8lvhjGEAa+W8N/sef+Q9MHGGFT9fP+2zsSwPBDoHRcu0nFBt4thA/p4KghSVNZEA+SREjcGrJpJ2U4c0BoemdUknfeuZKa8KiLJfnd/K15FbgITURfhUuJIoolbuenDmUFJIp1yPEAoL76rBUi05hdKEpaXV+EFCLJoLO7bp9FU9pw5SEliIQwBW24kiWfjbXfN4srHIQPOabRucBE3DfIwIuxOXprq7TQow9ttwXtbXa+4kcMA6oK0kv+nakBjVvjddLvhV9L+oRfuXWCUy+u+4ADrzH11zIwsn5w3w5puxF053URvLgjXSeHigZBS7f64ZB33Rrd01JITO6Wz3pPRM74qazkin8D93Q3QPE4JvhUNx77cDTt4uOhYHh9eS9T4hSqKthpd1vyS7COV3pdCdMzXtJScmdHCTxg8+6451j6vgtRPHLD6pD9BERVDsuZgdFA7TEC6/bBlteiyQfcwd6V+YS7n0c41L6qqrKOyl1ARoeiQW5Cx/WpVA3a6TjCOEA2a9gFyEWpabrXth/ywVYCvVMx2DoTNGfoOPoILhbklEWqsin5IfVRL/u0WT3JZPq5m600vrB9QuQSEbYHEcu2ARgRZiNOXmTzm/Gy13Yhffr2tCethFomS2PYMwcvZnCA5a8K4EEzoqa7i4+utYH37nWH1bUisTNIbjiEkJOJDKuHLpuKOMzOKisadYv3Wmc+MrooZLzWJRfKRJudIhAMdXwgsme6U3J0+PLHmaqUNZrRbmtcbWpKIpyIIV912SZL6mlovBB3bJFWlQrEdUj+ufwaastTGuhi3ULWPTSd3XTrxSeWIwhUFn2zHHtxpabvIxT6LWLgRQTXILOspkG8QhP+6G32Fo9iunpcQe67OWFoddcFynZf0GF1uoSO1TU8AELYHIUV279oBMWGCHnkydbGvxQZP7hu1pFuP5J2Dmx8jfDK2FIjX3j87dfmvzr+vjhlyt9loslc/8lg/HlcT4yP2Bnm4y0bjTVgKtzpqzGJ31cdr5Dht0l/EN0KWwIK5VjM/E4PJe3DHCPhVccUIEjnFvaFTSmn3tDpZp2agMklbPYkQNVenPFGxtLiUq37QCiDm054yKgzBkHvUndoDXN7uKgeYFY/8ezoCpkyN2dQ9ggALWAQH64Und83lhitvu5DQrW4qo4mLUw1abfVu2KIICZsCUX5dMdfQkyL3sZLREdhRRT0aBtzRXo6N2ygzbrnIjyfAPfZQ/ES+yRGazQuQUZDF3SD1e2JyinsMHcVrFzZzPEy3U/8A9QAlTB/i3R0thorCKhmRtYymcRi4rUgUkMIlG6S6aM2z3DHe6xAO5ZBQ70U+V4O4j/kZ8xFD9X6vNO/gFT0bkZrZ5VZ9jzUHzIKDGW5ThwknXCrbrGvjsH6mddfcbGq9lsFeOzk5KWOF1wbfaCn245ero1c3Oa+rwo0ytGSxfe9AJZPNPt1uvVqhZ/hmdIp6kRyvu5cRBbmbL5r3DIhrkwMpiW/oMhmmaSaagqTsVpUWSGD+YhAZWkWdJr+PYO7hNiz4gP3Qd3eRF4Zul1ukwoXUTBQT9s/9vISV4fq8J3LKo8ezYwgYFo6cA1RbJMdfj7rswKka8jPXIIwg3G8pIucmzSy2DgCCiWzGbKbUhm4spCaU6PrwuNB1t2y07djmydsYxa5vlraNJHL30PA1f6PTGOeGI5ZyNoxOoaRGSs8GkZ5PemasZuuI2qWCxeCbGax+FJHfPaVpL2YQcOqmwmUq0H3M4qEWSsklIdhNtig1ZlunJSkNWkjAgPjnX1QDNSGZAD19HK95Ic5fvDkO2dqain7CmIS+sypdDlCLr6eqmQ3SpNzSJRFRNUpx+aZth3VIaATHSXuE3ButVuFvAgGWW34UfdQdNSkJCzgVNS2gvk5SNuddg8nkqBKFdUUXMV/YPjfJ6t0FWqELnMMnEBgzQgtZOH7ppM72LViVnKvTLy+0b9hXcJxHRTrDyWpZGE9vuiZ9bVVK1DLi5sgLfCZVQCS5AW13l96IfeFl4w/CwgcSEZ/Yg986YDWwh0KoofzTEYcQftWh5A6eVL4i0onMkbMWIyhMoEey0qWjJwdHVbUAlLrQSJJQiEHwdFRG7sVR2nNAlLG/RmE32Yn1abpDCKn1q3bsI5/FD3JqKbODa6MTGQ2N04R5rr7O+YxFMHRKLTSRD4lHhTetog6fOqV0H4JfWSOiaabZKwkpZmk86gGxk3mRnz3sCmsC18fHpj/uT84eUWvWpH19SSmTmcr9XyYbNOoi6PNou7ayf7ei5ZwYImmA85DYhfZMxh/4+Q4cjvSw47QlaSqPxdcgXLzl+4kb4oi0/3wRC1yD8CcPFUZ51O9ru/W60W6QO1r9BYYRntmyZuFaF8wg4sK2DZSgQUSvoQqm4wZBkiBbrhkMNk8EqN0sUdXFfSNdmWuKiEdmcuupaj1eF5/9uQxaT/D6jvrPJLUrsoYHlhsTglrbTb9Wzii6b7+3SxWF5B6MrDh3dzKGd6Vv8WH0dFEqJNlRJQGHeu9Ekt0mE2vus4aF1vttGZkrXz72kjILZTG32BAQVy7o71n1zLjeyU7j0fLTXxznqeUQ+apmEafsXTC+Wa/qi31QfMFMh+fHRk0DqKnVbHEL/Scl3XIhZlFSDBDDSj0/4h6MksIAPz876GIDK6pAjSg3g8jgsFcbjlsHI5Ip/HDOd/qsDD7UJmuhGN+7wTT7VVq1l8xAvnh33FNID5/bDOP/CqkhNW7Sz0ZWdIJH4XGTGtbiV4al5M6iBpxmaYE4bVqEp3GtJMve89rIGO1IWcz7uXmnDq6b79k6lqMWbO3cuQgHwdg+0o67irkR1L9fnJk5ZiuYNSEAx2YZlmFPddbKmkjWoU1qvvmVoBik+oyhqwNwJ0fKZbcqoWOmKlKzbQXFlsQFG7MsmLkpPlLfx6bjWTGk7f+orwaB8J4IF/JT2ClCzSt8Av9KD39lso+Rq+ftc38A13kHVdQzUzRiJwd11WJABzFtiwzTaeQl9SDYPpUzG0KL3Ua+Ul2x94CEpy76GQojbIiw9o5mF4JFS2khqJVztFUDVAwSwUZlxLljpnwIZAst5XvR0uOFb4dL4qnbq+vZLrP+a1HcWmsguFxZZp2f93Tsfr1yh3wp4IysjYN0Jbo9gimetQxbrWC7z+/VljWW70cIX44y4GdrdgXd/W6bRTgDhDW4fSwi4KjSG9kbNRKqNRRdk4bHVlNJJ1uzLZFz1X39Cg3f6lT6v9NheNfbxIy1In66J6lg7Yj5jHZYc+BoE5QaqRa0n6P3jH7Ty9wGIF/9j/QKQj31QlEeFs+GCCJAmFxeFwTYsWpd2i082rTL6v8EiWkVMwcIvDgZgO2x06VJLh/+Cw85mKhl7V1gfId9bJu+oupPdVJrJfjOIFy+qq7mVRXyz2G+OkXWb/ME2HtYijxeMqk8r7DNB+yKFSfcfQOijg4hGmcYBUQVr7SpljLS81bi3wT/qAEQwcPa+/P7d8zSTezejcWjzNbdn3vWgRBJcUQSCxzqDhklhNDXCPuGEJYm8LGDK3G3hvLBi49iVCD/7B3ZbRH8HhSDyZCQUZzu7dsGz2JDIXBdzYKJkrjRkVDCcDUjgOO4lj2B03mknHtOXrJUuhppxHr7U0M5g9hLiB3CEnuyHYEUqXUEfSdd3I3N4yivg0jB39DftVghTJHhlElxAa+eGoDXZtUWNvRAciROeLvaSgRJ5JoKSdMcK/0CNBDySvA/f9lcE0QGDKnkVrzPaiwOxAPsSwxPp3Blqrspv1XgEOp0Okt1ucalCw5JDd5IaEph2TCQlA96pySUPe94L2Tjd7fIidWts5M3GfoXgnGz679nnnJmVZ/jgfz2V0/+wEolVKrgxM17uBncXk6p+qC2l9CORXL+2800xtz508blbW5VHAi3svKM/4mnf6JBdx/6EE752g4XVHzje9BmevprteSG3Bezl2R12L1Mrfhlu4DvcnOuw49Ct7eN33T+gjsggo7HJa/LfVzIorUEWNjG13Faqwqj7UE7VHhKL5JSjN2ecMxVNIGxfpTdyCIl0o/F6iW3t6OvMHrzj4UjRYnCGOU94dt4Y/prE2toCQVzhZMcAU03ixcK5KUy7revZffj25UCnjzVlpM7+iL7uYTpfBMlPY7n7gu+FVIIAQMHm7X8OWFWyBLbBmMuK0uXRRoalDMgQPTR5dtodnzyKzyZY1LdbxIptVBy7qWh/YfiVf067kytIqiG3UUiqatUQ+R5MKHBghoWrukhfSmbKWfcjEblkyyiNFMzakCcbdN8mjKzTcs0s71JjS1tuzzBQG9XmQO7mTH96EsTHT2JoTCScpC0dt82AdnQxXCTNVaM4n5ktl5mv/tjfMYKst0+DS6s8GPtSX3vHB4xDMi3iBKlabhMccKVQuLsQ/50a56dTk9M6FuVF6s64SJR+8P4Uv1yMUvga8auE8UvTG+Iq9ggZt7xbbJBhnz+p+6rWlsCUjzbO9sF8sGRxsTuSeW+p6zsahhO/xHWknRLDA8I6Nq+UioE4k/cWR1a6FNh6vr4bF9Du9aVwuubRN8aO62vqdCsHi4xdZwElz/vh0GgzUTDE+sE5bq5W5I9xtqzIAQEqPMb+wnKVREj6FUJUoF3x9NkvsmCYwmiTPKwxBXHOelBYIASh0q7VtWNxG1DpNHSGi0lIZzu0vT03ocuWMAM90DAJeKjXe5tDFMrfW/CAAqRe7kPG+81kF4jhXY3lt17EsJ+XTwx5CaAaO0eeuZ6mED7yHIbW1GbR8NZC/IAduMK5xlwYfq+3WzlZ/3/v83qV6qA5zc+4X2DxMnfl6y20oL8vojUe9v5G4Jj/UlLbPkqbxp13ULxWdLFxcOK8VpttxJCoaE5WOYhSgsJ5TCu7GdEHP/LK4kPj5ZySIa2REEagko5PMNodGOBiDd8ALIGZQgI/BMQgA6sqiSp2i2T3YYY2YtIT6eGxo7oGmed0lBAHhaildQJ/bvld32nP03ZjPxYnBeP+xmWtSit56uIQCZmX0pkw9b0RYS+4k9LkbiqDCmDLFNrMz3f7rmMxdtHipdbl1vSUWtX+b+Mq7NqLzd/MNEwv+8W9KLZOUvvK1byhX6hEprC+366vw0+w5uauSHJ+JGIeaLFWYNNZN+FBcCIhvloELt/g1bem5B4IIingNpONcYKcK4XwXyiAVnjr4QHZxqZW0TpaAOt3kKiU7vdOGL7Gb+zBJU6zm16BLqeKYkZZ77kSrjZqpz+ljzbniKqZ5i6QeslBFUotlI5T2QX0sga/Yt8tWKcUkBHBQODp5qEyU0UPm2WiMsEvxn2NnjEQsYhgDunNlyVtN4IXFsQsaP7Echbn9c+V87gB4jUjCGIF2J6gVXuQoEddKGiRVCeQET2FS9Fwhc8VbX5cQZJ+b5NEtxtEC59FIU/EXGAL2XHa27v/m6mEMYmNjLbLtsNUCQRiSpe+bJAGNLOkmNYMPh3bsBsa0477JIkXD2Oh5WCfpbLNoCTzTRmzhZkmXXmNARlopGacsgCBLjkro054DBqB3P0nHigNvwxiemgehTNgfZr8pXWfs+e9fcaXtsOzusdc2SaBI0tf5+FsSb+I9c4ni1xkjlBI46hOFui7MyRzPU28R+XpMxyaXpq7vu1tQrl/GsD7Av8UYAiB7fq47zPLJNxE+cjKYo1yLyeJDRMI5PSYfgAjL8zC9DwEwKemHLCLHnAM7oaSgOG86oQWLfUcpToj4kKM8ZorzHYwwG/OFV/j4tJtfjAVySlClxaLxkgFH83ubnrJ8KHTYPYXTaQt9tnRKhiX0nd7hbIyMI/hBTm5+CgNWHpbR/4RzBEk42LOzt4jK56178YpXX1GupB5MS0WXKWQXhleTK/h6XnTE9jUJRyc3AtLyXei8TAZMS/ReJSeni8K46vefgalehJIywhkcl8pC3sy1SCuPN45RBrAzCAAbAxJRyUEdw1Z8U+exZgKewJ6mGYg1hUQdjFBBZMT3cdvxW+Q1Tr3PARYLytt3ijR3YlGCzX1yizFjiQ3ySqc++tL9+UvTI2KfMG7wtVdf4UR+tT1SOmaBc9TASM+FernRy7zvXOHuOCSyd7xsPPG4CUwW2wu8Q7euaJUgSXVhctU/fgYkQH4iILgNvJPgorfC2gA0XVKB2Uz3KO4th4TRTCWUGQxpHurbp6OtMroWuJOaLi75ACweroNl7IMxfNQsGgwqy9KMx14L9EAR6RuFsxlE4pQHhfBreE3RAyUj73/4iOeNarj3E6C4Iuan1lU8WyK1K0LqUdXGmC20rbFBMTxOHQ0Mu2IFPFzNbKtTW4XQuI4YK7+8Gorei81mRzhl9OpL9XyydznXtHYY+80Zqkb0orsdcEXWyyCl35Wp3BRfpYUj6gL11V7XFJvNbtfLdHb99a5enRw45Wp/E4usKaANIouLHFgAAsjYsJNKMH+4ijORB8U2DBY4nCCV+N/Rj1bIZ9t2gNyzN8UE8ZYlPh4bQPw7noMbqyF4jVkLZxfWLblbGAS/9NF4eaNHbIrCXyNRvzc21B92wRHKHOTCKV610ezhH1C+ngF77ZkuzPiEb4+fHndHyma8Qc2bzS80rO7ji3vfP+27TnSfN6CvvYlOYpT8PN7EX/oqTZPkkTc72dd4s7TS5zV3d9bYeVn/xlMG+Cyk1yTOLpX3X/r0S7sv0ZXlE1ZH1GcbraiFnl1XRTYrD/fNuwaTQto+j4Zjl4lQUtNz5kwVityJKxjvDwLC2+un192VqoWXZ/0cVeeL+u/nT+fdTGqXN+CFbAbCNioSwIl/MHzmq9YejjBga+nBznjNr3JQYcZtT4G8r5RnxuU4/DBalqN4bhTM2GRtKkiEfoDmuaV23YxrUmToTCIfQgQt9KYwTTezJDwngAXCuLDSjffBrNyFfGDzFCdkWT85lRqNvy+ZBSguFa3qLpx4Mtnb93z6nt17aHgQ8N3GETxiHkPlroBy2S6/uoTtX7Yp9QYPVS+V5wJ4Kpc5taZfl45qxuYJO2Qa+5OINBrXFtBMkpIdMyecFIzZvJihfYPseKSxGC2iI4uq8Fayb/cP918/nDa46SVNgzqJoxDAGhC+MTpodaihjjlYzPoWALomRvvD9zE/+VV8fDBFf22z2Z9LLISvO7WQHx7oFmkm7Wub9jvkAmrXlqc2Spw7dvdvuNBc6RAIx36HjbRbUc+6jqNsyyM7NtzSBtVx3cUTXkQUcHNIunNRfLLJkRDhnIRau/0sK1DiHEVprPF932kbXsdslu1LELKb1NIzVTCMSkenACHvyNheTx4R3al6XdhlA1aMzbdjXVj6Q7pja1+EVR8PQ+AU80iEvTTUBl7IyMsfhMjtgwJmSYSu6XhEnzyLaeKOQ1z0qmcTJu/7kprxOi+hPOElTNa0y7izo+UXludScsCP9iG8iA9Dgd3cybPUHNzwm1DBkqbaNuFQshyk64RV7eiL4+ysek/H4FXyWgc8LWnX4TiswA3l9bhZqbUt92BvjqPVMiXyOK/avNgPwg7WGlNnwZgsW/8GA2LDaQHUjVqRl9ht2jeianku1rlhxdGsa2WODGt56ykRN0scUezRv47YqrnW9mzgaJ6dfmVfxMm+jLgVAq/oc/ZMRJBc53zPKZDGQJouKtkFOiRJdcDEkZm5gru2sR4urTYej/jtMHwxF+up1+a0fQnHslkOQnxRQI9V1Fa3uS0UX8AJh0rEaB42KjpUhiwSH9sqoaEwx3Vds1n3zGKwe5dV3nvUPmoGP5sCoOBmPja2r8a8loLWMeSO4uYy6oKSie51rbxu0ijoZMG6HyPcRdm9xCWT29e9DwuSQsBCNh3gybNWMK8O7+HYDOFuBni72draxVof6hKx+87dtTHHuqziT2gkSCHIfhfrUn400sriW1cuWOb0FB+oVldMwzBNl7HLC8eDMkiGMbkdUXz4U98gQPBj8DLgLhir95d5E9mtSM5pEaSvTNG/y4sQMghooQPCHQEjjlEhLcoyX39n4EZbdtG/Pfcou+WfnReWnaRrZ05oZq023W17RBpY6XBdyw3c1E934oUZ1jEKd99CRSydXF1VYgioFrX+RJ/XXYhw8vc8pclXePbgJo3eSolw4iJO4eRsL3v4qDcx6TZLNpC2mWCylwS7zB4e6ojcmbn1in01wCHjY+UkCwzGXHvq9478QvIVbSKqjIXj2lPfR9X39lzD3e6rpb0scYp67Pyl3UMOiinROvItKg45g+v61c1NfWw9cIFXck7sx1qijbX70v5wNKW39/33oJB3mxg8ylJyDoG3fh7UjKYpyq5YGurwlBeR7MuOgKlICHFRltWJmytuKi4zV4R+EJE3Fir+jfLbiQ8QaCGhPUopwIeIkydsXWdvGkiP6tWAbp3InBCc9Z7ObNb16k4hIVW8+HaGrMiRhS/X3MuUIlO08tNO5lHQe3AyN5oMI3LD7da4WV04z7n0HCD5SZsjSa494TEqWDTTBbTyKKg+LA/EAKkhWoXUxiWCWO9iDpRWYxUq5J2hFGz6qZnABj8V/6FvGXjzU1ErkTiIfqocMVOGafhKxkH9wCaUm/BGjCJ1cAZeA5yHs9x2ADhp0+ptBq2/z20kY7idjM0JtBVtHmkz86XevcVeAyQ/ibBzMR9QPRKZ62R8qpTAIy0+02YxjNoeh1B0PRpJe23wBau1RCIhpDNGKWDGJVrDSCvONbNcJBFda6fEtQKSRGGnIJ3IQ5hGNV2Eh7Ap6qEoSv5BuCnThGysgkjsygeN26DinpOHWEXrhyaj6qTzjIXCmIbLaLkD4Ci1n1Wr4PKWQS2bVCThhnDLuLXUZVthUDWPKN5qjjG986she3TR3xB1dnx1la7rTdH7C6k3Q5NNFrRCH7cyZXumMrc91YpPnnV8K/CeEVgtDjgJBhgZewiuEq24IxzJUTTpfRXv9ASBEc5uaUsv8NoeZIj2BoOMQ4Rkm+PuTOHQWJbjRczEPwq2q4A2R3Pn4p0YgEE8W9zrA1k9ZRR8BiUDkTOCfpn3eyO6rvVBiSL+mfmTP/aUiJMq7CKjq/H9sMLGXOymP105afkgJL/Nj83n4KWbz2OxjIbDnqBxE5tK83kahiXdQMzD4w2fv9L4zDRPPj0cjVKDED0paWldV7Mr4EHMj4AYgHWYR8Z4gT8Ku8ofmE/QJlvlTUYD45u4MguTF5pSqV7YVki2jiZK3Cg3s/j6SnTZiFfp9LT9d8VR83Nsp41e0F0LpEYjbiHXjImTK7ThK/zXY6xMV3EAvZVxpjikxk/Ot5W2MrBY5hljHM0748OMWxksc+OMZDqSFhAv4SEgmGLaDMnDbAgQUTV/p5ybFcAI1xIMF5QiNimvFytzS/l5RyireMjGtaGnawwD8Oo9nKtisCyl1PcE50rJGSr8QC5/Z2OECCkOYGi5lAp4QNyUiY4Os77RIBU3SGVopTbDiYpwfAiImWiqgc1tMhh3bb8l55IIyq6VOfmRVEouNJi03sKi60K7VGd8EVbCQFv0mGuWmKyBhtqk4JCywR3ZkHMMV1VVjKgJBkqMc5pgasC9Kf5Gi7AGjrFB9kKcu9OjuG3fWxGtWVIPEztxNP0qfCIO9VTd1vW8it22bBTq2phJTsrSJoylsjvge+iq8PRenV9VxVUR29mizw3BStdsN2S+90XBessqWgnDsQkwy8VvLg/KQz3VgUbDQNATsFC10SX1nCxZNqescXA2n69Wh8wR8TzS+VJVHCq4ryhDue3E2HND1ywa7RoYkQp3UAoBnSda3tykZ3TePybrweaSsmzrNL22NKgKla9fKGZ/QC4ALznPOZ4EtVCvxxl/Jl/QokVy03ngvC9d8mHKNI5wq/gy8ZzcnTWUTSdqi4vl0Y8pP7IzZr4pjDwacl7oKw4VbckcKOtO9aBZQMPFHp9gDJ9P4Ew877GtxvWQYg52cZVmnjsKSe7hMKWgkusL7Bl4ZSa9frGWPnhxoETxSqFzy7lhJhgTHChSirXVSYGUVdmD2Sczl1OEsjlqO0lhhLA+E6USymjfirYKsO4tqnV0YHirlKYA1nKDHco3yqNU54lBYhhpiOuFaEv9WkB6IrdHGdbjwz7KMywLcCu7wMEuWqb+oEnGs/d4MI19ncGWh+2zoYYNHUNPgnnRLiE4OvjdasAZMWtmaiD6SDGR9iEoq3MJ2RFI6dUSAVpmKXPHZPSdhsP1xSlVWs+mStPsXfc7ah1Inw2t9fk0mWmJ/oMmrJDnSa7lLAwaU6X4B6q2E24Zfj6Yk+Tej3RjmBl7zb6yFVMNh26jwH+eLXmTFI8ZMWkQh0BERdQXtZSuZARTwnCJUONv2XQNh3IF+4Zrfds+4WRTAYOIxFCLGzytGMwX2aXrIQ9kAlC0QdECpUg5UBfUOA5UD0oBFF3tYfdBladPiWS6JTtrjeUZLESvUReIigZAceBgF+8gLrd+5bBlyv7l/6IzBbQv4/boM1oyj1zgYml9RUjvs1V8KOau2NGEYSoYPBhDgPTSuxV9eIIkO6zKWwSIeIaDqLiRIdERNECeEPscV6YphvWoYlAPF4PtG2qGYlCa4raLPCctY5fErDAFwTyonEIWhq+Y9FFkojw3T83JKWn4iqGmyEJkZSD7oVtpTLhtiBmBNx6m17N9JfYtoojFZ6TUyDZUJiHo4pREfta/2uHwgMdm7IGMo7H/lQwvag1Z3NO755PLZxdq3D251viKwysaVxycaZzpHWkdGPec9PQLMQ1ODbgD1tQ3gUgZEuEiahBgBH+ADgyqBxgGJN2lFk0DH9r1UdxWO22kqqoOVRxG7MjhzdbEsWtE3PCAAF8hKI4eXW9OSzVeuuTD/boX9E4LoIeeuWGLaT0tym6pjogGPQx3NWRAICxlbPN56cTOboJIL5OhieeAJCvhmWCf4wJlwCsEw0RQ4mQuTaqLA9rq4jh8n53qJnmXSIOTCOi8iZvixVidPKd0LmzOvnM+BAF8CEVuQAfupPRFw/Xx0+U5LyHDYdLDnQT1Vt1DgDIIvTvrryYkL/g3eXUMTcOCc855xTkhOBimfhgJUVF0u4ZIaW3eBEMiBhwoFpo9n+DGpEnU0DQFp/wprjbnY44gkG8UeRZAiYSBcavN+g5SjbfwoHfWuBQNoJ4evKjXp/WM7qW70cEtkxv2bio7GdrzpSON1Tre09pBBuBkxJMD4YW17JtY7gxIBRYdyQS8CfgA+GSMC/zyVSlWgkVkHczPaFnJmRZEE2AYf9uq2EGHhjw0PDhvJyMqdkzcJSwxSllcwCeDB3dVxIag+m6Jl1E8fO51bfZw2sf7Jmpv7xvp1UxvptXT65YSXWVGmZnnWnOhGROcrXQqZjBUotNsM7T9gOPt91cwCJUBYReizDVreDvbSCbxnKSrqPpy+hyc6GfJF8gPiItigiFCxkPkd/T39XvapVko0KwlwDCCx4iiCEOrNFq/bf1AIJ++DV6q9wmeGg0lfLUvYVXGXQ7IeSsRGsq1rEtM4Ti21QSaQOuMAEeCurgoJIWeyzUgxLSUFBAr5ogN+c6a5nW2rOiTGdkQZLtzq1gX1MQFITZ9aXUkiro+yieuocJ+zOsDohFX7PsrztMmbs5eBbb0eHZ2YoSBwutSX4uNhrECeC7jOlWkxcLQ8p7IcBhgUtOgYXK4MOn16O80AJU0eyi7PnMbzfWROgWK9XbRhAVODQvJQCCKYTT8AQQHddICtHlCwyKU6TdnYqy/t8DhwYI+7yaJUNyZE4CgQC4ooVotEsvu8Ffx+ENfR56pQWEA2RIyBezGS1G1cCGoZagb9jUNyZ7gqcCNYC5UTiYzQ8nqHvLJU7gUxWCYgwckgyFtq6qh8JaXuKGYL3TULsQalRWqce4Eevzyr8ASmSFIl2V81TF0oQsNH2YsWSQjwHvINx78+OvdmPMylzYVEvGf9u6dy3OH1b9leI29o7N7stJyxYWxF/PNZl4XGpGZPOqRdGWa4HsHWa3b6eA8OrDN2qpcRQ9GckZHt9syxr8xYUqdTA5sHhgoj1FUZsYpd2XS5aA4CTfIY9THSR66etM38JMaDXoSejdJQOQvvERmiSp4HYokXajTrkcQhk5a1KCzi0FLY2PB1IQ/P0ypYjiH2B7GIdotBSC6ygCyGI0ZLOYycZamOQCBAS5jggEWkRCyOMA5yFraAAIFZaY3IT8WSd6x6w74YPPUl/8N1+erJEEm+IK+jIuPBIWgFmzueOqQaiDMpssoPSCKuNPmYoZVZEh5vPctY/wCAQoVS/3yymLyr8cqfidqHBkSEIoA7RSkoe9zNNz1Tk8dq2JLoJxgUZ8UwygWozgLmVdgA1aBgK6gswPSizkYt+SMaa/XsV/2ankWGtV9rkXRoE3uI0I6sLaLsqyiMQxCUbQan0PK+o9BYE7WdLK37fsixqLRV84E5aDnHEeNH/J4nCNlm9QaBiSMsyt/7uKoH4CujsuEESHIfMZQR9GGdEUDSMsCqOXiuEhjOENDrlHcVNr46B0Az0szuubUtrIHlplLcxok5GDGKWtDpKuzPHJoC1WiZ0GukV4jNWviqQFFliIXxBV3dpWWlrF/eHbhKkyH3uR/n9nKSc6UY0/0J39SLFknQoKMeetwefOIkEGNz0utGoFRiqaT4Lg10YVGXrRzuNQvHVMDHU4x+/M5Y1HmOR9HPLWej0Meb04zYB+yu6Fl0NBSKqVlKPWj00lEGo587sfDNT7q00nfR3CCHaREFdG5AM9oOKmInKEe7Wg4Vm2k8ijOIIO11vP0NVU71XLuqVvP3g3lzXst/YR2LOnXTKHqR3z5+mT/ZJhPrXdjhVU/ti0cuEkrjmqb08/sOJev8aATCXqT3kI5lpErrCsEA98jKCbXAZ2L62x3Mu3RuPyvsP3gaohNaL6N4BtEnhG/o33L3iWNMypnZC+gfBqqlKugMH05daYmMYA4ha5JV+NIpfZNZuOvI2aIIzSExDE/NfMTM+vzLyZ8LcEv/1bFsCpWijgOqR+iD9oPPiBnDyPJ/F1IBNafYjEu2O/ZiLYB1waIPORXq0sameB3c+wLCSRwNRw6rkX21T34IVYktIZD3NH6LroXCkLCMxGh/9Ri88GsRchWeBLd74tj5l4tE+YV/dIvO6W9zRhkhUw9TotzQmnSpKTTgDSXpfamz9u+nmiiKM+tdFeYjSufoVH5C6JWlcmay+wqdXfiQv4e/fGMW3/b2dpgKkzdyZ5nRDPUoAllJyt4cO3s6mHQcBwROclSu7T3DjulVbfz8l1aKNloSI9eJjIXizgejGV4EQfME3OxQDN0b7RcdAODahWKV1ltY2VkpUoOVpZwqbYUTy8GciJjs0xIZc28aLbraqs8VDgOA4pm7XEC45w2QWDpICVD/WLH1N7Bic8YG2y47/8a2WeFrZDdQG4B+QIqq3CsZkuppdmwX1ArqOYRW88kNUldRHWVwiBThYVllTGF9sJRsg0WNkfGhKFLjb7qq8JwnPQFsLoWgSjXG6c2/XOQOk+dPzzPpm2sGiJnd30XgeAOYDWiJxhWRJ4n+wfhSpmFChNcA2OfjommFj8sUFwZrVtFPWTuIqaZ8fP8ObogTM0qqyxJ4lxlotJXQTHkO0SACI40BAyImIjxyKkK3Dr9WcMIQu2dQfUmv0/N0bK530BRUVL9HWXlCwUQH4mduLXyc7zW3+LUOEGp4xBX9Lcoh3ToxPZyTkmmnXm9GSReY+bCRY9yyK60aFYPqok0cG7L9zSTRKIXh/Z/Dv6HyXyYwvsYfGdl3saQSk6+lfE38MWTr/AUDDsz9ERiy/40kKhTclDQKDb+kwFTPclVYMIJrG7RyaewyPD0/dS904O3sd9EwxvUkxgf817rdeeU0RMGAH3nCAgpF48e2r/68OaDfeaB3QeKAGnWg6e/kefcg1fgBdj3y3/pnBH44kzIrNczUlv9SpNyjxtf2GdfbDv1tFf64KWuvaXXDt1sp9bEN99DbZna37O1iy0LgtMAvt2v2Ozxehvebr1cb6wzokr4SxxxIfCRz1I7OOQItpQJTqS1JMPhGyrg5ZYcW6lFD4EKPOEx+vCEXg+L0LZudspp7GhNL1nBIqcvOIzphSNMXY8uQg/rfepmIHnQzpg8LU9rVuGl8K39iw8RxU0FKzZlJEZv39twiFfBm+g6dp+T0ZioTDRWCutF7dd0CnekVHunvesYjgm00a6BNBiQ+kUXSeFz+H02TaM6eVxfOPsKJhUrHchIkoIHXZI8goQS7BwXZI87DviihcX+bedWp0c6RyrH8EZ3Bn4c4M9fdPvLG0xs88XISUfnNRm1dKthVz13xJVp0TFdUwudqY4ehmpWN/mlegqhm9R2jvOkfb35B+mh9YfnnUtlZqoa2bj3vwyBBHHZo0VlLI9CBPMIKyx/+KDdHc8uNr+lb6qJFHuvcP9u/DzzA4MVW3++Q6toaWgWTZXvqZxS3Dnz6ZJPE1FkFNNp7VSPm+XeO5cjfQ603ZKYFw30lnQB6MaWa6inQD10ZR0Rkw/NMz+Ix98rctPrji+12b+OfUwTJ7HWp5wXzTicTFyT9wM9j9rcdHlZ7/CmE46jGNIdt8Mwso3NM7zL5ZmOgLeY6/uu3kiLMur8AokccZZpYdfA+yMyUDCPeonU/8/Vvj9/wegrTC503uS2ynuD569SfIXUK8MNan4WrR6oNs1X0e3A1rw6pXfKaKGzuKVmM+O+0+u0RjsBexplje0G0Bvg5i20v7nt9GiMMnh1Ph85vb59dEu6KK7mXZ6P14faFb+/c0QouL5+V7F/+s53rajEdh8qJeO3AoZBMdDchCZ954lzTD7nVmmPA8hnVvvaDS+eAnJlIgkXDo52Ax/CLHNk1+n9sG7XxBuwNCV+xyTjiA3J6vq0lQ7Qt+Ws7QRkRaVL0Th1OE43J82ExqendogOUe2YP7uHcjPaRirEWVfZB1n2M9K4xqtmf7l6AFCC5jmnS37R6Sa/0XTkdfQ8Ui+iw2gTGoQKoY1zeAVb16PpxOZ/SwYqod8rv1j+8OH0g5Kwo5M6zCZPPxTAU+lz/oEhYo/DI3s+FXk/kDTPcBIILJf46e4zdBlZDcGNnkg/0XjaX6lQwcuR3sizkeLk1UQwpk6iSSNWPW6c+E3OBec1p8fJq7dqRDWeDhuY4s0Wx8OiIpEZ0ROxUwivWrISLs0anL3wEh1gR1+5qxvYPJzBtXs80l0tALjXpHIdjLxzMqzn7jsYWHHj2yKdGnsL8bdk2jX+Zvw3E39zpk2p15i4ZXabk+kyWO41rM6RXLUN5/larmrMPqfGadOMpAoNS9r/lq80+cTVpuub685rc//6ttr5hO+cjLyxlj8ZE3Pw3bMtp09dvV6VXppk4+Pjbenu6OqswDfEMeyN49J/Sxm2uguV39XNN53F+Ssftmn4j0jbHU1y7NtfJlX5zc8vhS6Z0IepOD6L6dhHXzqOY0Lvwn9r531l3krpDcZe5+70bFJ3xbMV+5xxwNKCF00nznzw9raN0SfU7H/9Li/iQsft7HD9nmNZ3alltDGsNqIPtacdfyx79xI+2tU4f17717lT79lUKjbgI9gsw+cHMwYiANY0Tlf7GqGRwuErQMwT2Ls43mcI3aVqquTNP7qLQwQtlpJ1wtlWgdbALpmmxBP+V4PoZPIDE8XGrgoetZmyeVHjcSPtJpBSr+BFf7nXt3tqvRMqFsafG94cpPsdJtgODgz8tctZx5rvx4TlofTmiN+l90wYZuxgiOntc7w7j4EYu7Pm/yK1rx/uGNyrduPsVNxB75rOgfI+NEvMTGYG3Xk417joFBokLCRDWZTqR37UiewkZEa6RJVnr1DXLL2yaFkUm3VLFMLP+LNnMzsmE6+eXlCuKgIIJNqSXxSW0iRa4pk37yGdxKwi0ckLaFBm2Vrwv/kwBOlV3Mc3SG5ATcDdzA9udVSqQOTByAgEY6pXwoF2MHGY8YFvGWuzxh9By4brmr04rqnCOQxoBAwtBiY7PNm0bd/7RHo1vZeanfR1qnQKyZL/0wjHE5+ZuJe8M9FGAolvGLM2riuBZJJcXqDhuUlC0XxlKmWC3+lxL+F4D9VcKT0vDRZFsoLkZzIhNdG4CsWMA7GOF6DButXPDyP3GFeHvrgLK8hVL6pwZfLFbREpzJTQdehojFedlcZDZ9CCQJ2dfER1fV7WbQiqE1XJ683jJAkEN+c92A/U42ujYonjuuoM/Ti3PcCJbd4tdHWQJwAfwebixv9oR9JOGNgYBPHQMr42F32r1iRmCt+ANIBnKLIKfR0cYachUpshqTB4N9YPcTKGeXU9An0EobYGVKFjBIHj4n4xrETdWQluteyaQlTz07eCq9YKk5T2lv7MeOpMOpjSicoZ/yKedywrfqyk4MCPxFQ5XUaVYRJOMKSoiIfYLCGJM/CJytLhwsFwYCg2+uWGFS/NjLjOnTpqeXtPiBq2otiGd7LZO2uSJ0+lOiY9fodhoj6td0L4goIiTrtZBHDCVuov+hRhlbW3w/E0kLi9jJbkpUvXLc3ml5Q+9akcZNBXasB9gjrEOIev+gvW7JgcKkugoh8Xw+WWkZErZyPZ23WHwp9pN080zCvG9vTWoj3OZ+rmWQxiCovZe/ULurwvGoF/6dbMLaba29Ub/zHyzFgi4/32X708KTLT1Luml9BFP/jNuEGYYK491rq0W9rjOHAa04ipxGgaeDS4H70rUj4CVgcliiPOC0xVNUFAEIFf4HjUj8ToMcTjodej7LbPaaAor08wyStM6bl7bn2AJYo+dJDys6PISMfFTWyje7hXHo+/zvgYkpk2bZG47d5e1b3R+zuOtCO+PvXW7b23af6/VqO6/k8GKHET8tIv93dwcs/4jm/esRD0Qakh58hUIbfalqvVxXxR8lXlQLxoN8q3vGvqrUd9ZNoiVf3Wyp5DXctXd/jVE+7M599WkivtFqtj9BK6V+S3t9vI1iS2ENhelPFpKMKXjnye5VcuyK7XiPajR/jGkcW7cTfOzHEADTZE4HUI5CxsgZ/wnqq29Bd+Z/ngpzRm8Wussx26+Oe/vRhdTy2nlAaHKichU2UeUlVjjqyuQc6GnAl5FUY+3/IhBaWPChy70QPhHuB55ETSrjSTGg7J6ZjiMSu+0QM8z7jwMzFYQWSQFfrjrR6Wwx9/60EIr1bjGoEvTjZzOGl0rPRZ6AlkNej5PH6qKvMetszm8/xyF2+aBds7n2ZasotDSj/zsfN/uW+av7Qh1cw3zXiMaVqW5fy4YR2f+c7Mm2G2i3c77Zm70ed53bENQ6MipbRNoIBb0TbFvJrNCjxdH331oQ27rjHE1SD9qyc+fKLqWfWJU6h/GNs17anWqxlaAeXHqE8kSfglD5HnIR4gzV0d7THoBMfKyJ8JvKFJvvLS9gARIJDlP1YOTJxkblHXgpntvdD9jyrMigvFif8Tmsxh93VJcXzkNCv8x3Ojd9TMqdcRY8rpaDSvHGuhkHUr3vXLl8aG51XZdQ2jh0ws03wwzXPqBBOZcdyHjT6fDsMoKJ+b8c5huSI+zxtp3/CNKchlx59IBWbJZLQHWCa7bOU71ZJuw+1OTz7iVhF+SlYpvmex4XqN9KRsFYy5CZmFTC21R3Ol3ADGnvtpxccaWb/iw6ByOSS+Xw5BHR42XllXpvk1d2O17XPPvRCrvwk3G5juRnEmwLosRj1RbThvkBqfTpvgGRnAYc3YJ5qmE8VkC1WUwBzSI5hIRMKr8+On80W1EXFVzSKWKAVOGW1WGf5fPwzFAs30tRMW432GUic9iV97EZoPYeCrIZAa/HP/n2/rT3t71fPNPtvroKfSh0Nprb937cKFtWHpX1q7iFFQ3qIBi9j4w0c/ZLzxRRC4X9//t9xLWEy43/vqyI7ft37sRDG3e626XjZ1tJtrIuH+tx/6rxWKMN2neoirU976299764cC73KBg6/SL7x7eNH/QKz4/d4zNmo8wgyOqBHpcfGEseBOFpyi+kqVfu52VJEZPO1ZJJyDngVTpjRzbBg993hc3ynXTDqjEbUt6LfGQeAYIbpRLz5KtrBujrDU0sHII4x77a6aLRGZdeAb5BoRKXZprzb2JGqUu6N5l7xS/8K/0OCkcKJZQzWG3Bv62MeCNs6nlc74rj1TPnm9cq3i5rr+o8HAGBUXDmxb+cANVY9lTcU9VZwh0Cwds21f4km+ljamN4/XMOcn1TEpOlB0TDHtTIW0mT48uMCRbDiufUfYHEKmbmHL4ilBc4hJAG5rOUb3sp2TOc5t89GB857B6eaSJWdIi1RLl1fjeTmEPAvCfNfbF+hiXIfZqn6uJ67AOh9xvb8BdpUUMhEKMsY1OKJsjrbt0r1ZSz44uezdUkR+4HB9HfXPabqzoVP2HsxhQbbvPv3mnq3a/nWRFjUglMxIg/DNJu9Ak26/HjvS2Md+CLbxxXhvrvWiOODTeq+jsC3exd6ZqV3Y1yrE8fKvu5lhWbusT5ZTUTu0jZJMlVrsyWUCRxbBd7DAjhmpc+H+derN/08BV9HOZOPZwQhHxlrLb/SJUJoDpwWZEYzSlVTn8VqsExP0azLEJNugawNRj4BuEL4dy/rb7gfcy65XuZHArn8oXXb1ZZe6G3W12QEsNR1TSRBuB7Wl186RxlOmi2LiuidupSOhW6ITRQwKmtg8VL/prNbwe3isckx8s6bQnkTqpmavi49V6WrZSpeSvuM72pzzOa3xIM5t5PmVEOU3t3gUvf6HU0303N61LJwEYnhRGUgSiGBa1C40RtAEUxitpFUbmc+er6sP1iv4jHrriT5Q62ldUf87p4ORbsugoFdAh4yR4JEi6bkUkqZtLnhSNTtS7QSIZH3bfgT+R+aj26dZseG4QqTN5jBvleQxaj7BqOIEFG0aGI+aSvTf6djzFTufTYKT0ugWg1dBNDBtzuXCeOFgSZfaTD+H3kTa6e6iPmS8XcCJF8plRT4oAAoQsIw6b7jLtMYRWgxaVlfD0C+Bs2HEtsJQxaR4CVbIRThVVKhV41Lsmnm/Q9OjkPw+DHp/v8j9Afaw6B+k+cbv2k5OMRxVPPG313z/37FlAvBv2f/cEwPBv8P/FWEJQKDgH9XvkUiDASEe9YToMEla6tAOsxPkAjS1I8u0L7Cg+irfgP59Ez/JNF2eekP1xi3P1W9vAvzzxWg7xlZRLcvghSGTHiJDo/giz7K06PJCetoXzNUoi9O31t9Yy5cmqcAkIenEEO9itL1bR1Pceh6sBqzhsC/jakAlewaco//WSXX07XPp+XyyfOoB+sOLnxjpv+AJpJJIiWCK4cd731KYGXs5z+ZMQIDvK2zGhjzpmSlLluUvJknCm37m42WMwnD8VveNTms+lThO8GEfVshsjKO3meRIcuKKJYRVBR0Nq726x/MMp24aRDbYiNxPk1jRoxuEvOefGIH/+YasOD20nGXALODWdMqTAjNN7Z87+zLBrxHOMh2a55ei+ctwPA7cSeSlvTze9DE/rOBrbzJt321/8eZ00FJpw4FW/TZn2iEyrvAoa56Zv8m0cTuU0gAHj6FveZqviGqhfydrvObjO4kEQ04qKYiE5K6hL4uYr8KU2ZN5QeKRusegVe6Bizte31G967/S4LZwK8NATP/KDIpCoUXOL2b2Yz9WTIPLvnBnkJWuaDarPZqv1Nf0sejsnmf3Q9eKXF++e1ymIbNymZpZr4pyvnVSmgrJ9FCPnZX5el7utEDYjZ/Q9pH7WDWexaXTCfIMfUJFbgLo3mKQvgVjhnDwo9zmk0qDFgymtVpepQ1PA5gk4TqSSJH8giYvRafBq8d7g6FpGqptaZamcVFiuvG1OVP5rvzFfDqQNCU+RwdvFbSmr6Ay5kSogZmn9HCv0lLJkL7Zd7mP+V7dR1/4x7v5TiIwiP3tBY5bmu1goNWv919tvt/Yipb3OY6Uxt9KftFNSJNa1xoAmNB1nUH8hxCIK11I2zObJZFwfwOGR7W+IydOliX4A1WZyPw/IiE4D8fMjB6c/lsMpGDGfHbzdXmc/ikUsY9h9zsftrF9Hm8+0PdCnP+q8yhdz8VUlcSTZXo9ltxNujqs4Nf1fqEPkn0ghDuAfVDNcGKd9mUc+8GDZZlcLTfoGuUhOZjb/0circIEn9c/wReMIhXNG4s0TMcQ/LOZmyZvzJpk9FM/7aR2ZRK0LF1dAZmFrPryVUvrqhUqf1Nj2TuyIfPax9Xl5YeDp4+wCG+smE6T5OsjdLdFUdQipQk1jJOlm92n8Kz6L/6CwvZiWhTzC/ryUFdaTVA4Tc8zArYdRJGrB+lA9QXb1GiPSTLh8KKHT6AErooB10IXM1+rpbMnsFufBo8RBpgXWBXUHThEB9rf4snNnCSqaDzMSLRvP5K5Rc9oW6lJGHkY7jZ1wGAztTnMbP4eXYzDZBl4V2WFKPAZZ5fpdXZy9eQL494W08D3Sq8seVRkiqLbPKvonxZ4HQXc62mKbVMHnVpkWS4w8njcoTYOzC7MRImCv/1DLdZKX4QYxfzM8BYmJn0TuL9Kk6Fl8bzObOennGK5VlrYls7XtVxYX202nOaYJCmKVH2Vjx7PzHuMxnWyYqzDyw6H1+KSwyrQVF6i9NdbLlpWx+OhouNYT6llK/vNDvET1ooliqYdXVysSFhgGdp3VJmvSl/UJfTR6LPjvxp9tirbnUd90b8V+9MfhEqvub0fOol9ZHJkdo7t8zz3QM/x5xANeFUbMQKQnksyu2JFeQrTZ+kp3zLs/kVxdbVf16iCeMAJBY1puB2FCDmdVx8gl4meAVQSkRVpnCPo2xYcJWlQAFtY+SDRF1fc2yKMCmE37q0nVssSnmiCU9EGIhVeQRDOJnIZw7BePr9jyiZYVBTeNdk4D59AqE9m8bxKPIh6+TIVhVQaz/g8wfiVbaYhnZcNgGEOow8E2v7bCfQp+KaQXkB0okt2livpeIKR56BsQd09yTXe4TYTBabmEUyKiEcdg1ATytvZaG0n+fYxAnICgbCXCgCHnedTbJmf4bL9wRnbaV4UfD3G0jTLUm88JnCT2a9lKK99/QWISbLMLNvOPT0Tt4s5esmrkHqQJBmUL86qjRy4L0AdwBSyco9ErkXjdu2s9gsaMu6QDYA7wXafgIQwtjsvptkqr/KqnVnSjevz/J2Z9bLkJMMolR3blv/pwDopWYkqdhkV5xHqiA1Reo7+W0lSip0gZaxmt4ZE4cyKWjDX+oo7QUJKjfPm57eLv9quYq7ttlPoQNMMsaxzF4S8ai0WnOWZLKu+66qqTLZiCMe8gXMr9/2cbhZLZAkWldRzroATAIokhH3uRzkCD1v6vjGS23zfNtIs13N1vVpqS/nNxo0874dz1nV/POZlk1HPxgP600a/3yGsc/W4OAXJ7X3giff6sZfTORTpfEZ8TyzTYlmyVMbuKjrTRDZuUaEJSjix8PpYgLITfQiNtd7L4njjAV8+FKRTV6o7hwEW5VPqEehtLaSx5TglulKdxwW56YzljdxwOhQkSyaRqJDQ8dELor6gN7u6St+tgr1GUWtvlUAS5gd9iy9w4jMNvyivNrDtdq1vgS5AYS3J8nqt74J2uiy5KDNdH7qOM2ypoDr6Xhe822mKQ33ougHo9GPygDzFzKlIEsWosi4XKKIDDZFuH5dosKw/xpMnUFS0lEVGl1kVQNXJql4uD1R8abOynM3KKEl4UmWmafueZ9tfb76ayF/e8Ac7+mLhcle17Ca9y8WjG3ZEV6uf9+Bd5Z5Enu37uzncEgvVCqkO8F2TrKbJqUitNZkqnGYCIwnBRJUI81r1GUj0dfyyNglwQy2EjY3+znd1dK7s7B3t5/uCGZ9kK7X3vGfliiRKBDIBiafP671Qk41GXhSGnjfCeUCr/s6jq+sUvRr3cdf1dfe+2/0AiVPe87SqtL59s8Qdt+d56EVRktN3Pj/WhOryjp2vIJaIngklcXMLEj4kpGt9XlXlVNKS9jnVYhyfhAPw9DcCfQi+DykO+8oyNIvMkcS5lMDHHhL3zYe8pZV5I960RsbOZEbpf0YI826nhq5lWo/LXPSTI1jad352w/8bW7AR6zDKThXEhafLzQRRqRWwGrR9nMo2vr+hJelrKNc0qvyDyZHndIYjBtvAOMgieThyDLUJp3qFWnWDV+ivtpbAPlMcSLzqwSfudSGUfH5HucacY6UigF/Tr1I3n8mzTfM5FsGC6TZZh42+VRNltCsNdNPkLMdkWdFUVflK9M1IbkcGJ/EUFJ4SUJ3FCqW2tjobpWkgWvd9GRM6GzXpB1wjbAvbJGUyqp1zD8uzIU3PzLhgmm4RhCGvepnbTQqeDT48VuhbzgNfTIUx+l7EFIKqrGJL+Ik7iPaIVGtYPWj3GEl5zB9dJnw1PNbUspjqaS+d1/3MC/v851v2bzqLOpTTxgqlUrlMjOEOjUkvLHo9xc4VmMnqtfCITqKolCrnRh4mjzfnpla1jK9E2SanZt5U2HXf4553TcRNaOvaaprn8UzVdd4PszCOnRC0PJ5OE1a5Z4v+ekXEf8mPDm0qTZrW9B4+miMkUDBOS4GDCwEla9GOvQAOOIcubpdhaGYrUVD7nB6Oe2s93vTLrC+on0kZpKj99GwGdnbrP6HTXcxR+npFHMSFdIZdWTdNRbNyIEEdsppVqCeoNnBecJPS5IJRJBBeh3Ex4t+wVKwaZP7ry3He93Dzjbt3xWMlB7gO62rJUpl+mb7eI9qHt9W5cLvHcSZJuijtS0kNfqA/0oULYeWB7YsyHidJLh88t6g9bOBRPb6GNzs9WExPSPPq0CwnxyWnTcHvqJlW8quekZnu7PD6w2TecdrlO5XjkKYRIxsDQODA8W3cjuC4u16PVs9XFcsLUcivF9++GFwot1jw0ylWVRcvLgYvxs9su+pdcZmr9rurc5W2XEeUF1UVFQigBXyQAEwGGfQ+ax+30Au89HSUlYXoXySPHSbxMXfPvYctywJ3UNAhtjPwICPmUA/PNdCKvbJqOyxmpjNLzKmTd6Qhe31RJOx/Hk2DLEkiPQE6AYkoYgtrONQ8PxifRdwzaIYFxjTNYeCaFsXQshJXg6A4xDzHV7BEuS9wdlCJxhguti2ZA6dzCEg81ZWXoFhF2eXc43EJpRc6v7V5YzsBkPCqTUWgywYGwxHGwHya4DlFGLfyrElbaw0GM9UCE85MiCi8r95QH6pfqwEUpfwmQ49hSEdTCcla23OxD6k2CQylHEN23Y8puZTsgJWS29ioOwDQDd+7KycDt6iMFyJcGaz8gD50oB0apsnTKrNDP5sTHNKsKDCfK1NU6GWXbWbb7DLqWq/bObcNGImsRQBzdkNWcTMQU3OoJEvIFHMkOBK3war3GLBjqDEajzBlG6HhLS216kIdg6WtLWOd/MqkRMahi7tLvf9QP2izXNTrcnqS/E6OEUN5kFIEexslbQHg395VlIFkVpWqweXxYbJY/23E/lFh85YFV+rsjJ8CGywn14ZoyKpTgAz2GF1WCEKXJNpJTqSg9wyFOEnSbcycU+KIKTQVdZUBcYX2KVVxGM2z1NDB5vfneW+9wVL7g1Bz8jMSuhBSDmoZOASvtrzDE2zRFANVyJOVvHMcYJNsyIFiYDTicYlpAMzRxNBE1kRxSJmBh1yBi7d42KONPIxTZ6hL7e7cPop4c62Ozz40o29g4/msfrCm8kA5O8wWiBHP740b2g38is+ftZcd8pMfnwF1S58Jtw6bEzs+jTPq+YmcHqNOsZ4cGmWTWVCUHjvDJyQ5tHzozbb3U/D45jROvZGq6cpmhfNkAUS8yMM0eHUfYB2x6NHZi4dqCl9tKYEqMd4I7EZ64AGvJ6JcVxSNJXouM8aroFlLa3kpZEyW1VTVllpDKdAMkAYoUBinoez7CUMy3nwjx7Q/5yEKMtxyYQczPqISSuNJHB8Y0LZi2Iz48KvpG0SNRCnxLFAP6Ba44u9wbVvvLvOCUuTgDxQU0v9HAABOhzH+iYMDQKSs3+BnzO+MGIbFreiye9zi0RScrWHENPB/oI++fdjt04N1Vx5+pUWPoajv1opr+NWsKc9eZdGrm4vGdmzn5xMZApYQvBldXB3MfEVELymfZ/wM+x0TjmNOcl1slzSeAbyn/RQimY2HbMcnEwA9AAkBBN2ieCNr/dBflnNUv4LU8AKKJCjDRJ0SVUr5DLRUGGUcvkXcczfAek15apDKoTzsP9w662rFlAC/wmy2zXRWj/1VpITQtFPh73YrzMMgDi5Jg5l1EFgyE825WesMaIf9q2O1ayJWgDnyoy2LhjUfuH3Q1YtaqguO1IJSjy0x5c0qk7XmbM0na4KsbE1BuNpO+42UbFWKoRNAZWWyVu8GTQuaDYSzi3uJxhSiFw463DehVt+8lqE+rW1Dhni3jNBPE/FDjERGHoZ8gnUIC//S1rs+9b4IdYdmZSw0yYscpSg5NBDZMSyAwS3vkpZxJosiDmd/Jty/N87hmxz0Ux0f3PLyph86MTU2rDg/rrV6dWRA4EXrZEt/Q7mllrhSjGVHSnMyDupxwDUl4hWrvRz3TR4QD47hPGq48gGai/lpyypugeqmcDgVRYcAHESCPQGOHXMYzY2nV4wV787XhMVzmPdsp9dS6emdtan4WjwjhpZmj0HUH2m4NzOyWj2hA6wY5wgeU8gghBA1H20ZFBJXnOmHDtBdrWtOwXpmjF1WYCnmXYGKgBBUwggzCtxqpgzZsfq85KB6DKJOpFVGGxBbPtN0xDBRmRtAOINZUKJivIXipVOvF1NJPJdnI2t1mJl2vk+pkVkSeIP3YB6A60YHacvSKAf7s5iTAKk8NdhJs+pjLe2k52r48qKPXxyrOILxmsIASsNsJkJJslnGrxl5Y0o0WzHv3+Z/PZoeeGTd27rmfG3O4UbkPDlvH8OW+XPcKMJrocdt89/ftoY8ZJFSWZWHSq6WPOYZstGGFuYoFsp7o8atwb9u/vvBJGSRlsilyTzhv9fh/hfB/a75gXnfGMNQckQkiVPY6vPUQ6dXNcTxSHLvelZ4uc/4qsyed2jhPXNgeqzC6cWigOvByvMfScGBa6rhMEy7OM4wnugDY3gRU4skw2KIioTVJh1dETwxqsydXzMIZq/HmQjAtbupr6mXTID98A9DiqRo0hABlw0JSLA4hhsm5vJwgmEpGicoAjd02OVSOE0zX+D8If+A/4EbwRAMxhsAkY8NVQ5J0AwOWYs6KrVsksrtaQgJnaef4anyvxcwJiEACpKIFQeNB1SOTEesc6NczvHM1F3HLhwzc8vNzLhlmIYle3ExTuHyz+mcW9H6qQuvL89vlNrepp6D872zx3u7NTsxxt/u8mPvYbzH8Xvc9bLSj/goz1feeJANmBdDpGYG+4HZ6ct5UR/ytizra9krp6OLxdFIU+72eoMGbP18kBqc7nPCA94WyxmdOM3AZ4xYE9sCvTYkvaKH/iqlSSlRpMaTQsL4yoOm5cCISQEl2E13wygfs5djlQn5+w32WD1ZDaQj08bT/HjwemAJXuCoT8Z3m0vsWbbGXJwGPI/0RW4QIwQh8FXT7aZoZMOmcKGVIn8tIUnAW85cY9uQqfKYxaLvGmTOgCn6My5khqq/PujcoYmMQOvyovyltL/g/BqnzPmBA8WMRw+IouwZv6WgaIy3RIZboPQzuKL0RDStf97DSYllS8qoeZSmec/h7fyWGreUT+emMndMtvz6zPXMcH420ZdaBonjxCCi2SvoJ1LIYLx84sHj07kNFcwHZ7Y31x1LzNhZfZb2JUmkxwdM0xjnQlbV7K7IfMuKjoiCqLmuc68MmpfxSsYkv/qbZ65gnwYiGukXRFkwhFuCHdK2yWRXEzxYAj+w55oVrjdDPlL5oim/GblsGR1y7nxjLpgoTMIeoUIAkXpSsxr7SyzEfnf86I6vIweHaeAVTRRKv5KGJMvZuK5tI5ZHpaEyxdRYQouJlfgEAda0RdZebrx/rFwxejUAifRk7i36Hq2x6RjZmrExTS1G/nubfAiowgghq3UBP6GOqMxl5M3nhp3CPp0ojbxtycd9Uh9MU3QzJH/cO6DF+q3qlUrb1fOVIpMSnwCAVWn/RB8Ztq88Y5OJxCnlAkwyOdbwo2bKlB4IRjWxdsb2gtGlgiNjfjXvwDEzpkCTkBSgWxpLtOrhwImJY7eqjEwpgIS6BCtEpTDhBk4+K2kV7di386ocFRv79A0u6bN5ZeVEpXuy+yG1+GSjo7uFbV1ec3kiiw2zDefrF3lhf+I7Ny+v9IWbuzb1wQ14HOKigOkJyY6EhAQp8FiGCOq4lecrXJ0TRkhuYrVJ7qPWjUtCQYGDX0TPors6veODkGFeqzvu4vkP9X+JftVQNtD7GRniciVPLmuGoz9AElAA9GsBgRONx9TTSrKKTOO3EMhb0YOopU1WtnCmXlqifg8g74pT/Li7G5K0HjsxZtoFTuJq1I6zK+XDrFAKwxQF5sAwjRM17Re+RthNJ7ivMnuBrgpDGS4InWDkWN1f9NrxQdoHqg943IoRy6WBxOBKZ93BkiSfO64DCs58/FFLNJ5ff0DP7xifOp32NGYnL+HhkdmmW2g2U58ZdnRb9jNbAZgqKMmXmrukfJPSplO+/Hlfx40hfeIww6ryiMahzx3Gfsww0c+vCGxsnNh3QtZdVpGZtU61K5ExwY+QK+KCp7+x72ac3i/Ysp5dwz0aMM/05ooFZrRL5eVxjvIGMvqV5wC5Ah+5vFiHN1W5a+ineos+7ZPIjna1Nuzve27EzRojnXbuG8KBu9c97qxj56x6klfiOaEXAiCZgvHYTvFBH6mFWdo/WDXOoNk6aMrywMWLYO0nDxyfU5o5TrY7gaICB6YJhsmzl0H1gAktB9csBuoZpWvJknKPv0uV4gDhROfNBULGcD2kDIZAdJEBAQhWwNipfLpPHzx4XPk3H1b/6hh5eiExBL0APYGjsqB1FBaCDuW81CGbZ1La0AdJdiPtlxBE/6sQhJpBG0tWdv/Avm//iWHZ2GY5IxR5WPKNG3NM+6RmGWeHPVSEPY8Df5JsVUcU3dky5k/L8JxC467qQtWt3H/Y2F/efK3Q5YbskIGO2z/P9peNXcZketd7sz1bjGgL7OLeUILnjhrYv2z96+5bTg3DPxv4jMbqATOEu5PA6H1csJi9KO4xPRPbR+7giHJyt+AMZfj9/J773E1lx006mDeCLG307Q3EEDuF6We8Qia1wVAwUgqriLN8f9wwFuAvGss4e5HxZ9kScqKMkf+pF867fPQvLQ17ve1Y+xvJnvycXJH2Z5wWv4l3uf0Zso834xoa/QY6mRxKuDspwog1XjcLGFWONGZXo4jbF2EnNnz3phKb8PpI90j9SGEC9ppFSymsBK0F2wFKCO4AnXv2KE2CBxcphpOBElXUsG3VZXWlZtZtSts9Ls3dZh7hRBo9UWNGvK6kapoHtXHveNaInljKzm+9gwws9kzNBoZBXLfIBP+TdC3i3fIwBvmsqB+In0qn6dUdWAyrc8vF18hlNrhBrk2eWuAjxmGAPbwPdpLpSvB3u20XYTzZX1i59J0sZM2tLqimnSz+/lv8FF3NhzoWJmix38BFV+6cBPndQrHvoOTsUqhcLP9MhuW4mW+beetzYrsCAcmrbKdTbfgcGZIuDygOFIRUjBrHFB7j2H32xsmXtkrvT72fOX6+1WoOeveYr+U29lDGFcbiXzlEPNa1HCLXazYLf+Dvx/eiiX+wsaGs5Sz/9vNnTjLHbD9PVBjaveJfzBXoxBx6eOkzJhjEfBc3dil9S/kq/hRtjgCII4AIRHcAjjR7yNeLFQPoVGzvjUdzJ2uuuF74i9m+natjPb3/48wGoOP+6v5FveeIiZxAn1Nz7smXOWuDBqPD5tiTzEAMwMG2LgrrIG3kAxVNFjzN9nk3bj3HSBU4uFSwJAsG7FzZ1I5jkOVu4Cd/eD137rjgeeF0nd9wvt7+1la/Lv7IkJ8R/0eQf0ShVF0eINZOywPvWdcAZl53tq86W7CiDlTggHg8IMXjdbr4+cd//XiyMtlOuZ/b/PWDyd/d4BObryX08PzViP6hxw87/Hn9niYEsoN+THlkbGmwz2jV0sH5Zhw8H3eqZH0Ym0qcEWORrvDAnZO18B5TZtmlUN+ewiksX4xYZ1ewBe5idN697hptFMfLwTKPybfpvOuvqiDfqQKTcUl5MAumk9nrYtgsy7FzdTa07Gvs7Eq2wcsY/Zx4VxDhx63dbRn8tgiQSQdWyrqAB6WOHHR7ykBpWQIKFKVgjxfUt+Yy+74Xe+7zD//64ZgabScHrP763uQTq6/V9Otv/GpAPyzx59l7jPjkoB0gYCu1UAjNaH9bofBd2WjOVJ32UB/T8rwkIyAS/AUx2xNKaCYPUHTMEVAdwpX0ROyifkZllsGrzTea3xsMUPxAUlhda/jXOXpAjkxu+0pL7TbZJ7PqVEfXJNmVBUTVYx1xTWfnnL6JDFctndYN/NbaTUh0wzxiEkmS6KWWNSSzl31dp4WZUjsT2Mtk8UnIPYDv8tQ8LWtcEsc+wTua9i5v2baElW+KXseDpuDDaV/3NAkH28p+kTqO4prQ3CO7Qcj0u7G9YxjGniwXIJnTghYOa4SCNCe6yAjNPLBQ7qM8yFv6JOeD1CPEL5lYzG5/cBFQUmmEfRnZ6k7CuzwioRXm7Qeca4/tjZ8HIAlTc0Vga2VVkdkIWJ4uKc1MZuLcm+bK+h5aN9eWzpMpMSRj61vEGBaohT1EIV4BgqU+JF05d4JvL4/5E/0mq07EUfOhxX2DWgN1qrRilZd3gCaR3kEvIeW7gFvtRf40+KmbTAK+GFAJwgOVwxCTzKgkkbrJYaPENmP/c9uKUs9xKy4isl8d2wLHLa3sA4HnvXUVBpQrQOz3MIGTRaGMqf/Vpt0ClkoH3fHGIzvGGdsG8LZqqm6F3ex2OHQZKIfzVfwMyFxDpE0zJdKIRTXgIUMYAPRGOUnguZfdl6F839j3/kegp91oRcYA6z/sY5Mxyh05G5aUkcXL6GmkE5OOiZmALE8tia8sU3ERo3xe4FUV5fQMj0LSczj2gPgC3CN6BaJE5Ggo+onHNNW23Q6orqISsocDsduPKakjx4cE7MKbGBCNBR5ElV6SK+bK6JbEJx1iok5sWOgWNTFldAwmMBX8lKcNF41jtu+3RcotIaDbCD/QM/mydbw/T/1O9em3Q5ems6Sa+qtz6lHTHG1Ss03qORBo0U4ejWWVxzOHiBYEIoxLKlNarG0FQbhEgkQaJXZiZ/vQFN72ncWhysRiapcSUd8kGCkH/aJb90kjcVriMqk4D429F6P3e6tSLecoG7OTU3EmjHIipGzD9nYDuwu/1+T2KcKFPq36J+Q80wlmkGBp05QOh7TdLdGBilNAmuQSjslD8z+MmhL73akGG6pNxNdSY6axUJmqfIo5wGnsYROdptk2/+Rx0fOiR3OTZC7zqsUBcQ1My4TkaPhzyaGl5KFyTlNtiAuoE2sH/3n/nSwS3tZVXyT45YlpP1Qys55FwflWbYeKzaH1CijE4jjBicRg0DCHviDrm7yvIScxDkN0gLR8IDA0vlmPzACdxVVsKcGjbxeMEOgrp/FLV1PZ0UDNMuxhuIt1niRg51dTqmlkKFXpuSl5eTgAht27VH1lcjz+Xe3VO5JkyYCY55WwJO+5vKJ/5V+pe8H+RG3iMOZTPu57RYdjR4zCocn5E/8lUFlp2Bnw08kDR8h5VUXPd54ZUvkwuXGwLm8QVWvEAAMeHEbUdDXHspHljTink8qtaGlAF7gIpqxUHTgXUNrXk093OAntAkJSiPzw7qquHNm4onRDPp0VOLvxLyAdleu/SP6wiJCAajX5dyJNNrXwZFToBG/4fK2UAqMdoxLa7ap6G7y8HAAsl89pZdQyM4ersYB7Yrc+s0UFPV89QDDwJHOCug0a3MCYVrWh6414WBcWdS7g8KMTacFUKxuC5ZQPlDbT6b1uw5RuSl6Cb/ksLWYW5yafqJRUYgrhx42jfefMiW7UxbCYwL6PVhjHfCp9LA/QhgIJDw+BbJjQFAIVhqQCIpLMdTb6O2RZVCM2YYHdThVc3pSgThyiY8VPyh5HHdu15ZDaZ1VDm5xifibKXHG6Adjxi/7Y7rIhdWi76QlPgHpIEkSl1OS2EcWpN2dLcUzCkRruxj8BpST5P6HPR7Y809fV7ac8Y4/0RxZZC+04aCq4OEN4GUHmV+8dzHOLYhMkmqDQqGkpzYTqfSmtQXmqcZmu2XTPJ8tnPuOUz2I/PSb6mb0knJ1Fw8rGQEH1QKyOthNnpZ1ploK1HEmt4Dd4KSDXd8QfENkqOjMpiv2mltW0p8U1lTVijVwDxVAUIwkKyWS/+HesYTercRJo3MTAzeu3IoyUmSEO2TroUvMNuYxgYJXjNK+rQ4PHD2PerxGjmuaJmNYyzT4kjt4SAwzLzAyYpPnKwgHF83uHB8xIvUiA2zC0cCO56dmZu1iz4iZlSRhpysxrIa+q8G4ITJpgyXjcMs3G+Bc6PZBAOv+aqTXpnHSMG8kRz8JIKYZEF/ZK5Ec1Me5RO24xAWCknjOu1xAMg6k/9u0U7G2731hhFIdU7GosLqOcawx0kakiz5pp3ZYXt4+rjeEvpPq2jSQAtYWitNrQFM5qJ3btt+3MUUQv+ikVOHfTETMzCJaR3QPhNJKcSHXloqna9TareZtxgy89Cuvs72FcFkIBCj3fh3veD/gD02qDc1IOGzGH5+Gw6Ma47KMoIyVDdAB+vqDLUDRyWDjEq/ls3Mml6Bs79M9yOodDimvm3AiWNlObEIbc8kC/NwaCnolHuGngNl+aubWuWCyE22Kr4vm8U28dE++tNkgKd/oW4Y23ojjBIHZyAWLRIOWEWtBEdC2WFXtX1gvfueKOeIVMWSAWks66wEWd17vB5HUHQI96XdLtmvXAEq9XFKjZW2sEoyucFgjBgBr8xTutP3tlAblScdDcplTbyIf09REMar6mabEjniRMY7Gavhqpk9Mr+CIcCPFFkqa3tbxkyzMGrPmnGxBMfMYlOgN3h4c3T5rVkfcKC3wxUEdBr7vDFyOgKqBdvRObkJDueyCbRdmUuJ7RFimSVwrWo2anc6OlDU3NHk8zedEIQ54VDfsGMS4s7ki/x7uq13fapXzs+XwnXqDAlYaRSl84nkRvy0RmdJELkDNAunRFuGl1fMHFsQn9QYzNYIebdH2nDWH1y0cWWglqNPHipT7PTQ5XvYgWVPFFslV/m2f1ZbR1jeUONytQgZmizNhKsWXoik77B45NWPDX8FgTN8+40aSXmKXGw5Hb55Fd+2sToRN3y4sgEOe8fBmNEEbC/sgLJpL/C+AmYJvHszp7UcrKKWUvm9ZJhQw1NONnSPafw6epzHS/ECHC3Bzf9YKikf9cPz7eKDqCRjkScoo0e0+voALOcPntjzFMJ1ne3jUY3dCZ2uaBU8qSuUNvbCF4C4E/MjtXtxcualQKwdeuqnOCiJhm+zaQTMnTCiF5RF7GmkuJHAFVdVh/d1IuHU/LdT2BwSDu3g4rTrZ2hxTg/GYxcrgo1P7l0dMKxc3rp6h5lgkpXsZaa3UUpAZ/VIPX/dJxgV3DC/bdaYIWU818zRNV491GW0ZDni0mgz060AOiDu6GdNGbIOMlSnMRww/Ob/eEK7fHdvZquNzjWUBIAWzUkYnzeyGeiVrzo910xoSzFKapcdSGRum6X+/GEJ6VD7P+gShG0bR9Oq29utWzh/VSS2HaiB/V6UsBEd38A2QudwkMzyLBnm1fxIV+rzPNMmj5x/9DJCvNyd0XrRGXKZgDX3Rx7/HKM5KuCigAwh7SA8ldKye63u0pY0iIYQPBCT0GmJYoz4MA50wk5/DIg3OJP8o5R36kRQjI5chHF07BFdRj6M0EZ2/SM02VlImizNAB33y4BADU6qiM6gS3kED3cY+T8bITCVy8dIQRGDDq8B19IPDwq/jDhtsmQw/v/ds/uSzG3cgeqiyWXL0BQMAO4jkPInAIOgWxdXZm6eCqwXqeO5xwRXVDq2J4IzZGftxdwLlju3hVQ8jTpN167tZ0StJ1k8LjdqJJ44TrXEh27ciK3uMUJ29Q0nsEHnORs63Ja0uJU24hSA38y1x4E3TTTHXijFE7ubWiNMNoGzBLbzpDDT/fIAdC2AQGgEPEBMBWmqfgkKNbq0b6j/jSpmQLPltY/GTMrNBrwhdWkucQvg3BaISGT39k47mIywqXGa5KrEdl8a+vwXMxnhvCqxtMwCU39iiPEP2aZgodjcTpUZ7CG0KCHk14Wn5B1xZ39S2BtP/p7mawxK0hjbpxDHoZJmv5lFnm1A4vabsrFhrym8Vs4LQlvviSVMOyIxDnfts5E8vtb/f3GR6HTZ8eUVuUBezBYqnlQweXO1xlOMkeYgTPYiIfH212+AUIMdhPwY0UFm7bEZcvVJtoeG+fHnof1aedPpGorcIQ1a97g4FTb42kT/o1PkuvdLSMyLEkcxtznCY3ZnHPJh6H/qbYcN+8O9Wg4R7vg/PXVQkjnjvao/+RiT9N0e2eZxP117OdGHn3+43zoNA8yRT1/yWU02HPJ8HUDXPxOfi5f9+k0H+9FOVfvfh+vXfDvj1Pbr4deskYxaJOaeBxOTA1tWGKCaprlesAauxQgodlrWy+V+DsL9KpaTSbtsMFan8+H4Z3Ax8G3c9RuJj1eG//2twiihRFWWKbm6KcFZScBuLHXSwads62m+ISdUFRKEmP7yd+fB1chUMw0kgGzFKu4aDf6Z+0BkU8OALtev9vTGpIYgHKNEZSsoidm8ojIBMijzzNuPjWbbmLNjnDTTNFO9rvuR6tHZ0fuXHMZjOsJCr7aEGQMcqBKvdDnCTz5aPLg94sxtUrYR754EgpaSZQeMbWFwUr4wgNMGZLHcfG2wBGsQ3FOBYACwcJFDPmQmA8SGsLWc4W5n2F9U4rhtCEWsuciCSiN/AjsUksulhHGXxHsD+0Wk2upfy015ngJgBTXtHeeq4qs5gVeAGPLD7v6/bxDEa5FVWnK3LHiB2gliUlnpbOLCumfmvRNWbebt1mjoeE038gruAkpQB0N5xHt72urOtHdUsXJ68noZj/P3NanG0fQCGYYqBIBzFGea32axff4MKirqKQkZDoiE72+WwTgVs/c3j9BXr60H1rbGmIveetVWO3VjlTInYabvUy/6nLiIHUgrETmaCA5KVwoRJthCwr/ovJEArwkBiTgJdMMbsgLcin5HIH1ACwn6fwzjvQQY2Zo/aG/EzwDa3FaR6yR6R9af+wtsbtsB3YzRS3bLmjekV5B4fuXfezroM6nJM/PZI+rrcyKhRrpkOF0gR4WhvK9iReJQjOMSWAcQMTt4EOiVGQR/DTVKzwQ+ypd148sGn1MGWHzdk1LU5nDqU7i5rL8mfFVDQxHk009Rw3cAwuiRISgACEUBvKYqnZM2h6dEZ3hhprdU1x6ImDVXEk/4+QGPScnvPxVL2YLOSrylb21YCru+xVnp9JCseWzk6rGxeQm90c3Yx+UtRLHcHvwWAC3mY2HdfB+G8jpZDWnu8I4kDoUqCqz2gnMQdu3Tmc/6NUF3AxzwebcYldDTTVZ6SFmAN3/zx4Uz8MbWDzO2qo+yxhadEjnQlpUaW6E0hm0j6fSFRVSloH23bKJKbPxpqsT2yLW1XmyC3aH2d3Qt0jj0XsIpA9kt/vWsDiXRr0T6KHvnWyI7zML4257Ftc7hbtZRdy1jpKJ+GUqiEBwwdCpsN3HHgk6qnEb5zf3xlmrtuAcWkEbOcdRy4SInKCpQxSypQl7lyU+XJ0eAiiEeLvHrSoiiJd13Bd+/dAkCCQid4RM8GhhBPHEAO+24Erp5L/17d/f2d/Jf5kf2QP7ixX/PoAIBMG32QFCKegRcRRAMngAAvAmDxvbLlWXOXegnDCO8PUJp4S+mWzDHZyWi5vd1PGCOByoMXpkmwoAO45MfNCid6WDeeZdIURArijsikfB7z+2OGpklSR1tyRHYF4SGmxUrv4NFIVChXSixCFCISfca6kiGwsbRxbKVLHpSEVuPPSwYHDybuo9nN77JSAmHNul3j5C9otzpLJzcOcl7nEQ3F/4rdEEWgWPkvJlWTLMBsGXWMVoYaOEu+zQVchG+O5+igkWOxxtCrgPbBLeE8sjnanu1LUBJV1IFexsJIgMYI4CEIgXGjU9VRBoRM9wAPBjKBblOQu/HyMY0w61FDoBEtvM0eLRS7m1bHMKA8JpggaXCLBAhwugiz0kSI+Wq02VTtFLVVVH1G8oZ6PrqiBiKEqvug63CDb0+9yMflsxx4eWCde5tc0DDeculBQcrwhhpRCnhC91+icfV/q4lerKpM+XFSFvfZDi8sGY4y2A+2z7gJQC2QjRnzVMJuRaKc7uwhN7AeDJ6qcpjw3maM42gm7ChjwZdSlWhQoTlOBkqGV8FKDUeF+Q5oS7EAhLrE/TdJPK/HUNGtVIitIqVIShNLEQowkbV6OR4c8Q19isoySyGvuue8F6pKSADKLliRQP4/DYUJobAa44+odNHcwirab2kO0zvLiq/bc+6lNzgXb7djtZMxLdhHPSTKIV0/H+tVwSgqtmiB80n0MkzzvW0DWunhRRNPQMFB6RGLfDz1OtfaC+lBSeoTwxzG2D5GmccFYKgvf6GURYtJ4REGJYN6uVc4wji0akyqURganSYzA0u84gK2o+AXwFHlVtQnGnnisFFTh/d4xhZ7rdPqzlqhjdBrptL8zd5oHI4lJw9HZdjeFMjNARmKsAGTZFZSPqZEs5CQGg9RBgtnhWmaHHounhuHUAy9mpUpOIpSzndfAsunPRU/VErvKnHktPLJ8FqKH4OeOjSydcTSJ6C6DFwy1lsCT7OKJ4iH+dDK6TZqxlGnSR+LUH2Pyjp23fSjRObosuMF76qZwbBocLuTBJ5jGs/c3G2pOWUjHm6iuiBNFDzPYX1uH82zdDXtoELi1zouZyd5PnVcBbAyod+wnDe75Rp4DVMpyrCeF3D+rW59IucRshSbtGRIRCMQ3WxmBiLKyPGIZMLiEymKcSfSkcqHE+KklbnBRU/IZfZkV10grBIUlmEJn/vDkS70Rt2A7WYjiXGyXs1mphMtdtp7v5DOgLKnv2Dm52IalHJWqCANKUCbbYkIoCpKit2J5Qqe52JiTHtQbNG1jTWF1kLkBggd5Vn7j9t/e/+L9abeNt3gpG2AQU14psGdIGdFq5I83I24s3ISN9oovc7nxRSsCx093DQ2oW4UAotbUX1GPymEWL+UGcK+Vt25HgpLkVYGMBENNQwfZKDZ9JUJcH4lN8JoG1dsig/WIHhID/uKheE87Mq2plTAxhPsmkszuwD1RcdIUzjKKYJJBEAZ7KWN22F5F5EQw/gVEjPempmbIG5KN2qILQcoXg5JRb/YGtkjq2fQTpinNSOE9bHUD4h086DR7xH+FMsb5L1lK5UtVgCVURtvGnd+4VX6rFMtG0UmnQxceuy6Irj1drwlI26cfBTPwDga5FkF6TssHFnJYHll2uoXm/956kPyG89a4cgngk68nX+99/Wrm+zYPD7a4s2d31vR7/b77vqnoUpfXyvr+bebaYyjKCsyr2osTupgk+wU9SxceUFhgy6uN2nZHCPiJf2bZ7BPFrZKpGl/oMOWRB2p8Zae/+VZ7cPfGgbcnlpFCgBvq/nkM1r4ZFpHfwY5vzgxOSfaqzpDA81TcCOcRzScZAAKygzPz5Q4duBsTRV8A+Efnvri082r0a+mrt+alWi057ZfWnxgFHqkXxZ/TsBqvnNp69UqqN5HOnbdw43IfgoNl3A4vfkHkBjJ8HiyYqus5X486SLmiSF46XWQmAPJGHCkG/kxnCSonjhbrZsvqAqNO1cuJ4fZTG0XnpY0hGvS7DSkml2OUk80FhTkeKGWGmY42fClykXx58CmYL1kzxzmZ2pyDOv6TsYgcrFZEMBiWsIuS+xJ1/I+D8YJyj3UB5WfDYE+bPt4hdwryckUMcwg6fceBGxHsr1aWUurUJzFXgp39aQFr3XiJuqw1qak4JaoVT/tRz2/pbHH+slFc48OXJCKuBpGZlMTfMBH1XgRoalDHPyedTIl3ZqXiDC9XHo/a2mIxcKtyKiNoMnNObgrCkTygafWQvjOEg0rbC5ROo6g5CCKF/9sHhMU3ugxWBXqqOjVMONitvG5C6rYe57bp9m+pQ5FgbiqYAtdS8Fe7euPYEZA9uNLmKRl2lNrJd0sUj93zznJFc8I+/iKW1tYd9IhDP5TO9WWVtZN7Y/zamXNvOA16DF8Y1a3k1J5p2wNetliO4fguGsDGExg7lyMuMgVrlaP29dLXLoHLJa204A0cTnGYCmroputyKDSFAbZQHRtHwTZPpJsdG26C7sJSqJo4Ro+19HpIZfnwZlglh5SEr6SOAx6s8n74L7bHJrNlJEfrimD69FQVER50sd4pDAEQvFC4GVOE/ebCETP58qmC5QS0rpaWyOgzIpMuN/lBSXH6HQu0Nbqw3mUL9CyEnfZYWURGQbVu23KgaBi75d8wWAk08QrUwOBjvcQ2oAQmIlmNus/WqeFn1aqntAYYL2uInP034312QoQwiFu8GHt67yUXcHEdmcHMe6wj86OXTvZzs7vlmHQSRb7k0fRfeuo7ExuTES3NFXLkRNHwjMA2/FIJv079jJ8nzafmH/+bPef0qI7Q8plxviw8Y5/5rbM5lsy++uzFdBPDX968HGhH5Av4okAB45dam8C5xUz6VP8+aytik9qYtRhJAeqzDkKhgFMh+Iqq8xvB5oPPB1fOscGtuhhnw8cSzXLn2SlZwrJps4al66y1N5mkqSwb3v7J/Vaxtn7k0rTzgX/wQ5vsjC8sU4wZKc38cjWAu7CHPnrmYRz77MxnLjxlbYo4o3zzDc8nVvt0L7667pzIr5E24DUE0BSTRAe9Bs3yA23CUxpJX4BsTCMg6vmM8Eu0d0xrSSOkUx/Feha8Nmc5kxkAVpI3xUMz4oDz+eeZTHTRau3yJrGO5iuUYeQ1zsg3yw9BjsGMgCeLuBOF5MDBF+O6GZrmtnyn23UcVcgDps1MZgUOY+KBNT0fvO64UeHNpu56OXNjdMOTnNksji2MsLtqSBquOAbxAqs6OmsE043pqZi3K2LsdsxWzczJlSbPh8Mg8P3gJO62X+CM5bN0UfYMyT24VzIKDfaGfUk77xrZjzOZOsqykYo/k7cf2LNbt3pAEMyFHlqWGI9aO7sKvYSHDqHN7cKhzMIDiHZppo7ZvMpbrWbT91kj7ikj6NM+IROcdwhVp79rPg9GWa6xvSsuYEobdtV8RhOSAL1ZiZShzBfY+7j7hNcCljJPTbFXCD4PHJxdT85YKwKyygiiSZLIzLw+l+rxb/LN8+T1WMcCgS+E4+q8shKV5dS9R5kxMY7egPv5DkbI9SvO6qOm9GyZ6W6g4ycmmvlRtE8wLBbRyihEx6g3Vgiisg3uX+c2Sn73aQf7h6/CvViIrpJjbdDTDVV08LD6G9kgDWj0FOXHmMfe4xzVW2XjV04Cq3Xem6Gj+NQwdP11P7HmpfgVsX25hMse5cxv4+a7Qz0TqgosY29tQpPSXZWNjTNXvD7Os4b+MaNVRiSiokFMQwYFZtOpbTfSursgcrfCzFBVTS1PhBqWjuvhFjR6b8/4iZi19pSnfxJoVcRv9H/Web3zWXRFb4DOY10mYHmZL8zqjmSQ+lIr5N6kS63BAF0ihJZs3rrTz6r/BELhgD84ZPtBwuHZCdY//1zeSar1P/gDmXN7e7Oi7f/5ny8mmu7f/m1E8q4ZgRzpSfHe61pig2//X128+OPg4TeCQG05elGdl0PkAl8/XPcuECJyg+pv8YD4cs5YO4c7sSOyQY3CMIHS/eibkUPQjJJYt985Sq/4DLbvRxPReo9YNDS+6yiYB8Ouzd9XtCiu70H21b3SwOfNYciM24nZ25215/uHyyFu4G8L2Cqv6Yv6zPB977HDejimBXbNy3WPbkYdDtURLXjp6XmhzQLJ1m33WFd7pcP35aX5z5vN9rRZfS4mrtfmkEd/d1OOWxRInKtrnKshgnV5p3ShvSC22HeowGt9GRj6e4RuqTRgOa4SQXEvaOqQWMz12/GFUMKzpYw0SCdRFBBVwb1VDwRQj/3kmeaVm1Xj09tegNqwUDjvjHCVoA69Z7BNPFVtnnfaYGsoYpbaylebOaB510b8UCe9FubLLTiyZnJyuAMvZGoltDHfJ/nOcGRyuAcHVZ608ehUpxoipAU/391Vm20PQFlzV6PQ4hVSqAbleV2olMSYIS4E+Y9QNfm6+z7c9x57XtuV2lcbjugZ3H4/SLINpqRcNbTyi3WmtFplmdGgaqE8k2edAQrH0H+fla8U9V1KocFszJNx4SapkwlMBKWWzYkGQ155rltbsDTnZdYiST50HrsCKmcFisBMsN7n2k0SgyXNV4ZSFT5Pb+Pu7E2nhT3NU/QUjPGsXUhPtmtLcKnBD5m7zEn4tLM40qauR6bpLDsx4DmsFy2yhCfXNxjLYNQJyU7go8hRdmsmM/TgF13DSgWX+XH56D4cWzFILeMfLu47hzlOD7v4iS/ggq2+aQWrNLKANPKnjx0IWmVLNxJ3poG+1jU0OpkZt4bj8bCFZ7Yh9qxT6P6hVYtnShJIajLSJgN2ljFJoWFyKVKapjZMD5Ym19dEqn+WTJVIj6ajPtws2ECqbiLhrbOTbo6XQqpL2eWm1GtBK9mP1Xj2NpzhCDcm9rPhWeGJhVr/Lbpjq1+zvbpatkMfDluXQTqT5fj10qvPUc/w3YP5d6EuZE5lYWVC4UPHfwyH8x7XT265FHev3E9IBGLbNs034bCsYNVAnCluYuFJ4KGIQrGv7sC3BGLWs35SXugfmGMUuoLN3Gej6uXSDdZDbunTb5dEYJpyvTHu17vNV9RqLPPpEq4g+xfj/A5LWKpY9MZrQDblNMICVo1FCPpJJPCchBCFa3BAAph4xCEYOhB18d3D7jNUT8OUFVARdPqa7Bcrn5P9ou/elZl4U4FO2KTez6b1+jTr0+vVYhIBucwFvx+kW/wmFDkAko8sqxdbeMO5rvcZN5K58H2a3kagkknciQ9MdtV6fZLC7gtfc9vffgHvE9WXPZ6S1e3mq3Yc5yeqi1tduUqNQh2X1Ooy+ZK+kx2+wEpGBh9ebhVMjRIACLWB/NgVsoPBIkfKyc5VXFSNiWcebaP+USvoJhP1j2Kb1FQVT1SYwZdk85Wo0OVjvchiajazUWVP+MjydQX8Sre7OhTUX8vC683YctuYiPC2EpMibjeYLhvKMUpyYGGQz5EislRBPLiIiiopaz0jteXg+zjj0v1v0HfEsJGFG0Zxwm0anopj1UcxpRvkeqt5ouDucfD0lf7VLNR2UWTReKVw/BPbINfAWrPRIAO5zxCUl3w8Pvtjtbsx8R3cr32jkxBWXM1VauabhrpmrorKL16x2JXD6zUWeTy6uNLmGMlbPRRH2m6zPFb2OxmWzcTjITViI7kZZCqedbGcjFinbFym+ruvi+MWkG64gqo1Pdyom+u+g2CJaW4L/6A0WrKV2O1uTigKfxxTYjMKnghBqdbx/Fr/eIKxXTs316jY2zfS8bVAo1IpFskGaAxuboIUUrDdyE3UNIG5mHwizfMLIZ3kJtGMnqsBjvOfyo4t2TtFAC7evQJW3p0DucjD714AC7yWCSsf7BHjK5tcwFEr2Far2TVhZMHT3jUEQ7n7z+xukUqDdHS9DYCUIgGtUvQB8EQSf9qEwPPDvks+xpYRDMs5UVwU6TAXooV8EfZILqrz/ILTvZQSgZkql1OpCurw6hdFK58yVePWcIlVhoIP4TtpVHTY8ylQeJYNmavO+vMUsiO/IJmMFjusi5Xqg0G9HjbpTlXm/XhI4eu9cFuzCKKo1oqoQqRHW6C1ftdesPddR4GjTjAG4wecJ1mr6gsYw3ykExrh1skJqPlQY7tko2wa74eyIIhUcwEeTKHavRNwscg8gc49tO0wjKeFLiHtGE/bvX70bKd1oJLHhsJsxNkrFH61nu1u4WeATRKR/c8yu5qbUWpeUGVGj6ZnMpjcBr3d1I7tMjHFgT+yREZvjCMfMZciXpr0IujJiQfnpOR+YbeeolloPH0yGPngfIxPituZN7iwxAgxkALQWqphDJ0K+CZzFPoyRNjBId8fMCzAakDmlvxY+Pj6V51G3Y4xGlhfbrcYfE6tUmMWKWLuBCADkOlABJTrcyXTt/MzC071r85dxVj5TGGXo45TFdDYmqhJqWvQMfFUL9ZT+K9HIqri0UE7lgVe6Ika5XAByhxSXl80YqNYGNpC4xtHb1pU8YCQQocC4tlVNM2idpcG02CwSVD180HJkozIUjAr5WiwAMdxA9+nHfOwXZweyx9XHkZgshSbsmPODgFUf5pdQQavKHEIKY8d+e6ONZ7EvT9VUUu0JFdp9TElFPF0cpEp0imopF6oM/qXttrtBnsLPoqISWHMqROV5sCOg/VHcOvR3uNBPhWn0ZSS4NS2LcHjuLqJkEnFR6JriGwF5hIS0c48RPe5u1ZTcO0a1ndiePkP8A9Ve9eX8KVYQ3gYmplmF4cbxLoRtkgQc6XNZnmEQqKx7M5QnuhNcqf+3bDyTtInr3EpFYMgVgR8MkBz2R73/TRVBW80t25ZCQnHyd2yJoW34MaEg9l6paARKVsRdSTunQNXrqsqJoZxtPt7830onL3nWgssvHJtBzrq2m2vrlxQ4CeHYNQxXEHkOxfcGQ8dN1q3PGSZow3BmhKZcBp9jnumWI7254W2J5FYf4CRJi9YFPSYGqPciAnI8n3DYFsWmcvovB1LpRlZpqqUNqau9zjuJFnBDQKeSjEwBGAc1Kikg0TaLv8lkvmfat5wVrmins2rB/0n7K4nMDRxBOLIeSGP/P5onwfXIoBRUf92aw7zMnD1jxu1slAjcsMkfFThQ7n8ei3Cl1q0j250u6MA+5L1iq2HXeTHklliGFTds2qS0RFpg7QFpBUKK1ssp3uU0zd8SdOTS1L+wSgvERy4bgGgMW3aUioQw2NSKgbhpVQiKqIRvRIUWlpMLtiOwhq8M7Se1iuCt/ZGS4efPdjwkaNHqHX40QvHl+WFGidKKHtyE2iqKc1n/Rejf0kYD5wOnPWvcX2hvysV6YFRs8LUbyCdYBfGhc2ivj4u3+tIfLvdGJh11FHWmg5QoKitUcuCeRNTKkQUBm7kphHfLOtQxBnNBLi7pusyJEpQD0SeSYhRBHHbc6UhHhZrhQlW++t/EV1pma2fPpxZ3WKwg9rQC2E8sjYBPXoeadTC3h3UTTsvPUlWE80lIwnpAzuCOtZzGYcMKDsS5Aew9Gm7NMe/JphJU5of1yTBO+dDnvXWLGACIjdQlJZ+ldAjSG4+HIZuqLXsOe9iTL3WnPWeHGw+Ut1FcF8bsIJ1vu+vDU5DqsHEn1P/PFSjy3e8tRla/ITzpiPD4asOkxu+P/PdmS/Nd3KtD3dtnFgbz+v9DGRXr2+yRFo6depIozy/k48TbMsj+mxKB6gZZoPhRZAf9JJ4a9CiIbb//F+Lkq/qRzIVuXPRaSDiSiz0chYOCwME1w/brrRZWaV1kO4q2uMqi+q8anQfEDLbtDZflk55GLL4Mjdn5xFXMpGnITMAxyCkGzQrLoEErNsx6kww75S2VeeXbrfMAAjihw+DFfQEgcgAKkKCKokiFshfwTIFrvEpKPBIFbZQQdZR13CQN1cqjVmkAqr/Ik3TeIFnaEYS19cEvDyXPcIZd+LrK1vUwILn6Y2Nfl7YjQt9GOau0Nc6GzMpMkUpzpUbKZx6ZTRT5Pqxo7EhCOU78XVniFCscpfv3h3E70qZ6ydhJvSdTG4kbPUTIhHBs/x/LZsYhFP63mZC0T1RV494awwd9u5LM/Z6998fdhJaOLZEYbmAbtuR1heR2c1JIhfN2g5a9wwcH6EYwt7jLAbg2KKyIlPR47QE9xocQxvfY50c/ZxprmqLccgCszOgajmOT2tavW3nqF/AYQIGBHPqi65Waar0y6CP/bmXzb0qDCtvngnLaa/62TxzAaDnjgYowcrRW283twOu3crZ/MKhzpPeVw1CXE81ZNlWX2R5DjbjsAZYttejByC54aW1ejuLZTwWgM1y1mM0NjfYcIYij1xk1vQC3YmvQH+JlmOXhRvZ8+QlgozlcKMY6YFSvDD5ze6LUdj2c3Zb3H/z4YfEPp5VL8u3qRlvKhdZZDW2VuPxykJd1sfQrdwN0icxmQ8eYlKfAaN5hlRoSVy8cuMJJLKr2qDatgqoCYMW9XssSQpmQ4MY4YQEIWy667y/KA8OKg5f89Il0zrcr3G/KVtWPifft9USTy9PTvbbfvA5N45lcdhoOHYtRTBYsw30AyUjPYaEXCx4eTop9yN3EPDR1DZK01rH/RwQdO7n5ORknudzgpYBGKZjH9hUM3tCjO2T5E752ioQFhe4I9bc1FOCABQV8BQRPo5cRTEgIOLQXtQCkdudl905bd3CuFepa1EOcjfgq7PNpX4LvBhHR2BL6DomESwacnriwC5R8ttppj0AldSPXdbpbI65K0hIP+l1p/H0xvMaHbXZpLQspRQV98nJRsj+7EMB95cCAUVRO8pFfzTyRbTJkX4nvk5u3LaVpkmVKEo2pzYNNUX2z1v/XV3zpUh609FdXRR1F02gUSwrQHfia75oICBw/b8o1W33drnz0KU9zVVPk/5UO277TpcXTlcUnYPucRO3yY1THMwH84JxkwOgh3DPoG2c1iO+v7iZmPTE9uB0NjsFTxZ2VZ8wl1JhyUvBOZWKZmpKARTixE4TnJf0Q7fRaHtmuLyQvXRqdFq9mKRcv5vWcT2b1THa2Pyd+BpR20mLhjgFcRxSIGMp+vJ2+jIEX4CWxVv2aBpPGXvyGSFuu75TvuENYz1uhJN6oPsFz+tFvGDN51jNTSkUPOQ8nM3Ja1v+QAx3yndoe+WMk6soubpKIvREfd6bhyS72m0ZaVlEDV7JDH+ZWb5vZUi5d6d8zW2kQtCFAUUeQKTwH47jxeZslz9qSsI9i1ceXPHcpRzQ5SeL8SLP55WgK5FOABOHWrSU+iRqlUiJrFa04sTX6riSLHA4W9rcx/JfABLtE0H5zx1CsfOvh+ib6XM/RhCY3I/vs/E8Rg6cXgU8VKleFnOVfDAMiJkH7SABoocRAMz/TWFk255bbukWB7IFQGTUBLpQFKKKAOcyCWHvpMKJ561dx1V3xIUpFX8wdLyaw1S2i5CpxPNBqgd60LgpL8/noWnaAYuDw4iqmH5UyTqI/0F8rWEvcf7bhM3gC4Ryf4rK+TG/Bd/P4D+JbyP3uFZMhcFnTh2h3Mhyw8gztPRpKHinxkrmkVbnvY6HHRbXhQebYMyIz44AYw97nIJg5lDPjBzIfWZyeVHHmIt1wkWlfAD93s1t/peUYHELRDTXcJPENZCwmUygmim4skwWBY8FCE7EKWuT9GSUpqMTxOcMwaUOO1Vh6U11ARbG2Oxu4GOyNm5APLOo6Zap0wlbNEUMN9bfxCLHtCwfo1hhU+SIerncraF/tyUBFiSGG2PLAkSRxWumO3iASUhgEFsaZOD4rx0wwescuJ+Tb+Z27gNEuY1bo6pnJtsIWZhphhw/UUFGbhY8FQcR21gQLznbTpFDPv4YCPdTzwALgUxVI71vsQ93VO6UghC83U7TZP1OfC1QmTHbRG3X7hZ48ExQJyspVjiL0HGXWYqM6iqyAtkKqiqwZKwVrDVFvc5FEv6Ec+j65Z8EriDwmnqgB7llneSjMHmKPIdiy3EuK+CGTLSNEjVNpCBSsd7UFd0OIiZT6GFOwjRCYFCs8S4PxOeW2TzyOBPp2Ea6jZCtoxwszsQehtjGJUciy+JBhGsSxZvwm9WFR662u2kOx1fQWypmjNM+8mtSeK1jvuypNCk4LDbd+PZGavtuyP43eiPayH/zAcYQwSKkRsAHUpDmbeqDSW7aJuC6l6eAaJVXpiWGYe4A2zaW3rT7vd6KDp/wepumDoEA1o4ywsL7dc2d2zOhhXe/KWJ4CcdK1YbvszWngesgPNiUyDGjYobRu+hZNWOZhjGQFcB4gI+9gxEdPKfXvdrRlJZcBH7A8aoGAa9pfAA4wWa8IszRVEA8pyKOQyoyAl+UgjxHhPrOauItKjlDlmhPioA65sN6xJiO+VMMqR/TAGUjI6OgtLMhA2vnMrGMOC+YbYlqh2EcnX5jIqwALXRMTiJKUmntivebgGoWQvxCRp14RTeJbXnUa7b96dSvid4tFp1u4XORbjjkeyKwGjusTlEuumiN2WFJmIoirY936Bg6dDS8torzggJChXs0VooQ6JECkaJEgCaEKlcQJKSn2FOIWINwbXgPu6j2i3+4oE5Oe0oPMro3QxJWJn56FimTsyg6myj4ighLCoQg3fPRLCUkRqDeMR+u5U/UouSF3Krh9CSKB878IKLFtMCh5UyNErHjsziKQKMHIs7gOhX72qz0YwqAzE4gF9R3AhGNuKKbN4R1kZKVrYypEdGdsQbYCeh8pvebG+WmkeiMUexEMBt9eUNf4+Hw2RDiFA5TZUSIAe5m21jq55hjpEl0TDUQHMGJTAokqCpyBiYJIqUktUPIn8+866nJSQiFPF4K7aGD/qBxL/lpTUOp0HPFCVAzPEFiGIroxBM2UxrYIxbKutajikVwMXgCD1L/oRE7ioY2Kf8OBHIb2u97LHjxvkV4s6A60DcYb3TAD87/VfkWMthyP0ZcuOR+DJ1YatvYxWNyFqvgyaAAyLEdL4qPpPjQzTJwl82WGTVCEHROEDgdNRYN1HJQLDZT4tjhIt9kI6jbEXR4kgPsLZRaZx8OEsJLGFEU8PQgGgOlaGw6jjnW8LSgtpKwAEWRYIWMeaQeDL+xuvWj/Kt0cx7TpPQp73p81oM8MJPABMBBgvcSPVtELNXZxdRhZQ01JCnRhhOe6NP5czzNpNllJTxXrvg3ipeu6FYb0eubeySnBdHpfHuv4NzQcUKXK+6diDdBug6tgUkGmaKs3ag5Zdr26mrKP2Q7eDEMoojg2i5rwwe+4n2dWmuhkUk3VCpTBDBd2Zlc06hgNtIcTmBrcDxQgWQ9ygHHV3c152i2ooFOz4QhPb/pC2wveXt5XhTnS5sXHpPUXRO8Yv7KuDqYLoQlXtIYiZGIl6yB28GUvOJWdJzDvXHwjcC4VvDxR957b2jFfOmRC6HRCE18env34KU+cPs39nDSa+A1tHpgv4bQa7MPKuHtMM3DLeurm5t4dM1qyKonz9yoyWGQ4pXBF3AaoxUFifJwX8tNCGNxw5GKfY95rji+RV07bma1d9QJs2AE+EX9DP7OhH7g3Kn5m0UkiKKgM8ftrhL0YUCIL8YBj9kjouR4kWO+VqggKced/hgYpW2XAlrBLEdPgiTD8GEoRAM6xShqoWqysfrzyugYg6M/GE5oGKGDFlkuEiJOHcbyTHSzzBVRqQy5TFgJwbDpLL6ctc1Kr9E+OGLm5EfNOu6vl4kzQSPTQaPlcoQcU9itj6vNgrAmmWrVQltoLryopOMyOlHeGFS5ttgF3JKyF/+cnFg5XmXVvaMO2FFr4YrXK7Rb4U28w5sN3sX4xv3FeDSH1WzD9nA+ix9IynHM65M4fbQYDLm8YCbkSlDNPBb8OirbBHjzcx4UfWJ5CqqMsNcB77EgkOIhEyqrNiUGt1u1A4dwFPUfyEahifeSY6p5aeohdLr6bCxQVyIPFShNu8SQFTretiZpwSJOAo3lNKhnLJg7Vc5xeeXgxn8rBZ/aNoTZ8/XoyErmKI1TdAxuiYxslaeBgbER/HFQcnqQ5iZrEPKGWBAm/2p2o0NPSB31VsgQzERrmx4erP8faa6DMPQmxaKIHVSa/cxl6xA7DnIjwp52Y4YR9K5AoHWoUfglNoaiMKGAYLI9SCJKGEK3CMNismWtvChLN+n7uWeafY4maxcmLgCboKt7vXNkfrZFSU93+jTna4SJ0RRFY6BZlxpjKE4fZQHIkK0yL8heQI9a2Af28MD1q9YHw7RJ+9HtLxn93uLbbt5KZ43dnjXNWWvjq9UxGhiAO8YsI99EZWnMmYD30pT1PX5MHl6UYibtJUaFS6TFb8Cvw/FCP9Y3x31T10UUXUuSujL7B8WxV/dr/SFST/fq6fVkcn2q7oXX0sfowWSLu3XH66uVeGCnsG4aJ2UrePuo8jWmQqI8Ihi8xdhEOaBQ24n58V/LUkiLZ8EFES1GxxgdS1CEohgWgBexmhsMR6Oa+UMpnNTTRMPzOIPIzBBSm+IE3Z7rDbP+Fy6gv5LE7nnWu1xtWzVA81FvFLIrc54XT6vvA4ow2Fp1ezg9uPTbrmtcJvGcupbD/d7YADQt6k6SHi0D7zh2KCYBAtKCEVjEq5GF9mZrwJ8SuVm9ug/CSD1eIjQvyQqd5RCd5flZBLjD/a4IN4M/MQuuSgsb0r9/KzQkyQhRwrFD6EeSTHCj8lPFDIuo5iI+h8Z4sohqWi7THrIJ99BQ1Lukou4D0MtAjmPZRiNMbc4iUxyMqC2AJrGqakj+3GvLLKiaUoh5AgB5E1caHWvFoAqZzU3TkpZhpinidBmXcdTofbtd9FAhkcETwhsR3vh91sSyw4ZSjOLYiNDJYJ1w9GS1ZjUMOHvAKeAqf9U894KagB6GqbWkVb5TkHi2rlzxrKrORBdfWTTO18oO4+lkko7YCrEN0/Xie4Wh65BMVWj6WDvcAeYlfFHEfK/Lsu+aWi673PcB4B6dr802N6692OYQ4uzYq8firaK/pUBM2L1x5bEoajI2mlYX76xuciX7Z/aZoUWUXE0Egeect8iV0vVnwaLfxIbMVRld7fLlaLTMd1fCTaLXqKruNtNLFvmieAVxXhS7KqLr0s0uoqbKR/SY5bSLCMWPirDlfEFZnFLA4PQUXLQl/Z49XETRo7h1p6b6/gvuJGJHZkmELBSC1VysuL5dUZZnhmuKWSaariFsYlptScA6M8tjazlgU5JMlbOUdBzBdQwRQSDFhGNH+QCzbxC3aTK1+uDl3gT94/l5eK/fbZ4oSLxJrhNbvFla34h2Iryp7wvksWYzfaI8nGJ8vts1Z+xyasQkje3o1fI2ZW0XOVPwWpVuFc5sqzadYEAifLH/GczcUwAAuackth5NV1vYhmkabgEfGorEEIvNnfJlaM/OmbbCDLlkBE4HeyPCBhLl7/WOEfRV2XLPaIHHF+6v3nl1nBKD7sBXLXD6alm+egr4TQONOLnlTh/sSftg37b7Bwilhqj9qRgtmKNZACKtEnUdihaEV9cNZf5r3oF7ih6W3FPaX2SpbNKpfeFMLhzfdy4m+H5DNTZQEZUM7lgPZnJGZtksA42Q3Z3y5fuA24L0DZGxaHSYOci31fIPKzq+9E/KN4DA4J4Rh4MG3nWrAaD22hNeC9Aith8UYSqRHz/L5sRONfkEtTKSUdqSw/mQCtc4AdxLRJ49tBzUsmaJF8Bj6sQ9QwpvVSsYoeaeEn0latP2lc3mlTbF9qdEWoC7yj3gw+995/72w1fElrj6MEGfmqVXiHvjhuJFohYeb1cPPsChR4vFalwgZv+xRyTyhguxbpY9iySEYkZ5g1dHCVdi0djRwqrcyBE1+ncWqs7vlG9SWIK6KYVNWW4EtDdpe8KaORnLcMBRG2jA54dNIbEpNHYr8G1V6FJ/gLXxWkjDYULISqfb5xk+sL69fmfJilvPzmGzuS08/BpBwS3bHbdkuuVK9PhR5cv3H4WldXykk0U+qedkJ3ZIa+GF0wilwwH9pbrcU0pfaenw9I6RdPCKqxPyV6aCMH0Fvb1M8yJeAe+zi9eZVa+A36+kKb+XpD2PjCnpJL2XiIfKG3gNg/OoOmJr4EyaVlktXEpr2pyQ4YqfkPvcU5Irp3m0Wj1qHHzrpeDIYIVW55sNulot4J9HObNjhm3s5zSRQ6ZgWThkQ8dkiaTcIjx+vmVvF6ZjVqUUgSGG1mCJ6+Dvp+/rgItj1LWD7jlS1167mFu77prD+FKju/hOfBXaS/vMDnIEYDJYkGuGdVvD8b3YXcHnnRD/wgv3FBqE3HNwkG9fvWYOwRwF83mAUFfRgKUrcgZpAIToYSCOB7Ms1q4Gti0wFK7K6G06vqsR6YPu5WCD2xP6KqbXmuv2+tXz29vzV69b4dMjAnuuRabcv70PsMbsxfVHWLc0AY5fXpRl/CZbw/dVux+ScjuYVkVxslARN6/WyYGnzGlpms5pqvAcz8vzi+HFGxPavB2hKwk9kfRX2bbZPXmj2e2aN57gD/mpfFn5APJWNJ9L2ysXWwqC+eVIgctLUJA1IqdDJG+AToS4uEkyWgiiWYkGThTO3l8Rr4/oMXrvJt0tsQ9C/9L1B29vP3gPdV+vevKZPKzmb5QfQ1ruOT29lb/anBjCZ2c++9Zbn7XQ1+X0ytvGX00+75FL9Lj3sDFe9ePFOE8ev/8SeQ/HiffwoZeM8eIVog0X5OuLeGIwOwxEbBNO4EjBeXguovdHiraYX9IMXb0dYMO7U77l336g3Xv/SfkWfHgDPKXhk59H6JPZefa+sfHJVWP8vmxOviyhL9e7+W6x+MyajR/9IAveLwtPD2/rtCt8M4vgM7Ngw03x4NBHPgojZbj7GEsswcApTrWrOTpBjKhuQ/zf3hR13hZZYuCTLa1Ha5vWkJZyXYtivY7xLf3FhYPZNTvviyAbmZMMrnaZtJObYhCfLtcAaLnkO+Hklal88Pp/mRkE0QZlhVmMqOA775nTqncR+9M4oV9+4p3wjtDn/cb3Lnb0xeU3Xvr0x73S7KVveB//tPCjCs03DAANrQT84V2K99VYnDa9+Xj9bXb9ns96KKkv7t2gMpmdkbevS+SXhG0HlmIJ2qJF8TRFMLnfqpurYOlIAuNuZJ5eAl1LvSRhK0ovHnreRX3W6RcXeneGH2lofc3CPAzNXWJOquVxB+MBw/UAI7ZTV6FqrF1INerV1G7TngLRtZ/lFDCvpSymvpcD0gE8hEqZDp5iv8rnZNHJEuYvZkWnbXbho9FEq0xJCjKKDbZ0fMUHh0k46nBE1lay75uWq+evR1cWRSdGdLPCECxFA5ZLMNDYo+aOqZyv2eDZ/CyblvyUn9pFqbAhDsI8JfIRNhviAfAFq+/Xn4aM6j5vVJXBo7FMJzWrKhOzBTTMXjThVuSFbjKMgHLTCxCaRkZv6WD6sozBEBH+gQadY4hYC6wXrMIgyMbUyiix8NbX0M+ZNANgeDgRMWPKr2hLCJsrxh04DukcW2riVBNFbYpmjjL81MR1RcfBJpvDetAFiBBCVEO0S9m4r+ngAx7L9iKhZEqiqGuiXwW57vD40IQDg5J7WWBi0JlNN/sgs+0smOB2RNXAII4DGYMQYLn+i3+0TqFMa4ghJA+OFmNIHsJLw5EufKdxUtMEQzxOQWqYKSQ6iFnpAVcw7V6iNZFafW0oz7DBdk/+sCVhWw/MPrReUQp/X5Z1oVgY2yg6OoGFCpxZ2MKeeDS2DZnHJiC0eRC8Yj1gHzZxfrmZpgaXZWJdUhAdzSw1TC6Ow8wV/pj7tC04B48eg07u0OXfq/G78IedKvyT+CZ2MOOekaeO16q6HqPz/Jgd/kn5CsLDkvsxVCReyjKJR2ad/vcKwDBra3Uc48+JwqJ77lkC7vEkOaaQTTbfS3uYpft9OgP8cHSkp/2XWo9OpJMD07Zok3Lp6QmXohNklCzuCy5rRHHLpzafakOpotCHZKIEZtqJ7ehITuDv4mhBfeOuFMVb7MYuK7dlIQqD2gXDDrvg75Mfajlo8VwJLhAUBSA0rY8U5PWd8uWHbdskbNZ2b9EwVWXYEir4VIwszINjNBytTaF2XcJZcwJzX7oAuJR8fGUct8/SPRSv74k7oS7FzW585K8RWvsoUdl+cJNM0GwD88gSfUHHm+lwTJKs3aS2We1VbTbjPjqWRrq+CgIGGfucGHGQPkzC+A7PQT74w4103CC78OJ9cBCA4kQFM4x7pzvwvqxkG4B5xR+cH9auh5yW/SAAmPvJI9odbRU/hju1YtFQPAqiKvdKPAgEiUMixrHJRGr1JAi385tumQHgY5fxGV/6R1dzGPANySIZTVhiWu3wKKzTUos/yhwBzlTGR4tkg2IIKGCu6YSK3l8cJ6KJzlOlcYLAISQDf3DFUUOIbtdwGwi0fq9ekkKL5OOpbu7ZKZmn7XzepmhfbI5x0KYpJB7RV6yG2yQmPNiN/d8d0dZ2XJMQB5r8PK91rYVifNRWyLW0GmmAEGjofC0fZ+RsYHVCiL5kiQma1uqtPNzQeVhbFR1opOv43dBDzHQNWoF7aLyZv5TRSEZ5juQRXs8qNoVh+aygr2U5aETLc40gtxwSOZEPuEMKo7IcGlfgkCRu/VbXt8oNTLjneAdyGZMYd/l+133/En2Ed14F/KuPzH1b7WjJnX2I1Qk7uLP67KyeqXhjiWrKTvX+bUxl7E1gtyHjY9LplVbTjKBphxgSpL7tEIy457xrpLR4NswiXwzWMoC9Rp09p8dW0zPWlLYdYZ0dlGR1p3zlQSFBNo2J9t2GjutS6ercHYlePh61BbaAEGzRTC3vlG/HzIW67jjWWuiP4jg/NzYbB53fv+8Qdg0uuf7tVKqaDVR0pvkE67+1v4voNGaxPPbWgL9/+cHVSyBavbv/Tlz5+oJG6bFjtf/kApv7SDu5+tDrJwDb1z90JXxyKgYrLS7g7dSp2zLx8gPJ3Y0L6f2GR0VURLuPsidoxuUHnMmTtcAsGCOTIFFVjfjigj+Sf0rczI77uXdPKChaqU4fOq4Kh9B1wwOowoNEOCi5DXP4Ut1LX8P63LHA+dpBlfRZjNLGSRoWJluSFtQaIi8BREUFmxpRkWIy7nm4W9n25drrcgA38bqHykXXXSgP8WPD5XJ61NwwEbCVwJKl4bFLsJiS+3fKV+4v5TFHsyY4nvu/mDpblDoFROm8WZWH56euq61pqFlS0tXzpJnNmuQJfmUqEd4VuAcD3dmVky4VlqFJy3uf7WPh+vqlKDcZhMrGuXYgt0DtiLRli/QR98qdL7ovjC7n9yG1RrXy/nxkpUButV+91GoPT9iCzUeH4Wq6uhGupitTEMzVFHcSu88/G5/2lONOiWgZ01fx2lZQ/jaaFKAU6dx9MdbYxl8VJtAoo6uoZ7Hvo1NDsO70ZW2cPp0QsRnaQ/c0HoWQxVugE2lrwsXX9zc0uvHNqjL9+/iRiY4nkiZIDx9KgoZHIZvzjMe7KtLL6WG1stkrNHx6Q/N2I80DCLXRTvgwSa/5kt0/XU31WI4v3kDKE5abDLRwy1Rtr6cMLzO0HEx3eqcsnQmaRb2bvrAIwbbREQOR14DwD3hzoStHlq4krUGc1fVMBHweH5kTLHGAA3Mp5gOkEGZHcSmcVJV/hN/fA/ePF6OKdVHZuvH36/Xeb/BjE/U6gM3yUL6wr0jsOMJJ0RV+lD9dtjnQuaXOSOGskCAgygrfRCyan+2qU3YDdbaEQRzNX3TpEbwI4Gc0Pvwwvy0QCQV6HLcAY4i65hg2VrRAsNibuDXWr3OkCKkK54z9l1ahSihPqH9KrdJtdS4lOnh0vHihZny2CF+0AVuXHeXdQKAeV6ZDsIJUIlZAx7tBcICqgEB710+KP07yJ1vSZaq7HlE1pOMAj3tG7iTus2kXm6PqTvmmYxpujA1/1JZuBdjCFuSMQ/ICTnXRByx65IblZq2rTCxqyKGQquKDq4AC+gRLfIAJiVmhD4Lspg6kyvqpb04rFYN21FSw9QjReVE6chn0gKVQIRi8EAoTwPSKY6Vaz2Dq4b8az6kWonC5LKHHjWCaQoN2Je3qZhmJTRQ1IprlyuN+RJVeynYrg38E3gpL66rdTOOjV1LoEXe1comOu7N+oCRuXLdZrlbWmk2cEYjKQ29Eaxmik2okif0mZ4hpao76k01tX/nC2S4WWwftTDrRVbYInFSKFo4kOQt0WkRkstHEXnSQreaQEZZhfCmol0ErE0DXNAvRHGCRaFiSYy0DD+6E1Kz57VRuNrG9qvJkNE0oqEobi5zNFktRVcUS8fmLRoYkJKKq7hT2fq35i3OTpkIVTgUhNdHYp1WaIDOBBKYbfDiXDjPBXiRhO3d0KzSRnkr75zIocmJ4kmUJd93XY+LWtZu0+FyknwdVA2swElfl5SXr4NlQFLvcvUCM6QNV5wShvRIeoKhcdL7TB4fcc39V01EgpNfzmntOlwYcWtkw5PYAwit+enrLgudQEbbenS72oRJVibJ/UiWn+/1pUmH5iUSOikFtOYvKFDQZEn4QrNJKDi80lzdYRl8X2eihv+BSqtOqC8FQVUNY4ItTTnr6rBvklpWNiFgxGqyD2EcIWAMFbC+GTUHX+0hEKfvQSQQ4GpjUO7yUGb6gKtCfqo8TLMApAvJ0708DF5HIBk9RdVNVTR1pnBBJmgjXf+oRHKU7vh+FpZUu7jm2iG0biyj3rO0NMUMhl3r9QGcYpisaEUZIy/CRdtJBYNtCwR1maY0mwkxUPBtLjiMZUrCxKy6EgolQYjqQg0iOZKQNHRwPGpuixkGw2E6dzZT9RZS1mzk/mFmBPvatNHAUTqDK34VdJQjK+dwqYwYtOkmZMzUuxdFA6l7v/+FS3oRgy/SpGAy0yK4vEB0BCgUAbL6unBVZFw5Zr4lT4GZBYd4Eo683b87YXE2naSP7yJw35MIpl0ilkDDsgBwhUUth1A6g7c8jGOn6fUKv69JxlDsVGkFHrrjR3pnPnf0IP4lXdyDesuH0uvvIaULvkqUVyvfEIamHB2gd0TtAYGaEGTkKyCwa9ZntYNYvaV6BuF+4NC299uwfvw4W91O2zLAIH27HhM8eK8s6uR751jMBYK6FfE6vloGEY4jpWxFg8//fq8NkwLuUMvDQzG/lXM3dtnVzFc/rzvdz0C7KbHxqb10/RyhQshub41lahO9e39UM5IP+4P9g2+73o1xnJytGnjcq0GKNuOOkBVaLRTQZoE48SMjA2z+mEq0GMMaHwi/KBTsKKg1c0TP/NwQjS1+GuvCAc3wDF2YBUJhoFFMbmKbPGQ4mniWmpS5qFx43g1WCsPhIhVMKAqZi7jlKgM1bg5O7Ldauy4VtL8oa71TVpjhRW2Ibrn8Ci+7ONJIR7yQvxEUwSyZKjcVCzGGycno3yjF5qGBIEsQG4UIGIp3VUgjN2o08ZzgQdVw/BSo9LXZNXgfdXCo/IjaBjxRJm6rqWkIBqioy8S6ugf/yy2z4T3mp76jCj+CnKA86Z9GUz6SsMtA+wmdOBkHRG7a0UnM+AqFUNb8FLPG/YwKfnH22DzaZtDa1bghON7C7rkm2Zgo8X0HwEuSzwf79f8JlqYYr9ilc4mnjWp0bGDCTo0c7s5PcIMcWjFureJMHQu/+X/zy95v6MWPggb/up7+t9SIKj9nutort7xcmwt2d6wceI/RA3lm6yZL+XquK6/PmGs2LX0jhh0mLBs/P+O0Ncxy1TP3/78StXrBJjBuFbz94WAXgjG2eGBKnyg3Ng206XZEwNSXVBqT3Sp8JdRN/sbEBqLBEqV1f+udcrbTjxpZWYjqpX8drX/jPbWSr0pr/HTQSlec9ZoF5/9Yx5T1Dv/ImDYpP89p4EkRoeozX4TSQQqoA2fCX4wQPnXbptbEUAnz+8ycAAHay71QhXljQX1v93y+erT8XBjnq9bLpcxyonr/UHdb9k0j7wOEbcFN0JGZZhPXmzIdFiRqO6m2PgjMfcPVgqQ+xypJ+UCoN9Oj02fZ7ffz4MUQzD5zylKKY2PxCJjcrJEYUTCVZC7YpRPUWYj9BJEjyzGLee93CffnuiUSAlzdZBYOdjJU1BF50EFMjRasUmaLmK9xjk9ovi0BYiFbPTi2vjxob8+ogtkZqDp7PZkLkHZY6QTGYRyNVziWAfjRoDqaa8cZv8ApyEEKWp2Mrn2Tv+D8KpHRirOuh9ImHuJytSAHisxRnVNiBcjIhMkcFtgEhcLZhN2qumVdGzMfMZxvx1NrXvgo3gADnn16AIMcfL7NoN8C0wPegIWiptJJWkYVgCLVYWz5s2w00lJ8HouKQoWuqAHwIQdbm5FEKDAWY2384crUFFjo7dV5MYckpn0Z9b1B6n+0W1/E3Gw2jbhd0ri8qKl7DbRDQu50ERF0+hAlSa2wyMB4P+pUVyhYi4HJbsM5zJT93KbguUMpVZCM3ya/FZSCkeDnVFXja6xy9xjsue68UG4vahgW6grV6XQdyUDHX4Zh9p/cXwJwZn6XEeX+wfq1RTInPURZSCEN+olHLle9BQU+7YeGKQBlHpUnmsQHmcYlxjCW11cv4kl4xyc2tRL+MkTRNyyUcJXBfYW50s/nYe38Yb3wWGuopA/abkzvWxnhsaCoPlq1hp+aHlQLA98fqX29/N9nPZckpFVF9nMarltP9ajqt9mmn6+4qUxRuutgddvQDMKhzeuLMLxC8C3/pq64ELxZxJxIccKj0bJJUvcHkFHlrG6KGZ7jbxrANm1rbf0w0KZxDQW/Wa4HZYCcgDJ1nnyomwOIL7JdEoTwkIqn8dWxnqf7SSfzl0k8cRiYWhu4WJZP16eo0tLZYnSN/zcjLyxyq9XoOmI46/1TYodr+Q5EWhc0tfmrPIbhnwGI8mhTcBTm42YDOLJsv85BoNzD7p0ngqCYIkOcgUM48jxGT46G4rq1bZ+J+w1/qE0sWPoLvuUiXFWSlO7FYQlioHRUiWfIG4xnWU10Wmz+HJnTwuYmak9WacBPPc1arQo1LW4mdKJXYlK7MnXg2aYjYYZLKhJnTwHtBz2guetR2kJjAmbyIGu6IFcNEwh1Ov8HgguNkhJzOJto+wFDaTfelzcQoJqM53EGL816nyq2xiMbXMKrMo8Z7pNUPFxiE7MD3B2xIZ4QwFAz6bYwl3s/2u+u9lZNscuJOEuFqW5Qn245G69DAiLTVDW11v4l3YgZvaulf23fPphPNWtTsYyhoaHfssIsfkG9g7XwT3c6MdpK0jYzJY6cwjAekaYyC4yh9/12ipHs4P6z29hrNRxeiUfKqXHNbKrVZw/zCT2VVZuDbWPeIgTUMrLW6S2hOpFaclnBD7SHK5eHjg8AYzEuEKEkoREgk8iX1BA52GFNWXA2HpHCKX6tmNUTA2yhUM/3dL49IfKClWojIVV94H7UHVxKnSvS6XQ8pZD75BrMJ1O/GUEIcUm3wfXIaZTkRv6T9kOh32dBPYMSbgcAE/7JOY8bI9d4xHcbxpUVWUnB1f2aPHnqS313AnDkKKNwgXbiHZgKmd3YGu5f5pPeA8hoqDw73BVuv1VhqVwVCIsbRUgNt1eo/9PtmdsodPs/Vxo+MTU3iZgAQwDOafKMH3Vy5ZdF+mHgT1m/O5zPsx3FgNGG8TvAnFb/qRfiIihHLq/9CBkGzRbsVMD/yh46Utul9sfVoQgdLPqTzZqTuolacAroL41HophaozJp1O+tUVvHmIjIYmgxcqCCHC2AZWED1Yn9ibGos3eenfxH+i5Cdbn+1Mi7iNTqyKOjd0++0nwiI7tGb7NIfmXBSKbwG7EdzJs60YdTALjHIjLobZoTZlg8u3XlHkPvPcpMTqS8ge2TSv/NORWAXClaAgNhDRNiKcRJmUSSitD7lKOWKddWw22yoyaBTam5VWudkPQkc16mcY+f2lilHOeJCFnneJsLo8Ox8TgXwM75mfkr1K5ODgIIlgCZ+FOKqqlvAO3tFDq+lnAe4CkvI/YhJkd16FCpdMM5jErixG/Nsdis6nmE6GxldJIMoRiEYelLVp4rDYJIEM5lQcEXtEjOQMmOoGgpMJ08817Iw2jjomOgrU4RdXXUWDC55a0qrb+DzNBWxvw1Uiyol3cRJHW1yyRi1UQMcpaZpSrVkYjPCQPi/nJxQgFfjF2IlpFEtIh2qM3w3JlqYRgLwzbF5dF1iKElbqMNGh9LtYSkkcb4eoBFSKk7wKSCRml6K3QscoS2gUJmPOtPOCeTQEqw+ru5CLjdAKOtpO5+RKWPHmK4NwDdwUSKioQJPBdXG9yNpWYQAYDfwg5qnKD3LN6vrXbKPbrpWRMYuWkCCz1Lt4toWFy8Ke82g+eoSxDcV4gDJWkCRate/LjpFsjKMpGSozMgUVF3yl5uZTU72qUBjtuiWrKpskFq2nc1B/Qjr+mXnlh0Fi1KNC4F3nMM7tnAcnhdfIs5KxHJGaW0e3ZCw5HlW5MSPxzl/RpKG9fPZfwsHYC63i5jP0sQ1HABrd2ymUYcOOuiI/HfRoowd4gTM8IpPY7c9PIxKpMg6SVi93Xb56EokHHiARFzQ3fKDt+Lzel7GynAssqWbUbcgwRQcNtPQRbm5mWJsm2gXoZFAPGOOUP9CnZy6/aEDUKrHtR2xmPQDOMASGqV0ed2yOeCmrNr7eHn7kgyW6ZH9o+1xsK2H6qsJGAaHrqIgrW/Gs6H0GIOCyC4uQ/DirfaqZMuJBXnzz5HO5qd9bntlOeVxWZnnPUlkynXcKGmNRq2EgrfLKujsmhdZ/wV8iICuV9tp18WyuU1DNuls+UYgwjEzBjN05KeU6vBIWjYnl1Bt0xqrM7UaPbvy5d2v3HP/9x/oWu7UbUvf83l91131A/d4fKSZXIDfXcTUytN2+7Sk7mAbQaczarubi+tNOHrwXqvP98WeJcb4TDcU9qozR6ttC1xDzWdVTxaIkiCsiCU5yCrq9nrueBc+3DxSrm276gYjn3GQ+vl+JvxyPey2ETjX/R/FbKs837Bm2JDCV6i5Plxg2j2gxd5ecfhr6mqB1lJoWJgDW+RGkaaFkTNsxaH+OASJl73j1Pa72vm9vjHWV9dCjcfIxQUC+aaGtcZHJzq6zvXjYGVx1U7dh41V+A3whnbSWCuDahAiAM7+m1WrNmxMO9GJvWj+dty2KLWftZX27Q4Cn2iLDyPge9mIjfRIakBir/KL2HZpYIMhbWCFl1HwYGXbjqSO476HCg6wKrJ2O/4RtyA/MJ+dVFpjYpLYgPhfKlrard3RLRj3Lv1aczRqflD7ZDIG22QGbGBNCRnFY54FHKc5yU26J5alYxJqM7xtVZ6fXF8C0WY5SzH99FnATSogbf7hRO7/g5zlsMWnTFAi78AAGJ9JxOJ8XbKyK0dGuou7XQWjYiiz3d0oBxaHdenEaGo5/+zVyEx1pft+iGFRs/9J/tXM/P3768uvhoyymrs9vXbB2KFiezd3ACdMAtwNIlHlQH8yTQF2g9GlNIgStEURVuRO4XLdyRyO+/AwraSOS6VQML57tswdnpsdo9WGlGNYZfoSAYHq4eK6c+7cWC2EpRdQXVyMHnpW+cCpOfgoH6+ND5oFBbp7evsygS44vsgBCHTEC4KANoAABO8sgvuLiIX4+qAQnsdZwdzD2PhLD3CYSy/3h3uK+22WjVwJzxp8hjuKN7iUJ2SUJ2Ow8A2fEavkYQArGHCf+2xAWmBGhjUzeXpxZb0DZ8BVcLgvhTPcn0PJWeiBOhvxtz8p67P2UxaceKGxUaHOVqZnP6fXy0P8W9YZGSoM/sRCj+iexsjatlZ4vHB+ooo0ONDJApKWN/fUEnkArq2RbXVhI+tEAAwWkMLq2lyce3h4Es19hhfqufPftSe4c0umOR7nlFAn4Gk6+AVzmDseq/9f8PFMz1KiXoHVSjlMKjQoyB8A2bR5+Zqqvbl8fL69e3pouaSip4JEbVD08gctmWS0mqJVLUvTyxUNgjsn1ejZnYLLFi5Pt5eDdmFzzNYCN4VQVWlzg0ZwU+xuhERRFdgNm1YhslWX5fByVYgtl6er0A3l5dCgqkrLKf6Ro2cSduNgGUuHgfOHxi+dWiO2PADtmq0glaFpaMts2OHTHRVow+zuhR3j8zbbc6JNMowbQk2kSt2gsdrSQrfgsLhCg1sOWGHZiWf+SvzEJ0Iw1T6RAIC4W3BWLKJL5OAB1jATPHYh1X0BL9Dv6gPsNfIEPsFhNyxR7tbPOfmv0cFi12eMLAYTLzozftzIFo/io1UeftI/wB+M3ov3GumEP8OfcVbD+Cs50VpDLYqaRhmlqf1rcRZCwHgE+Zc5k9mX3v9W/MNsntyzpNYMIj9jqe9nHm/8wDmwgM583JtN4UvwbxjD3kmGBOjFxISP5fEnoMT8lvJ9UCmzwTF3GP/Mczjzcifs/g4fA1u5H38kh3k2E5xrppmSLAyZVMyMTUu5BIoysqN/+cLCRqUL31cJ16Aq7ThmlP8azwMHFNe6lCp/ZwLtE28rxWxBLUaENEzVTQPYewOlkvlHbZLZbyYcIPau+LHiYNzcPz9e4vu+6QGvsySnvjR8uyUe3jKBCHkRXO2rLyFFNyAjl9qGMd+lA+L77/yMMqGz+dJ6/3QntpX6HAlwM0Lnt5cqa8DhecB4DuBuWPtkYCsKiqS4Z9khNBIaOH2V+wInq2gu484FyY/2+Q98KZVpm2ZSIWWJfSHU/qmVNAzgxALBduLcJ5LbZvpjSaw4/xktk7s2UFRKCzsEIKhvBQ6rGMbAMilITqB8laCgTFSY4klDKwNlwIkLlrbHfKqF8M7kv8M+y6/PVfLKWtQ+XPg1vqLTZb2eTtf1ErUF4NdGHKu4F0B4jfnqhhFXOE0TGQ1A+WP4DrDB53NwmQrqIY/i06HeL8yNAyiTxjGDyqrmi43vghxoCQVR0lTJD7d3/blIM19waGLFINbFMHl664Ig+YPaC8ZJ/ew5lFSiLg7cReoHOrdViM3OWAAEHTw1ubaWUFVrLOFtigMcS1fhoXBRSTDtAkTmIopSk3A/WHyBlVU+wj9QG7ORzHrg7uODj7xeky5BetOZlPIKot4Sx4URXnihOmSDvawtiCPNnycVQXgOJNuE8JBajFOlOt/9c3wXGOiTgF6UjZ2kUSAzsp2z/BxtDgtLCLCHnIEw9BPbnzECt05ALV1M6wML6FQ/t0Vm8P9hxchVJDDDp78+YxxUMi4t5iciDCtKAVTCUWJk8KR0AarGMoGamtCInd3F16YzB7vpraWAya4edGuXz6VquBch9S2mbYQsqWJgVd5i1mJ4IHCVWacdgCeIRkIHikKZjGhWq7ztYj9JOaQp53aNhhzVdqNVPcVS2gqzwQlBTmkeQFh4javc4Wu5DTi36E1LQKG8a1WwFtZiNWq+tPVSJ0CUe8dB8Vni+qbn8OxmDpCe6QgGEVohvmUu0jLCTDPYd4Gm1zVjmvdI+6snfnuLpOHUhnB3GgnShaYv1gy51d+/yOHg3Bri1hkguzqzuH9HVqubIT5b3Cx058x3zosbaYA+4zqZGSpkMS0klEQdkQAzxabr+i98BnjrPDcwFs+dWzgYl1uL+6erB6ch3s5PCz1zyq1ze5IG6E2ok8JoHeHRuM+UQ9Z5ix3j0T2sEQnjoJ+PVAoUQWq+eQG3io8Gux2SEZz1DOGpoHmIWhLlTo3VKOBd9BQKYuWhgsfIImRBfyMuZbhyPv2Fvf1ASxi7qRcr6rE2Aio+yjztQQtnm9z3YfTABAcbZ5wIEMTtHe3BuRakWM70dW6SpVclpa5oIhE7A2JSk4DkPhbfyQAfe9fIQEBmJXDnxo61H+rz0/SjeF72pp9v0AR1JHbxy85iu2W2G17oKUkELC7oMcBJ8uYGpAYMK4uUg8ZxG9Tt2MQvWLiNlYUcgbjHxKnt2nZNBbWmASQMP2NafojOs+JLGl9mXn7+Vht1o3bWw+N5F8N0XMjnJqMqJ8/qs+YMPjvztQG9WI9e/CZAoe2UNEMvWUztnf7rZbA7vNOvhiUYxM77oOGDu2FVe7TNF/StemaFJJB3aivHje9ajiHrrcjRh84tRjDSvs/6clTjU5RJTIktr3RE05IC3A2ApWGEliWyS+Qv1zzw59xUubfYQ5a1WQObjJBGP0iDCDT2bDGrQNPuE83BwaW2t2LN6T0TJPlvdg/ZLpZaqdKXFY/CrHo9s6LVwbYH/mHQeZRIojKMtouaLgrF2OgAgRNFIAXOjFCeftUpExmfmNBObTIhf80B5EI2EYqIi88zF+NqhdsOmFEZN8tgFbFNPTK3GAszjdV5Rqjmpz/DeTWNwkkDtJPsqiIqI73JmaQcycz3sVGQ+CWidwdGWQ41SqQ3YlRkbuFsl05yZO0SRSjIBlwW2GgZm0hFu5f74M3ktBx0EGDPCpGBLyeiYF3ixSmr1rfM9TWpceXB5gn+o/uOpocZO9Qd+X2QAA53yxaicpS6SlAgwN/7ARQi4j04CvKhMDhsuxU1ljFr6L8HEIhH2yGJPX3E9OXFPbZB4YxuGWd1nGAe4EWpoHWK0xwYvNa1e3/M5vXkppVqmmMmwKLm0Qgol+UR1C7O0tfQnkgXeAjxaBJ7B/RffEE7i5gneTnXS+LYktJMc57pbBPxuGsmq/IUFpnnd97O052MxEBn2IcqHFdXCUVLgFn5KOnIc6/3OJeSsc0qosDAkbm1JKptwglryHtEbBRmtXK1088S4F+2taQTB2xj4FbJxxhxYOAfG60oMaOJgu25ZxnDNoog1hwW+LDseNmrACY5i0TBuAk5h26GOuavV6GQP0RaLKqOhsXy82ffpZO9T8iJK4qq8Zr3MhoGFJ+bd+BLHawFIQzNZqQBaZC+IPu0kz6xp8TE/E+2mLRAmQw0duQdK7AMJ96phEoO9eduUpSsWSicwR17tBquej9AaU82JZ+ST13S0095EalAu97kca36n83UzUoAt3KUNbyT01qAEU4EtXi6TTKqf36ppeAEjYSkivp9CJ973w+J4CGlQQgtTu7atJShZc2AFlQUVpB0AoxO1pMpZcMcJL3UxoPOmjokyRIt9Z5VmDt7Ie80B5zbfiz6ZnTnZkL+pd3v8oFBnxXDb9ZCFlJLpwfKF+uwq4fODg95DsAzGd2WrUzxaup3Hny5WT/kBQDPVzgz2U7cV7/aO9uaBFkuUaqgGiokJK3JBS7K1YaDQBhmvzuQzO0HCQ/jO29WQK6oxM17IBXULgpv52Lbf1kJUC4H5tq5+LRTkttdrARZqpACJ1/aUncBYgDmVpWjeq2f7YdKzwEodt8LcoQ4xrdQM+UtwlThzD6wY6XY1nMJHzRxbT2BdnEgwdUOa751m7hpw4VYFHU10YOXiRkO7XZqykyrvXV9MEk7uJ6DbJ0Jo273cMHvtwEC9gB+CHCby/r38E28i09l4neR+ZIOR2wM6K+m7gd3NsbDSN/5pmIYbyz2k1YvJn0vBu0eyHjPCeO0WrZsTW85uOo7f/U8Bw7nuB/N9l09CJVs3QX0hgH7O87eug2AR0yiqVtW1hr9Epl3xOHCinhEpXR4vIORlOeFtGq/NQSJSzx4l4sdECDmdroAAQFTciSSKD5bVJY1MYdHI0QnkdAQWRgskQSDkXhKVqisfU3A8WUSBc3mvMQaT3nAjeJynaiRn+aIrRTmCm9BmD9BDxIoYiAgaxPs1DohCCMd7JGgkew/c4V3pE3OgR1Wb9svy2lwrlrVT6eJZfFtYNSLSbENWeq+mEUfRP87XR2uzl433vbbis9zV+qSXYRbxs5Mu0Ckx7c21l2/KRG0A3jXHiBH0FFv+xmtRF0yCq+Q0dmOuq3M72rpNVT/ujV3xxp4NfOAIMEM8tZIEyOFIqdMUgwyiCgCx5wjIk6PmaGgFvpNnS8hX2aKlozT9CNw5f688/TguPuCEeI1AIrbO0qD+RGYY/ZX0CZLGcCEr4n3GQfiDklFd9c+Cx2bDO07nYy9wjMD8B3zz4C2QHEzOnRZm4kXbjJ6/VXXe9UJP+kkZGzsB+AT8w97/5aUjlzSCknAP8voEHVuWnZGGmlAHZ53bAyucyGI1+Auy+RnyeCkGoQkOtAAyz4NZYo6V7n/3r6/7vLn5oMoGjiyTXRIyhC9ffKkRblMZob7OO9tox5V3t9cMD1cpCl6fQF3N2e9uXECUNMAtiMV2SHsCYUdohEXvlS1GMIqHG9flaKpgGgvLsTz+tKLzsvNer25dKLH2U2iXXfidf6PvLKDLxPiD2eX4WpGWrkQq1AFGuEiyquWC3OFh0xHmpeSLXqeAkBGN+lzyNlIgVVKbWKXDIiKbA0NvIjMYvA/tVh8/s5REBWxSRfXf/0Cikrrn7yHbNVicZrxpf8slEM/Hatn/gwrZWm6eGZsjJO2t6QkV5d5OLaUg8OLCtzC+0ZavRIZ7qCrTjR6nDPzH+5cWYm7fR3NG7aTV/BZmi3fBCm7lTM+KLfhuilCebPDFebR+VW3qzTXdwHTc8Nw480RweJ5hZpyvDuc0jtn3xatV/9VC/SfmY09rV3DqnZIhiqFOrVbAoHBZXbzXmYAzgvsmG25tRJGzAr9+yyIWLA9CosEZmKGguR6EhMg1aDqx8+FXsZ9mHCE79I+e4YKBs8/iP63wQRjLvvdTeyPyfVhKVSq6MKLOiCiTye1CBehKD5KNnnazuB3VqIPADi+yn3iM5Mh4mbMZkHU9RHqTpfQGx57FCMXPJjtwu9lF4PIFt3C1m3fHY9ZFE42BA+muqFEwuWbPoAJ1ejauSFMPf9qFJobkKkPgEMrZ00zNoSoL1YN/Srcoa6AW0FmJ94yDSKKBBgxoqj4ASNCpHh4+3y5uOl7WfdGCEc7uRVuUm7MxFVrAgdEx2seVSuxhlG0XgjKMJbJLSYARCImiB9fXfLu3PXhs7wXF0GSBEtoY082z1ATMnjtVLf+3iEVhBANxQC4cdEqJ0/HQ1FWqehbHkV8DnUtQra7bqovh3d5LL0LwRRLqCmb33kxDSFeRywyEmcHnQH3Wl2XBhsvc4Z71DyuuvV/qjCFCP55R850+8T/WE8Pnr3Prxv85E0fxINrWs3a9g3t6QODdnvwwJTBvX+/KrT3ysvwgOb2G95u3PVqf9fq0nq9uvnwsITsYDZudoay58WSrnon0r/BXVWrxYo2IPHRetCexkGWNfIsngj5rlQ8pSXGcf/n3R0zUC2iHvG3kT03cPkYgnAFBLAw/DbmyzUgAL7LlV54kONiC0Cgllp1KYOZgh5LU0+dHNP64MCrsFKNlBrcuLpS4eC42lD7Tm28uk9q3OsiwPEJzgf4JUQrIHSlj/RZ3eW0HAofmy5r+UY6CG2uj8EIQwWT0QCllMIlVaBISZ9wBGE59ty1aIjZcZJmcmVpkqBV7VngXllIRfEoRLtQr1xNQAI3TtZKtkdoU+uMQF3x89laQJgBq7m9J2CEHtwroIY1mpHzTIbJUllOnscpS3gSidgwgHuc8JFFMNMXxDnBJ6Y/iYmOEWNNwzo103FErU0wjFZq1QYk5L0v0v9sOutfj/sXhjQDmt+3fAFI6f2D50BJa63kihUFU2sxlY0JVpHp1zJNFVFJdGWtWMxVSFQAa9USAEQGUpm51iKAoligI0vnDV292HpEVUZW2FpJSSQLBVakhKwO5LqVANnVEed6Zf7US9bhYGwUcFpl1Tqc/rN+4idy81m5iMwCGRG2k1iVeFSrWpUgbWoFjEgKiBmVGZnrgEAlHzq5mhODwgqV+eCgdumCdxFxYYF4rBIYY4LI4beS+NGSsFqt9VoWrKEBsJ/EhWoBVVwFs8SqzJLWLe+rleAF3rlVKliDit5b3aDI3AxWF1lZyurkmBdqKrQAtbhKAgD8zFxrlsBKVc3kApBYPXoQGqSq1EgS+dS0m+v1ESTqsSOk630hgNsyn2BfVNUWVLa4tvbyN1qoJXGd0FiqSFpgWWJaVmBFELAKCzOA1LEeRVZBgFYM0VcZy+gjGJK18NYu8AkRyjJ+TWhkooph9EsOr8GIzGoLhwBuI6NBhdAmrUNtxOYl0LliKwyVvdRqyS3sZKdYFxYrCv7XU/VMKgUm4klaus8ZQFNjZtEc0Cf5FZWJnaGeVRFxc66zW6zJAzbXagvwWJXoYyRBI2ca0SRWwlCrFVBvpBLxF8omgIyA+IEb+1Zh6q0VRkMkoOUKAu7LDDEq4EMjUblLo4SfUQ5rqpEUSmTUUXkA7GT9afFWAh2OpnumgTKRJl2iUvA4/YwwNsvIiny0EZA8yBLaMWAZV/BIIA0hHV3VLWMG/pkwBKNWqFaTxEELSR7ta8UD+ehF/AC0YVjAGuYB2QAMhVyK/axCAJDPUIHjitcFZy4yWiqgHrgnFgIIvZ4tcKsHLENJ8eCLwM+glzrgAtq6X6mFTsUlIyPIArmAZgGhSpvhO0rF+VmAM/VTyJaQ6aMrJusnyp1TIx7PyfIOKmGifh4KlRT7KggUtJYyYhV4Mxy8dRS1DHgWVy6kWlBLNkxkBm5zCK1IPHrpL6vwZTnI6xW2r+OqeINtFS36FmGnSMvJl002zhLrxAK6nv8t0S2lzlWVtb1LQ8eDqKm0JpunnFWhg5fDuFx2xk3b+14p/acpFO4ida0WnjESEOc5TaHS5aJyXXZfdTgqL/laJ1gVLXC6WgDHU8RjEaaCDySH81Cl+lAkgTtbyG5rRZF01p5NTruker0DAbR1d45s+SRFPax/5klb+cADOix26KiUrfyzwHf2RKX3IAl8JcOGz2eJfnBK5yFSJHIrC93jsBHZYKdF5hboo6Mc92LxJ10FfqXyXLQMYdFclivTwWEqb2XU3zmgujrWT/388+TP05NTNUI80MKDvW2lUmC/WlFxqkaZiR5LlBWPeiL15GM9UJlYAayqvVjlaAU1KkR6KWTRA2qHgQ3QUkjwFbMp208OnMhDXWM9FWCBzByAknIesAoA22v9qTOOJ2nUGAeqdPhoOCANjlpJwIjA5Qw0gUl/FKkBPocALwzuj1DLf/SzSmgZpFMg//mnFHBVBwarsaWqD6ilyncMgm/C2EyOq1d86ijMu1gMVCpLTuhrVq0MkN9TSSWEFvXGIii7XHCizWT5qmUKFy1kgMpIvFxyo2pi8AVfdPos0Ypjga10okz6EoQqq0oGAFiZ2KXvFLOUeU672q+qoDgM4IP0xarf+dH1vqlqiUzWubYWYrdv/fyUJbmQXrnH+p4NcMwpZ9i46ZX9PxEVUXyUZRykgo87lBHTfU2lVc2Ybyv1qw4eU+t8uGCuAx3ZsW7STJTvo4vXtA8Xf7fOER2Of6iQw07p8vHPkFvdtvnF3ypZAmfvzhNJqC2CIvzCBfCTpCoxBHUZZf+joF98Jnt963U7aaAfRKU00mhuFzKkbZpl2WcXkcnaV1g8Ah+5NH5iMPDvcRWVQwm06rfjtrVCcxl1lcU5K9ZAeSeyc00VVLA1Mx9OeUtn8P0qeuYDKEKHxXP74RcXvSIW9WSSGTuDXqZ6BQPZV2mgVTtrW3nbokmKRxFZ2klJtzVSvL3xuShYtdzNRrCYY5Qltiwky4wmnZIj1mm29Uzd+Ui1Yzn2Mhg1s0oXVa/+BlH5k8zu9UzUFzOjHvNdMRqSg/aK+EXnyp0EiUCpdYnKZV2NQfTWVU1qqjJWFGJDwkupQp47/eyGayxjfGuDkHJvUt01mXEU/Ah8q5w3dFKxCFoUePIR13d32U0xuHNJhef++0MQeEEo+JUjAR6U2hBL49bLC3DbCgJdjTsBAwbfI2qx7ChKttsS15TSdGTX0QJbJaEAmIEeGEUr1KRpeTM6BnXn4udBGlbfOEAQeyhgdBTaWVl7dkNVpkUMlfbPJkKgYfOYWzF7XxSd9yrtosAJi46J1lLNOGcq63xoeVuIcGgQZyESTdY/xBBqCOhEu+9EoJhHiYUOIQa0ms84AzTKftUiIxOAWpRuCOBrFo4tFoBQr5s+mm5bnarbt84+zLMlakVmwIC1WVY9LKEsd6qB+r8iAboAqPJZuEY9gVrV2qfRmwrELGJDZy3om3LdM1btMSGZKvbxwqOLa6YRQ2ElE2oREg0AxIuyyir5rCktQMydcKOAJG1h7V6KCCeWvwK6PIIBdmxE96DkXYK9BV8dwdSlbL0VEwkkuOCE4bW4UGE5hsFrfjN42oSBgce09ftRJZhjzSVMmpGtRiHWih1dRavTkmyPMO6ZSXjC/Wo3cp6lbkeJhgJA5994RT0AAGKEIKigEmw9BBxXzha8cpHWUkE97EPDoESzN1B0FZCPgplDO1Q3QChL9JXFK0QYWYhaJsCOKFpQFTJ8z8Ei6DTTKsw6ie4u15YBA0RlxCCVQqF5FYymFQF+cVr1i1pV4cDPIIufu4riSzaiEQuFKxZbnip1G4uzohwoxoGaRZMQkwgx7rLgqf1ewJhW1zkPYLdz3pZIG5lgn7Q7Fp9KljpSGojsqsiwK78e2RgczrSjU+QcJqd8tn0zRawz6nByAB+h7DGol9Q8aWeq7K60p8sq7IQBeunurNvypSw/zLO3RAMdpaX5K+n/Wd0BoN/UDujbRd54v9fD23mImwTliQJPC9v0hFxwsCVqTtH9BCSaEJmAUQHQ1SJVBPKSyTmuMHYqgdbOqWHr53bXL9Qpt/vTxMk+jwlglrBdNSL42ZspIosO6e+8QJQA/3QlGV4j0hXWYh7yj9gALX7RfJXrS4LnMf3leaq5Hi9qlCrHKUcAzVDDR/xFWzxMKzVqa13n3ecu9iYcV4ESDQMwnJmNLjTRxa5aWD91jysicSlwbkrvIMflTC5IolnmRqj9AadMbtq5WeO9ROrFZ+/zIXm7gOICgQzoAhxMqQoHXFW/SBZ6aVQ/gD7AlgVhPywXHbS0G2WSZFXSGqgSYVNRBGgudKkEHcIL7igTqSQLEuvWYONBjPEMUxf8xFRRSarVCmUKYjR/WBLNVRVKWMsEQpNd3UHFq9dAkGw1onI2n5pMV2Qcobm7ilNGsRu5suppSTSvdQhVJa5TJfuIYx8yiUBQ4jXSlmTDIP+RgkSDqgrKR2Gd1Ux384ufehX8w3PsE8nWWQQpIq0u4OVR7s2WaLbx0UVr+3AhshGqPDzySJINIArRcR4V+iKLymSYksUIUPFfjlIuBYNxb9mQhRJnKNdyd3W3VyCluTAzZDjZLeIehyoXVM005OVgw9c0zTGbmOAjBYUEITMlEJVoUA6JAOe0yLSPlJTdIV4jZyVaqGReI3lvRIQmUzFTZnUlyHmd7l7T8DmMH8sD2E+UaM4E5WmgbY1btzdjBMFsbl/tuu1HYklDDHt2t9VkoMr13uOCZLFqn6mb6ZrcJh37D8RmcmjoisQVRKfWD8GMftiKNTbMojjUTFi0sCCYuFnQVVVKaareQpmCkmSEbqAOmXGk2hLC4jSy3KwIUWQwtckz2B3iGqg3xQGQSUD/SlIrFsstUKglxUtheNlK4kKhRhN+yUqKp3+VKQn2QmFLuj1gl0Rz3WFxS2YyCQVyxZuI6s5F8vAqMy8oNWoaus01AjEMjpu0RzB3qDVsRo5hkyG26WRBvZxVMzQLEEaJE+zutbeIduEHt6mRF6W1jwxuQt7Pq9BFsFN1fQrVwHtrdY/ty3TQB4O/pr4HcKoS4L2bqovCGlpIAWbJgHVnZS+sRvJxTU1MBfn7WWKYS04QonZZaMGdhquNBMkrO3ENytIhBUqgReE+5OLDKixSwomqItFYpVMEIVMYWmGpY9SUGJ+sgk6yqm9Vfai+ZVUSbmE4h8LDl9KMal/Ck//5mHzoOhIslOybX2JHtjtWFby9SDdUMItQLUhBoplR8Va20EnGoN6nnORSI3RR7KdL5XorxS2Lowl1F5LJB0o8uKOYJmCNO0JR21wgsGXijkcNG9JyNQwJZS6TqWjagRjXUmquq2qBww2we403s/cXd4IGLJ4h9VoN13TBdCY1hF9u1nJVixypWsIYZZui+CnwTouFzMeeNhrc0m29OPD8REvslFvNHY5iR+GzUn19VLCZVqpioiCwIJpZ492CaFeVaNr47sjAGpYMwN8E/octXt5J3lj8TCw1tgcMDDp6oWKlg66bAbBS2eQ0SUUCngVIJPcrUQgWLEWL8yfLRD5jG0Td4syAX9WCJEnuTkaDOVgsDqZXJwg+s5hGklXGWOVtM56RoXV7ISGBArEgFD/YhoOzImHS6Vfw4VnmGJkMW7UmjXRvqmDy0dDmLcrHDoaFaPQK6novLthRWF6DmTXPmnnvZyuAn+0WpUehwuwCTExQzJEk3AEmo+AZxAmkEFjncRZzA+SGvrUDwA3CuSPZWlxxoxhBexvVJ6m61e4N2F377EGrcBIF6AC7sz2WL93uh43ukWgOEDqQ+ZK6xkyxNx/VCT6Ae+ctQaK58X3fRPgmD5EOy+WNAk8L28yEXHCwj47M2yQfl9iwXFUqKvArZDl7qUmLdovqAIfDRE8sdW59e8TGjvUDieZUYMocsZnpSlPKGXuDezdVunm6KlTi7fQ1eLp4laISk7QOMq8SylIMJKKy5B+xAVqQQIISTUTvL62kjJESZJs5LncE0Aq1RBtMbKgusgEPcQB/etDd8K0yqDQGcMKnI6AHG1Mwy3ywgRmJhjA61Pbeui6kbB4emURsSDo4//wzlxpkg1pgNRxdfsq1ONlrCEdzmpRWXHd/p/lJZ8y7qBO24QqlfU8AYbyysFHHnCsoyGAdMEvRgjAWwH92kmiA2JCFwRaAh1pGL3Z3eGs3msviXGSrnMRrrOj8TitsSqtC7bsBuvJcZRRdIq2suSeqxoWDUg5rZGw5KK1VpzJzJ2Ozmqr7VFHdccCTD0o070bSeJh7uo+QTyeAcYRoczhlFLvtRlZdMiDRPJ2ohfErE86B6mW3jzj2Te5EWR/wWjduJTUK8hETLIB6cFiF8FFYZ7X3zPDLs9vNAf/w3u5Ty9ZZBEGk1QX8z7sBiYbpbtXvval3Foq8sM2qsEcjkuQiPzODQpkS118lPj6Bm5ayBRXNhKG9swoZDCLM85NttkUZtihidK/wZYPXbvhrvK3JF3fL+6fEV80wWO4epFCUaGhpS7mOwzjWIbPUs4xqkWhuQzk4ZSCAeI3aK9FCxSeycVv5bVdWSTQ7SLfX6S42efcqLkprhvs8MgXVHWLc3j3G53gPZrRapx/HX8YjsWg2FKpnpnHBkFi5drFFInDt0VR7r2ehvrxr4HH/jSsi1I/NyqyQrai4gku5tGOp6Xek0mqzJbTP7SMqK11BQUwxArEpKSuJBpCRtsVu50GR3vNMbKIpc3SBtfdERdhqTECoOqxHiDC2usS2+xzeqrUscDGTrLXqG8teWm34yJ1447q5ECwh2uxpZWfVOQfWv4OG1uuTVT7pJ4goZPp3UoH7niSuGAyjxTL+kJ+bt2r6/Gr9J01yrBvWLASSGUI+PIy1KqZyT1cdZu5prdPwdBCrqHPOrloR1tR4wqI6pN3scFY1HesytjgkB7ofA9nnDm/YlYx3zEnQD/S+VgpBD+PWjAmf+2fSFcUiTW0GhYJTM2p6pKKOQuH0Qt2Pj6oK1sHAuDlbe8TZcUF26Ug03hetkZXgBbYR3ZNsRUawzpDHUi3fnKYlQsiw6vaSrbxoOTzKwkF2lHCCqokCQCGqe/dWuW2NlPIgi+cCmQlaFO7BwVIJsV82GKJ1dkfMWqzlhZmjkoESuElkhUP8SJ7EgWgPllpKBXrEt1o+1NgSSXdCCbkzH0TKdioP04zW417IffvfnYeSUgi75OgvfkcIgd3qO1dfP8VIJrtFQUKRVYxC/O7M5ls0I1qnCP+xZ4/lJKK0Zil03eJoQoUWx0W7ykmFNMpfqXS39bkrmjT2h1oaIAx85grtvUnJ7eZAtlpbFO9AtJmRlDZAY4vSOVcYpu0AEDUBREn4NuytdOZbLLfPr4Ft67Sx3TxNTOvz+LMtPpkWWPW4R6cNm7vu9osDz8O2p9zejt1iy7GjmAXUvipkRZgJna8hc1rae5o4c3fTEkmlRLNOmay0QsnddGyMZwJh9/9EF5C3qmSJe1Szw155hNbdBfmwLR1KKVVMCds8+1DwoMXf6op6PelQ2reoFrrSggWoDSMWOFumW6OlzCj6ARcrRn4SfrDlIp5UPQaFv5+/fpJb5PZuivhM3+fIuu8huzJPO8rPTe0STBaPM9JrLlV609lTNs0kq7vjmE6JLP9zyuRPsh/Z4i8MFLBIPnp9BpLg5AAyhHCEKT6Kf7CNTOcdSzi25mHd9qYnxU2eZjEDE3aKGWPYeLlzK6hK0+benRJYMV/RZm7uOFfbTr8uFKwIRsfhOdbvq/qetTzJdXtbJrv556nwY3D9ipMnZdXIneydMBlTM/t0g66S6yxCddlYXT6ebbfdfpzVNRmddHKkx60Uaau4/Saqd1F1q72XtLvdb4lbhSdxgg64O7uP5cvevR+WfXAcEfXQAx3IfCVV85xi7/zpUac/gHuvaJuPJ5n8fh2Z+PhOHSIdlqtvFHha2OZMyAUH++is+mZIT1kbuowqlYafrtJtE+aDspchluZa58iSBhQCz3geb8aiRHPVjvrkqdZpoTlnI6V2P7XvVnQMH9LLibeuxbW29fXE8BOPhHXYenHlg4TvPk2ywl2qbXBhNscDn96ALCT0KiHzrnwv0/ZDP6/imeymu6Fu94xZAwTQj81RUYOP2+Rs8XVvhn/ebA59MmTsTKkDe0yqHKdtbnAfu7u3uDeX8C2hreE9u+eLpLDOAZ9LHgt1uady//mRaKDjNZsU+5m7/JSxqFIJunWF0VvxcX2JyQ9NzLtYLLwlBFUlRaLaglC3mv8oPSXItQz1WVGQKFSYOlWALQtKAxU05iRkiI6BKbaIM/xsBdiGS4UAoTmkgfZNbcKTIju/U91oQyhMHzVqcKM4TvqSLrJJ6/S/uhtZ5VLbeUTZZLSNXgtYSxXdsVYfEeNlZHWngUqwqmOZtk+fyP4zsuqdyXw6kYwjNJ9Dcsoodrc3s+pCkwVhipO1MD6qSlz3AQkdcexXeUeyfshr3bi13TjJR06wAOrJYRXRR2GdVd1zDr88+2ZzwL/xPZ5VXd2zCFJEWl3A8f+92zRvRWQc7855ZbKmDkGYwu32aY/0FDgshs1/DxO1RlLVriVamWylVyQkS1HolOv02AGf0vfm7FbcLT0Pr4+ecwZityfnql02XW3v7jyrslpBsM/f+FMrDG7vDifjJiQaWsJvcjh0OwN2f2tEPWHgmswAUXZOHlXRLTc9AezZuNh7D4HR+AaVAo79yaxGnAkEeyvNj63a63QXt/a+R+KJXLBuvD+DmWbXJ51ndt85Y7ROt1rb25+EWt/kI7FoNRTeFl5ptyxWizU271DdgwXXvfHsdV991qLLu+TKyHJ1MjLRzhel0LDos45rucnuKPHMaCy2r6SsbEg0RAOMo1sUUhyQ9G/KnGlDgJWqpsYZ6pxJ9JndfGz0qDDbBrOtJpOae/lmRLSoJSZdF/WrJw21YhdDyJAodVfq3stOCYZ7YHQTg8kc5czlCCCaITXOGIjsoyh0jqidrnKZhlWrqCBACpRaHsZGYo3aHdHiZ8/YnTvzrw753ntw7e6d7jOcFtHAhByTDEp8S/YZpc2mFW8bNmTzaEZ9elqmJUf1fZHyi4Q4Yd4CbFh7GxviFZgLJ+s9YvjOgsbIhXCDsz9s1A8fOVf5Dq2oCECGVhJ37HMs4g/erw5Ha5yGjnjpxkn76bJ9yYcTPedORlQxV58QY3aQmaBFcVWBbl4thwyTMQuQaPRFCzRhKLH3DesOvY07bANddvStow/zbIl6MRINqTZyut8Nbbx9jQ6Z2aFJE9snfQa7x3szzAcTjbEO34RqjfxzKshP5dXyOeWIytmJDHNoCvHn1Ed6QSkQBypXpQTRqLJpwpJnsurFBihs+bRQcIUg6HExW8nEtSuNgJWqjmopBUuH3/vG6l32QaQVtUsEWp4SlwFFIGTY6XPcbp4e3RH2BK/p7/H4Sg0E7BUqIsq0fpPyDTjd0TNRi50tJ/GaS0Q4YmhuyqVOGJvNs1+BCaGjikQYyzIHySKUt8p3yhVJMSQ6rpoteOUiraWCJdH83KQh5OrNyQEiiXvR9pUdgVIcAJQfWEWzfA5BohLwLMCNtZLwiHFiGwdvgNQqHUvHZwj56pOH7wMJ7LLNX+lIFZWx9Jb1IRSdfqHw0SAkJ2iRadFYcLMiIeUCBUOgIIiP4l8sZ40Q6PRraZvU+I5+sa0deWdXDGDvzU7ruNzE5b2XA37v67rEy2z1zcyUb97rtHB5OXmU27eIZlYoAxB6b/X2DgOc2SCcjirc2XZT5zeRPY2KvZ21H5j5dKJ49Y5OoCepVeTO1bNn+1cJqEEHwO0jcu9v0ffvnn0zMN13/PN9yotDlM0d8WsdwtD9GzAb7I+QwC9YW9djFr7INA+xelnrjAGZlMkkZLpdDwnX+K4mpFPFc/euc/GqOWRVu/cwldx+w5xXtKdGn1wDirGlBWrGzugOSd26U16ttQc/Siyw2cXKSP4RG6AFCb7yXc39e03v126J5syzu9Uz9EzfNuFZd6hNI51muzczjjTH+qj55M0+JW8HKkEnS/lOpM5xdKjTOjNHKs7gHrKQ9Xgfd29H2zwPQCD3pv2Se9I/Ek1QR9YCKy7u2nAFL3klK9e7V379wM0ePEyZxbyLxQIhDm45Hknc9tZot6yBPc+2zKUh0WQpCwXgbLNtWdB2YW/WsiC3c0AOU6gjfLC6wzsmgCiAwzEaCgp3b5kO3cpRlZodSzzsyrjHQ0v6nB6AJNK6OjlD0LcfRtp3Jf2i6SZxYjrxj4PVTFd3Gl0QVujddPeda8wM+nUEkXEEzb1wGxTPXsK7d/a8dnMqN52DQEcc+0tmIhCUeI207e6mk7wo0aCqkstHYZ1Vd9blF/+tV8F/93t7DjGURZAi0uoC/h0kmp8Ghh7eDCeAu/1KTyva7qYeRSeYEGln1z87ezzb0ysg0U4YbBrACgbpuXOO5ozPQ/r/Im0T9+4VEDzU3MJg5l3M+Zo3fh9i9g+JcrPB+3R73CRONWqL/tY2qbOpPzbeJpBYiERzlcNZ5YwY1cizD97FwBb5QAt4RdfcfwhDEvuej1PiKO/31s/FQTJdaVS1Gl+57j7zZo05ujMenz79TWr0q3waiiCjJXxUh/QkxsSLl3zTJTfJxtvLGvXByTHxz1P3zIR1jpratACveVwUX0SPOJNl3r29LU2/4WatQcq00r5KXdtm5QRJPWmqsI9giB3OgEAyCAr3bjW11lM2nHkL2MfMnFbRMqP327zJjjGJ8b/wzkd6m6+ZopXIVSRTZowH7Jn0t3rRCbPCvhFZflKYpZ3t3IJUrozP6RtwbxvmgPgFbjul2xhDi1okhkqG41QEXB0eQooQa2zw0hmte7bjZW5JNGNvV/YScHHtXadPtuVJ993aY0neO2FOqJfMP0A3TWmflHU0bOVnW3jaiehY7e2+s6eNI233uy3ZJ7RaU0SRQE0mzed4pHXZVo19io/GXcXnVolG7FruVZkYyDwmk6BprmPbuevcJr6JkrazIoS7LXMvrTZFGsRcojmciRe0SNNNjziegjk+XUxMcsORV2eGC+GWfqdQLq28Ap+AFgVlnoSq+2qoxG8ZdKYeP7KWW6VT4nq8ZAqTpqPnvAf4J/Upv4GEMrz031Pn+JbpQ86WSKUuu2y5W8kS4Tlq29WMuuOekPTfzrYfEuFJcPaaEqdvphnsHvIqe/FaWSrtscybHyCpoADz791JfTugjNRlyaX5k8vx6AaMv/eiE0IQi4QqWAE3sHCf2UoT0AOJgTvkPZzgoelhw3E0lYr4K9zeO9O1xzzu1LMlmgGKZGwmMzj+dsP+crDA0yeYiqbu4702PdOu/82JTd5pZ8Lq+G3ttCJ77v/cgd+qMQQ8PggtE88xPv0R1RTuFDfH5t3WuB07WqJM9G4RYeI898z2HHXvGfGenVil7kOVRKMtPo9FIlGpKgvQaAIYgheI0UT5FPdTjwsdLO1eGbRaoQyzIYPO8nRTmFbhPMA+pETjYDa97pc4ybjHhFo18JVGSLRuR5YfZHESlVWJepeG3Vb3BLEJi78r7tuKJgUKyl9CQCA3qGKZHLudmQLcdOltG0xjE/GoCYZZKcecVCXRqGK4qEtFo0hEK6Oqa5lZSCUgPor/qqVRuoutXHKzRmeytxyPOuczXzL4aOhzlZl2t3LtVh2dOGfz1CB+XTiECMWO17vtrwX+vO87JK1Pqm0ixuqco58H41/xWlu0MXKn5ymYjOVZ93u/elVaZ/EyPt5YffzybPts75ZoNiFGrzk54Xvb0roOyP4RqK8t0WntZ7Pb3b2/u1gqfBMU6EC7s+e1fLnPPg/z/JpEAx3IfLB2egPZe7/GGhAPilv6ZISiS5O/v0dmPd43HSIZ+pZ/osDTwjbvhFxwsKVqfhb2czTTac1iW6I5mgyhaYaKNtEdjNPF4wdpYdSgPr7tpcTPLL0z/RK1F7lSqcdv2PdTdMa3v1IsfMfTIZFg7fTJ6kkPTCfwD5O4pKgdb05sPNy9AVqyL7pf+e5T3f3nikSTjnyW7vH2Zo73PmPyHrlmr9nu6d0Th/YV2zf5jdiZ2/tcbXXeLQIA5L3eRsWvLrnO3RKVeyHvlvC1f/cwvC7ELRj3mARj1jI5Rjf27pm/ZgKwcvMkAE8OPFzteCWR6zORv66eGA0BcTvaFzurpCgb3r77cXREzkZzI4HeLlBA08Y1tnos2+eFPBg8TNMiMKDdDAh2gwLcgh2Eoeg5RA0wNvuc2qD1l1SnNtSd9nLf2zI2GGns6jZ5N3kb6J6pN9zdUu4ZTgQQYeSejOCLVd1BDEZAdc2bPZ2rfaqUTyeJcYTmt9k5ZRS7T0pZ1XfMHz30jngtpVDltdHBtkB0xLF/yFwEghKvkbbd3XSR35CP/x0Jh1WKfRTWWe1dVfzy4R9FJ8Pf/XmHhhjKIkgRaXUB51iRSTRMEarhU/SLB3bvu0j07IqPg0gJbhvOjjzJAFU94GXPWeIdSHTHdbBnGqxgEJtrdbTP9nlI/x8bH9TbFSuc3JW9uw/8FZw9VzMa6UkvWrYykFak7j7BroyGICaSPTVr+8jeqQrrkFnqSYO9+Yqd9O7jnv5zGs+5/CyRtyGxZeG2wb8SJnEQo9lhuzduQxcPeX/eGhel+01njga/FXrT9ked8P1yD2bcvv2rx9LfUmLTTlgz/q2uJoPcOXeU8kfujMPFwWcv26gPb07/78veRPutVxV3MGDEI/ZT1peYbe2daH2kPm3v+QJdqC3GdmtXd6byBelgtY5SlbXnXp8jlHFo9nYFSDV/1fnZObhfdeZ2e47B88Iz93iPfWbO98g9Z8Ru9XJVNyLwL2O8zB2RHU8UXh/BAXj3tfJqPl4KH/rdg7PzBrjfDDn7knVUqUrR06wxzXSZwvFnVjpnmq1N4S99ArcaaIxHkzbv2q1jmXgfWkXpYey0WGODr6Acvx2Ir8hpoKD7e0ZLNI3TF3e/yxVw7+z5KM5pu/ue7GFn2+xOq6/S1D43/8b09dY4f+9A7+nW9hs6vT+p0+M+ffb39ur5RbRhn0eiaJOd1vdF+lC7IebjUw3C72PToVHZ6aGqlcOrIc4egcZOR6L5vjiN2+5o64267NOJTPNTdEczbzT9+vHpsgSpRGbhBS3ipJFHRUPrOLSdLltM0unszE8H/PME4uY4aCY17xn4BB3Ref2ydeR8wCgnNbuP6Na9H3H2nsvUW5F+JVTuV2Tr7UF3X5aZryaAb6YP+pY1dV3c7napwjNprTLO3tVsL8Cj/+3pRyd6Om1G+/Q/XLb2fMZopT7C+Ra6TVe5fE67NUPagBPK/35mRfw5SWemLksuzXcig9Z1hiXTHL+pLk5CFawABICc+1vjNDGldveUSdp71tnBCOPrFpXIfrs+0D7z9KysUayWoXKZFPIJDmTZDHzOND93l5nu3j23N9WUR58OfFytS2l2K4/0Jvuj1CfVX4XuCd65//eUPbscNPj4tdBqb9n1zbsDI/OTuxqbI2IXVyt2tNQOKq8e17Sc/lE7u72i6e1U61ONrDac0i3RhJswDCgFYJSgk1YCDU2FOi7MFrxykdZSQT3sT/DUVLdEAyFXvd21B5kl1GfmG0uaRPchR9Ow/UA39LWKiQhITtYQxPCsNRB2pTRsZBBVMsXPQowG3zfVC/4w/LIVbf11fPIw3pp2HET1l2uhu14ApTI59qFlCnCrS2/bYJp1H8OTyiZMdoqQaJgUR2EoelJyE8D+5qUd1QFVDgQKDfFR/B+2yWzpYV3Md7LWvbP7zFcBb795mZ1idKP57UnDTTuf/13Uzr/dquts1xs9zlmcNhhf+w6kmek8+Ym97d9H/ufzelVJrF91YtvnnM6/kPPMM2V/bBt28xM79FrYZOz+hD0fC26X1/n40fiNmPmNy7Pt9px51Ea1AWHn4ehLi6uaJLcZaAPVdkGntdNLsbsRl2uBCjUhAB3I7myp5csoxsEy148j/qMDHtCBzEeqHpTWVE/p3Ud/1APunQ93kWhufF43ofhUPkQ6LEc7CjwtbNMTcsHBPhqINlaRI3A1E8lSjjOydqcqXYm2G3MpOmktGwPCePwFcMTKuZYDccdt42+8/lx+XZsKIs561Rzmhcyj29ubeUP13TTThXe7j9/DfOH1al5BXLnS7sTyHJY5EFHSV4IEMksR8ZpAKkBPGMNY8o/YAK2xlaRbvhtjfl0V1hO56Og1rjNmRt4gz1SqKgNSCZMCkya6ZzuwI2oz3npuIgTVjgoGwUAFMwInAlgGILCxHTuxpQ3sDYU/vY2IuryPM0vGRuBIn5NZKUmDeXv9Z/ixB2aD+Nu19toLWNYrSZCWk3UyX+PzPJ9/IkZMHiJo3sXihH1PQB9H1BeJV2Yt+kbiwlBTU0Q9CEJrPxBMlocsmKciHl4GaBnuRfL+uRrLyeEhOum+nEHG4qBz+MKKNYZV052d343VT/K6YMwGuHdGhkxmROrZybm65QLNZOY8eFg3YijT8/Va6/Xi2qWP18vnfI3NdDOKIKrNFas6Niwzt/bI/jOyUptFPp0iGEdo3juCU0axu9WRVRcUURCmsa3ejDgflrhuCJJ9xLGPDHBlLAJBiddI28xs0sizNHDxdXHCYRUtPgrrrNxVlV+efTCugn/4GcCJZOssghSRVhfwl4CWCIK6WXn56rsoy8Qavdv4ZozbWUb2p7KCHvEVH77RLG3aaJ9HFG2Px0hR3SoB3oEgohnXWjt7WgCV6hgd441azWjOBFXJRBxVaOvxsDJ3NyLwv3o/xugzRSEFBveE0uOZWN3IYoZXXfNuoucUfOTxZJVKCAXqGdHl15gNxoFz1OTGPVVRnglvIN8r0UJlWbit/G1jI84ZI9hbaX7stfqPp7vY5I1B8UQuaBQsz+CcGVqPVhxpvuUIXTgsCk2bHjCEL5VLYlkTkYj1VgPjMU2I1fQdu1Eglb881+3friO6Lz8/YOXydL60k2S2iL2HmWusseLqC0OSv8UshMoW4+5mJ6B8k7RlcgODmOQYMQ5Jnz4ZFUkbpneR6BYiATp6WVnrxF3Kuu821+ktCUQ2lvemmz0yd6koqd83nrXGEIMvzEmuMdaPoHxkmQRAjFtZhCb5WmFXnjGKDFKaa73vd4gGz8igD0EoFQDECIvZzFnODDgmXGSMz2R0J51RHusrI8faM+fMKWRk2nREoBWz4a5hemB5GGtWRLXquxhDOLs5Ng5sPleOvO/3vdYwE3ttbRPBMubd6CJAdhvTaSScNMRPXr6s9jaSGxUJe54iS2QUDrqpu7qYYLH1fqqZD0EsoJ0MFEmGhyK5NwuxAa4wyzkk1vOd82EhNPcat2nGhTzg7LhCdulI0DQPbzpXJcZhFlHGBWECTVtjwO9OMDpFboZLEHNPuIdhLwEEnpThURF4WEwfwBXLl0oMJ3qfO2lSxnLugPfMPpFlWEe0FYfNCoykfqkNT5AVpiidWs7zFgNq6sTe7zDvoG28nUxlFTOXHX3r6MM8WyKFZFC4BetawrOCOiklezZ49L89vJBgsp4Z1fY3HIjKY8YYcTf7vZOEwyYmughGpjuwFsYKk97fNUzwFcqw0U1OBKoczeWYQ1M+fteIP9wPhxLqGGfODbQnSojQiDSBVVrNKYtQ0Iy5042IrwemrZHy13hVTtJROUvZnMnhivt8/RWpCCYdqbXu6JXau4SDSu/8oCLumIjbkH+w7vlMM0aXOCzeojhSfKN6A61Y/PdU/nZjOpZfHhtahlizePgxYQZ82zMfOmQHDUUxdnQd2u9VDqrDI0wSHUf0itMeU2Hc2k3u50NC+IQ9eKh9mdOfcqX4BPIKUBbYPcyRssmrlV0AgpuFrI6tszhzq6DVCjzMxnEPnllYqqZE2zzgGfLTXVtIWeZte+8/LU+Fnnu0PTUb7xOGHj4hL/VR0NMASKxIrbJWLFzXU5lqBer13Gehv4n+6rSy9d/g73u5tnbJHZln2t7mDL7Zg2Gy+KtZKcDHOEXUEtc+E9RN50hvqmLREMEDK7+uzMkvFxYSjUxUELABbzNqU7KSY330/h/v0LWrKtgTrzUPJPwGp5tTvfluXX36UxINGFVDld9z8ehRO2//XVSdf2MxeAV8ccYMU9oZtK/9DmYrs/Mditxdb1/zt7n/7Ps2q3g9MKaABs5x6How/hV3uhNFH7mztiWYjMGZdN+vXk2ssxhcT22snnq5tt1R86XD5zojT04Oea8I1O7O7Y+BurtYp7VPr7C7jdm9HhXeiSboALuzxy2ftll0cN/+R3oND1IuHch8TnoQt2eect9zz8QL7p1vFr6az/1+lrBRiu+eDpEOy/lPFHha2OaekAsO9tHT/ceYvJpFZemMbjkpo5+DZ7TdmIvK/iYX6vJDgYnZLZFBrFrukYmnPmm8MP5e3bgGvBZwn93eUmuv3cZKOoZV1dZNUU7v9tES9ntYg2McuraGq1zGJekhm5IRLNlSZta7qQXAWEwaM0NgmSX/iA3gWinBV76rpX6O6UMjXTS27GpSyMaNki1qBZMtFEwWUzLRoF3Io+fUCZ/GrujWarWrkExk1xSQ7wrSJ0nwbnfhzbwBb7y9Kfzp3YR4fuAqVapF2CyqWljxqVallNwBJZpDbZ6WybZ51048wClzAPRT525cuS4N+/bgvRIHjAB8CgLzLhYX8J6An9mZY4a3XnsjotozNhId/RwloYwGCEOOR0kNGOAMpyJJIuwG6TbCQU3MNMzfJwMtr8h3Z4QSniMjR3R9P2bMvTMix7pNZ6BzAFmC7KACJ3hP5X0LGTJZgPTq5BzcHXC5VlrvK5MyrKWoMTLGyGVdpl2GOrgUltUdP6frfs2FqaQv6YZLNDO0aksT+XQCGEdodq/glFHsHljNqgtdURCmcadahPnKnZyDbYHoiGPvZBCBoMRrpK2kRpM8SwMXXz4mHFbx6qOwzqp3d+eXL/xYE8l/97PNhhjKIkgRaXUB51iRSTR35vHpnFemh56pEw6KGOpXc4VnxNdZY8CZpU2bllGp7NTHE9TUSs1UPgJibvA9NcKAuoJBZItyrLWhHUilWiWLuN3VnW8vkyGlGypVlprS7goidZ0ThoE9MDCRwaCNNZWT2OmYognG2bvtSnbaXGJTE4FE3pD08LjGpoFoaM7JW27pivLrYhy18ynHrIXKslSQzP+YnSNGjPEgkebHhp9vp7t4lLc3xxO5oFmwPINziuXf3niroauDo3hLU9Phw1+G1u3H9ZBY1iSK8C8PEz4+f03wzeKjlVX7fIX86d+uY7ovfz/5evk+48g5Xfn2x5zR32J4vsTHaKd+BdMvBo2tDxc+ZnQ4s+XDqemzi1FQLsmM9rCkFUvclZg2W6p4DA0RJLVefYlxz0Qg4+meorsFAFLWIY8TjDkb1EIeqTNG+z7drJn5yrUyfZj/R1i1vtyBoPLwp2hf0no5ZoZgm5KpRnb/jNmazTjJVwy5jTa0JROGiXU4Z1oZGbkSzdhMu9BjIoi70P8Rlvmdy71oDooyo810x8y09/KszUNIEZAArvNRohWfMB4fTbD5o3GkPmP008ecpfu8EY8StR+qj7WjxEzd9siCLJOQLKmEhMzjj1TebddK+17K2iJht4eOcQ81pUptPphLneubqfTMUyXmZkkIdpXu4N3wbilH2O1MCv59yXJ3y8jDm+cy40IecPYIUHTuhMnMfg4O0+7d9tqbWMzD5maMj0uKZ6lb/JO3W55WHTUrMdGikwoetfq/YvmAyVIxj8Gin94xXDKJae3I6Fl9zazIPsoY1ycFON9Y2qcV0aHK0gbL7QOPzJ1MEt8+QboDLhGTko6UMs9MOuXtvnX0ofOWrWRIuAXrWsKTkJTPmdOoZnvxDifCWBclVAqqsF1fk8ktT5qisXuc6ZY8Y8G5cuVRplCFyHRPc8z/Xrtr+50uNDtAJ55F54knOJwyDhfsv9dm3wpikVAFK0ClBGPz+93FNAF+ozVlwJysCOZUi0Hanhv/eHp6p5S2yq23fPQPDaUqu7VC1N1RvJ3V6HL/zCnYzmK9Os51l1kGEcbI0yEMVNg9vTE7zoPAcnq0R5U/RrjNkveh/7sCV+9dZiYv356VpZgQ13hjhVIhY1uILvr22LOV5tjxWu5UecwM0AJoBXCavaLp3V0JH9+J7hpFpycdjptpfXcRHf0j6yG5c7f+G5myXwPPr/e9bI5H1h+MZZZ0XD5b8MpFWksFMczGvUvqvzI8l100lUJH4+vzKWzSNwtV9SEJQKQ2c9eIdAhKp1k+9Ty6vpdz3fQarmh8vSb9IcPh1Kfjbip8v2S9Vj6S+aAbifin6hlDqoAMcGSerVbBpfWw1sKCoA+yKSUt0URPMIIApQTOAyYss2WtsUgDg1yDbq+x9BQf5QXY4dlM8NcDmFYIWzjFR/H/sI18/5yvIZ7EPJDWt42yG+wpyibD6LSiUBP20BPCeHlqlYdFm0zFnkVtV9Y3pqCBlleLR44ooOLZHgwmAAbjMdoY1pMT+bw/n4jW3h4LMFobxj8e1GHdcrOdR+biMpJsFnlwYDK2mBVGN+gq2zqLR/DTGqvVDrDtNgyHPiK1MRrZyeG4pI5diwi3n4HqsyQCTfus1uzusOcaLVQ4EmTQAe3OrmH5dIRFB5efP1IYJOACOpD5JOhB2+PkU/bneT8zH3Dv/ADak8Xct59L2CjFN5dDpMNy8hkFnha22RNywcGWXPMGzAf/jaOkOcNgJjdVBZO0UNeig0otzn29h9Fg8bQw6bNIynheW/nx5hLNVa3um+1iPFRAem0evaZjBKrWV1cU6cY7asXfA58BsOSo0iOqWYRaPXLB36caj1IlalDkOgwS7K4y9ohnV+lOxNoALVUJvn7rebBnvY69F3DQJRA4pgRKMKsyDOYOoqGMUPtSMHHFKxrHRTS70It5EA2y6OQEkkjPQVJEcRNFCDmOXtRbJDjGrDNdnZbwLREXT1wOVU0TuIJg4Lgpb0HhqgpRqMP09394O9+ALpYAUiVcYbfwsEBHrpDEK8mqF76lDz/wgwh4mFoW8y4WGcSGQ241pw9IS5Mz22zV2otYuIEKhWgJjagaiZDsjzAmc4PWlCUi9mZSMYJOUqnNbGnGLu8/V8wGqqSpalpJk4TUBJUQEwBaIe3WT15uquqxYwA3vTJebtcPA5FXdyS8BU6ykh8bm22rFJHZOAdTSF0qDKDqt28i55kCQ9O3U5kBgKumrO6cm0ldTmCnAoaNR/af3tWInC2fTmaMIzSP0RqnjKJ/gresumCtFYRp2LnegJ0PS1w3GMk+4tiXMhOBoMRrpC2AS+R8fYaGBVAnDquM5qOwzmqtMQa/PLvjEIT/7vOOeHQtiyBFpNVFyMFNntZgHwYgOMrmLDI0eABGqIbhOEY/ATweJpHhHg4t4pt6u7+JYq4GEwsxZcxy9Yw6PDgQtRaBznA7iG7depCFcZiqyHAVZdpjxBgYQ81Fud5NqDI/kTaouae2LCsaJmY9GBmhz1iOAMQErUaouZumuvnkII6RHQoydiyLaoJWugYRQIRzFOWWajEZ2Fl9Ra+rbBjOzSY7qMpTyMicnxHloaCC0YyV5sdArm+nu7jIu2/EEzmAF3HPpDAVabk60/awFcOlNg8zMe7oeIax8av7IbG87XBrInkfsysrkwwmWQDPIB7m9ZtWWetxzKu+cm2CDvmvenRIWjLGI1OF7G5NxAHGF5v2VFFnmp5K0YqQAPPUDRESGjVFNXAuSeh4C4CzcvpqZAQ0VJUjnF8iFhSjWVS+xIhkmlrqs3quc8YwdwFrSLU10BINE1fmpRp781UKwADJmcyZAiA/ldVLq6Gq0xMAnl4CPsUxNA2miGeZnUVe60mOxNpNG+qjWdktcE2OTs5L9u+Zx4mTNThsiotYmq9QNJBX0m9KeJR9opQqytq0vboTDpFYwkMFi8jRw1gAEsBVdwhh8xyBxwbwo7MQaNbee9UKiC29DBtJhXMm6AoOF46sHkm6IUmGFRJ7cSs0yTWSlAx2Uk7vV0BcRXzylAjY8nBRloWw59M79AaDS8ZqAPEEgFZ9NsgYcG6buUpTvIaQF9WPt55FBEPzgiOfWCv3iBxeHoE3oyNRfNgCenvE5SpEhTYTHLGQCmLoqyuDYmljk4mJR5ktoeoJRJoR0SxFTtLmUZGV49RRQptQBIgRRp+5PcQAelXBiR2sBi9jwHgLWrSEZteLp32SvIjRcEU3SmTOMPp73+FUEWFAXUiM8QzLHcYwnr5q84o/1lQQ2cO3jj503rKVepEmcnVHS3jsPGzNnGHVbC/Ao//twUFJqYK6Knk8JWvTunIuSv4E4tkBcA3i4CyicjA87zVTNEGMfn6/p/PrOZQTrlOOCdOZ47BwQTm03NLBNMflIcs1ocLg1XhlbKmAiGXThEtVNuKt0LkF1loj8Zkky5xFTIIlf8HMRVFrj/aXdP+oVhBaVC3MRMSbJBJdqpTX86nkHUKeJSY6xIFGVqy0JlgZDWSQmtXSIrpNsd1oecgOaVcPOBy/vYe91zQ0Vj3kJ1hKOK3IMe2aLtpYH3NMnZpmgB0mseMxz/TTzZAWtrBLm/imhnQXzDlc6OnXdDZcWDzUKdGM13m+Db2zJwgAMB8AzvytPsT91R69YRcY4ZuVEfO4ZLZgtUhrqSAe37jnBPpF2M607KBnXBTZoJapiuQ6AVLVzUBrppFTaLWqIV4NUtwsn2hIrK7v5eCbNbDtOL+R+0NO6/kos5TegOn9kuuPZz4qcusMBrdvDWtvVW0UanFmnk2qUinkKThPZ6uGpWdKr9CLQATzDXGLOnezlQjTGJHxfGPuK1m/fa+vcWGB4YKtb3wiDwc7PKQEfz3ACBvhFE7xUfyDbVKqROdd7obAJpDWN5i7OlfoDikxePgB4GalPWqe86opqrLz+WtRc/4dtI/mOsP4vHmmsxoBFb8uIbEiBq60eW/r96n++Pz8OSfz+RHTYMwr+OeppIfB9Ste5z5hqCN3cswTJmPGzHR3g67OWOdMqnrFZVcXH2DbbQ099D2gg9E+nRxgw4qrWlW5/TFR/bxkdlp7Xcx2d8Xr2jxVuBM7QQeyO3tvy6drWnRwy+tHCicNpIAOZL4KepD3Ljhl/3x9XicOuHd+mfGTxapff42xR3iFL9ZDpMNy+iMKPC1s85qQCw62nDVvFDgopVL4WwUXcIq7OYY2oYkNPgjqDx3byCmy+FxQVpLQWap6gS++znQm/P8oOHovMyNeNbC7x0It7knhGDX3Pq8JaumB1yCi34NAAtx6bMyPHIaDkuYjncP8/YKmpTqgKjDpwRwgCbVSsk5NQjpErQ3QmhrVVN3y3fS2z7GJ+ctzPFuIx4yai0UnjbAY3USWi5uZB9Ssq6oNApbItSC3yEonYyzpJxl+m4suaiL1zFXU81Lq7I8sksdkRSzIWkLy2RLywH+6w0z17ibd/KiHQ1sL6+5h6ubdIv7wh7fzDfkWhaisnHxv21yMBBa9sWEI6sDjcR/5+/v9/U8imHpJl6V5F4sCPzzGAapDcHypvgmqVjyYfPaqlBNE14mWWo+mZfuzUD8rBJPVklydNDMlRJWaUXQY9KNaTGXSMG9NFEubKjXzZlNunZQ0kaWGItIeICom12rRVEmWqhKbN6uMIU58Uy3oWsaimTmZJ1BUhfwJ4oKqe9kQaWXG5U7+eJgBdE3L8wNMBABkUK7ubEJwtlAADR5mO3bSj3Ja8zwjn073xMw4QvPezJwyiv4jOGfVhWAuCNPpddYbjPNhiesGJtlHHPulLEQgKPEaaWtml3ae12fGWAB15rDKZh+FdVbXtffml6vPhG3w/nM7n7V25XsWQYpIq4uQg5s4zLgPJ2Q8yp9ZdWmTQKOMtrDDHGkQX4OUQpe10GxRP6BhGQU1iLGFxtDuK1SdzWFcB8vc9vTyR4++t+8da0qfHTPcodFdHbz3Hnvb3t57ROjqw3j3cWfEEs5o9di/LT9rbYh+Phb6NNOuxlRCnuneTTwvGSy5cnc3CXRQT6J2kxsRsk44R0k+vCUUQdUj/R6zXTTnHC1UfCKfyjHz7zlbMjAY94Kk+QnQ+7G4Dpje52PxRA7kZacgGPtfSHsvyO4z7rG7UmAHnTFt2Xs+jn+tfkgs60t2Yf1az+lwcF0ZIjrfsecQRIz2zUa7rnQsUV99P3k51H/40RFpY810sq1HA62X+OOxnnW6XS2EV8+l+TkGhoosuxR6Vl4tZ5PK2Ugp8AVVLU2KO7Ez8uqAsTFCEPEEKNYZEIbA2tS82vM5clt7RE9/VIbCBmrbSynTcoSLXO7juuRVK+JSxjecZ6E+UH+7uAgR0R4jIlIVZiDgU4PSmtICGBpRqn48bw7NYoOMtD2muESESGZgcPDGwFAtWsRS0hcCSkq8hykpR2P9YWyp3qeVMoqLkRGcpTnriOV0qGAzB3oYGwoJ4KpXB6cpew19bBzY/NHYSq/retYKRFNHnb6yq2jPas8ho0OkdI4MI82AUGuWaKFWAsbMUEwJNsmfr67orsohG2NoPPvoMEHX4fcdU+2tolJLBqmyLFVVarFIMZd2oUekKxneE8zN9evLSlXFtBra9SxEXMgDzh5BTHE6EjTN+2Krgtu7usI2TYlL5ulzQUx7nybKY6k2aUz2dtvTqmENYx6tdJ9R6KgocII7SigTSgAxxuj73j7QoxQxLTvEeqRvgRmzqzMlmEzjz8NKZ8FBwpBlWUYCt3aojHEhZ6oRSc1z3oD2hSlr3dZMmc25l53O6ZvXh8CWJSknbdwW1h3CU+fhamaOMYSa7cU7nLWG6kEJZRqYcbj+3Ao4bOfcnOJ96LinqkpLlpTcXUXJjFqh1krV6c/Xe3f5fk+XjKnLdiLiyb1Ck8pDPaN0MC30FQPLPaHC4NX6mintQlcoZdOE4hiS0s7BzjIN1lpWfibZC7Myk2JXCJQe/1oGZX76EIlEWsGdm6e7qsZgCBJr1/px38Z9qv4ZBHzaOUHsLdSe2ySdHym7oqlS2syvcH12X7p1XAM0x9DOc/Wnz/Kv5w4lUTvUWwUKASl3Xf5aHUZirwhdtizvodLVY4DtJS9+uj1A4lt3GYFfCMfsqnvPDn7O1+4SqoDoSlJclD7njhj2wOKa+P6qaB5eWcsW91eX13gXj6w/yJir6bgwW/DKRVpLBesxCDLZZu2HLPdYQe2S4ul1fyu7yelCC5Sp1D+9dz5XrH5aT5IF7dwdiqA7OWasyiQiFss9FOG+VgxX+HE2C9fyWEEfFuv94vcIDv+1lbmhBanQT9LnGAo9Oc0TDjG1TZXaum7IVly8SZ9Yc3oNVuUkmtU83LPOf/BKjPX1I9gaa9EARkheh6GxnqGLUdaPfnBkOf56gDQNhJ/hEh/Fb9jGe5X5vMvdUNgE0vr2xm5zCR3BuyykSTQ5caObM+eRsps4n38tasq/55Auw6k8slJp5bSz5kOTGGLiTpdc15ozzH79+PbtwjP9/BoJwf49Fkpp8iN22yQ/ylXU5RhJyljbCMJkLDpzH92gq5LrLFLXlzRWkw4d224jsEBtVCejsTk5qhsormoz4/bXQvVtSnZaOyeJ3d3jNQctFV6JF9ABdmefy/LpXhYt4L6+/0iP5AKVQwcy36HU0HXt1hvfXh9fmx6Ae+e3g/p8d3/+sYSNUnxXO0Q6LGe/osDTwjYfE3LBwZZSc9JrEFlo0g4lEXxFTgOzBz7qYCWQSUtDJw7K+wtWtoK1qNRVm0UrveRV0lmPPx5BHB29VuZHGzq81u5e18VgyU03RJuNWrrLKwvT70GhUnpsCQQSpM2mJ69cVvg7L6pdbsVZUHLynagFxzSNdipL/hEboAUJvn7reSoUn5YGABZ6tpo6Dg5jRBQbjsgK5jAxg5mLGkIVyKLamKMr38yRepGt+GDNvWAdKcuVAzlKsdHOvUSCYyK6cO+8hG8J7uL2+sk0qFUDkyawcDnCEeZuWsW9Ar/ybyOSF1RYmSG8rm3nKmlSQdvWXZJlXypm/+affuAH84OHKWUx72Jxh3VPQLztkbLtWtZq3jKFY43DI2xFjWJ0GpVoEdKhY49WMnsM1MlGJ1FSqFE3mlajrJ/LiLUaD3twbj9PXnHyGOJGbSRjS2zdxBD5WVp4CId16+ReMFS1yM1cQ022Ii++tKv2DtKmYCNZKpuZFH4fRVpV3bZLWQAS2mElHg93gNHyjucDXBURdfE5QqQMyEZpgJoyHSOGRDNpq35tJfPpRMI4QvMYJJwyiv4rOGXVhUFSEKa0lHqDeT4scd1AJPuIY5/KQgSCEq+Rtg5c+lauz1ywAOrCYZVBPgrrrOYcY/DL1Y8l2OC/+/gx89G1LIIUkVYXcI4VmURzR45X57wyPRyZOmG4O19B4IXkKKyfP1Jaz4tCo/5PiUrUFMIgH4jUsBXJBFB3hpZ3OBHtwSD2ZnprHC2kuZkiqqkJXeRzxWcparijR7qLm7XwzgSomov/VCTN2BCdJhoJkAEjbhR2C9UWvcnZec1YZzg4pGkiJYseefC3lgGfQIRzlOW7V8vo91I28FrtfJXJrFx4hqpMNDkSLPO/lUdydByPVk7zY2ivx23oYirv40fEE1nwjzplZTGRBT++nsKjZtw5AqXr8NCQhoZ3hoR86nVZv2Y5pBKg9v05mosJtUupPQ6+ksW9ng9f9Ho9jntf+o6vJ88LfP7dF6LZp/b+KOI7EVq/xB9pT5bvXS1oP9d1rVNeKzUhEnZDdWuy6Swn183tmSvfBmBnHTJFQkh2d+PMYERI6TM6nCoMgS8RhbLpvttK+84eEaJiKSc/F8rJu0s4c3XP++b30RC3kz20lGFHQvu3s8ud3rOS6rPpM5WIzE5uNs7mSBfoEXuzb6+bA6tySIhTkuPnu7KwUE5JeSzFgb2qrKZMPJKyFXmWoRjiFP8TjEd7L17rrB27caAkGmBVY2s+VGmCKXsYS0ACuOpdlfKFayQeG8CP0krJ2+/7nkdD5sva8ex97cZaV4+ZnFVFFC1Xi2KnmRTzVaFS3Mk0+2qunYNC1+/fK7S6Kg1ckomYNauaaEX6/apN7QMYcphmcWcJhYIot7j1jsr0hOghQa+nMpnQj5+2NzNqtoWKrTJzIQ84ewR5Qd8JC1vzz8HjLLSvIqq0Ga3QxFqJil7bBJxLRwOuyNqWm4unVcN6RqmzIr/RaPgOFr2dKBsmlAFilKNf9/ZUA+hVBTt2KPfUvmHMiL0nAxEz+LA6BTloWcQ9qfCwCpXWJtbMrCAE7v0FfeedXtZM2et6Tj/t3TevD4EtS1Je6tZtX78cwlMvrWbmGGOo2V68wxk9gYVcj+PIwz8KlgIsHHat58QTr9R8NUCl6Fm76qoqWiIKtR7UuSX/9/PDqPzx1Z3X/Pgp8sW5B8Jh4YBb17OSD5oK3pEqbkuoVd39+D4el2kVqqUjTYySQ6+au6xverrYSWWru5AM0+cpbDTlL4XjX8ugzC5RfwhJV5qVqPuFL+MSU32ieWtf75fR3FBmhYZa1wAI7DCeV4mL0VN06GlO+RH5HI5Zna+oeqeUvTITXcDPz90/zytQQHTo81ZlzwALOSqGv0dVI6V7BIYNW+8FruoaOx5LTckrpYgIV40ML0S3VhXj6lXptd+jSgCqjP2g9CRnrSemsTMaDqoiTmyMSwYhJZRP6gIherMrUR/XMVuwWqS1VFAL27OXqO675ucqWLjVMWlO/Wr5o04iKRreHqDvuvPR6W1VafLNpUOGuB3oEbIS0F+/jqHfD3YpmgPbTukpVf2YBJU69c1yOVH5/ZLnt9q3iVw+UsDlp/h93+ZG0sz1yDybNqM2fbsNe02NKfby7Zxax8XSG68Fu1F3N57ryUKDK7MSnKp9JVdOvPjJ23BB1ne3wCjr1A+ObMdfD4jhhfAaHuKj+Avb5KiKwF3uhsEmkNa3jV5RNe1OOTCkhwm750496RxjvM9cfgIAvxc1t9WtuntdnfcL41mxOO2s4+kZlKnyyi/MueZbeNLfv379GoP5n88aDmfOXCjluR+52w7M/VW94xxJco59UGAyZuxynzuIasc6izzbB43Vmxc4tt329AVqo7oYzd3JcX/KwaT4BLdt6ktG9YzCgaaN8fGwu86VqA9WoSamBR2o3VlWy6eBLWq4c/mRwsgCI6ADma831DxUO+vps6ylNQC4VwdnaqlRk9vbJjOPxlf7CR2W6y9R4GlhG52QCw62aH/UmjcOLHzJYcNY9vw4dhPvUFEAbTdmAVkXvFiSy8D7chNj5XM08vSMbzJ+7/ns9McjyOMrWF7jLsvvaouqvd8XBZjKjOf1vhSN9MTHTsK/B8OR0kcs54eDgxIorMg+6x6rqZb1abuZwrVVEXm0gZLzE6UjnrzKP2IDtErnmNHiu+nmX5dk7i/P8jWH9HHqXtUzKVZ69uaqWTXCI1ItvJm5dwYukTZNPqqmSGr2S5q4mJqgibkIXiJAqcNU9NKL9XK9Mi/VWzpwLzFHILp1py1ZqOyypalHVsyp3qLWsPbmm2f9648nnKyfZlBTdeh2uRg1A6urniq7YyjOyxHxOP/4rP9FntoMWE5mwbyLxQOkJlFoRAieWt3YzMbP2Jlk7zMAYUULpegVFFHCLgXKHsPY7DkwCohexAjTk4YxaTeoXKMzdiqLROell5OSdk8X3LhEDoksMQiUSd6fxgxmPp0X986aO3YLOr+nhlbmjU53uy5nPc005CSb20V0bCbpY+tO7JOzZ8CdeV0jaKQUgbjofOaaMMwQ0baU6s4M8Yr/b80JrWvvPnM+D/YXebz2Wvl0YmYcUfOczJwyiv5HcM6qC4u5IEx5XevNE+fDEtcNTLKPOPbF9cmhzEQgKPEaacvMTV/IR0ywAOqVwyot+iisszqO1hq/XP26kDd4/7qdl4268j2LIEWk1UXIwU2cGO/7gDvVfFTBTLTUuJMN0ZuND8tIL5Wv35h7BnlAAkzKD6YxWIUjttcyskImoFTyDpgqQd0L1t/BdHOz3uUzQ2sBL4a8dUY2F1JMvbW8oqu7qXK1rIrdzRTTliIkIlEESJCS9wyipp5unkZEK8zkJDG4BRgECVGAQ04ANu+hDIaOxAB7Jso3CZdysjizc/LFRtE0blCIJdf9g2UNdguVZSmQzO9S9ixZMozGrTQ/luhOp7tYtPd6cTyRG/AOiSvBtQ7T/ecLoXmxM3fnML2roWHlyo/yOPFe/bYhGQbiUuBt4cerV0XBtC1P27MzjJxANe8PGfz53I+Gvu3nwXRzvpdoUmEl3yM87yZD/Hdpvvnh05E0RdWpObo7OEFSHvx0OFOZfKrhhu9eHRYgdML8qk4qqwwHGFub2cOvydcrT/7tZZI6gUAORjYJGbODckqW8jHSmcp5euyxem5/6akHkNtOFEESqRk4jV3yJDGuuqa+v0dUw3znJOeqBG403lFSdDujRRlRMrGBrvGwXRfm0B30q0e6t6tGa9G6XmmlFlFBqFCrxLuHMUexxugwiCJK3NzMiOMRtrBdo23EPLNREp7wXfTuyS2aPeTR4DsxhZ3mZdWSNBJMn48hvmUiRk0N3Ae6unVFQ5dxaEa6VEobUQ9ai6X1GTOE50KawqUJN9KeF8aIu75+8UostknCOS7K7BGAk9NRA3n4dnUV3UExCtEkruqkpSm/nwSOk2iUo6CktdueVg3r/aosaZxEwaNioofF2YcWiaYS7070fXcKH6oKLarPWKDFqxJHsWGoxCM2H5O6kOC4rwtI/Tn3Bag7lPIwKTAOgJj7nZXS2YeOW3ZWWbcLRUKEbS/+K6vFsRMRy3P9PTRBVG4zMh39yIQIoaJ3G7hJZmCzjSzTd/Cvf7qqpcdROE15n3JMmKYSioo5tBzywTTFUx1XckIdwyXqBv4+vQHvDV3ThI5N3WKSaPp3VjeG+JKVcPyCaszOgrWsuMXdFQEBQUp7v78fFC0j3oJQkDPqTglNUmLYPSCImxv7rNhNYlPD4RCe2wWV3Jd8fnWMK3HlbKHVgBdXOauN8WtqcTM5vTamE4sVOzq14pj1/RBU2My+N9ER9IqmWotB7HknjtBuO0k00TsZ6WXPoaKIcQjfdRqOa5steOUiraWCLdHc0GvEz0mtiXHF6M5k0jgwgChgcztKzmVWEpdwcPgEyghC0cIhRM/TqPFU67W1FqOkVXsxAKseT+HXwGsMJrhWNEXjZjiRpL952W4U8l0Q0ZBEXW73JC2RvyVdv09XK6T5kqD4jeUAhECnX9d6dkXn4bDqr+h1VtNrPfesDjifP5VO+Zfzm9sjLbdWWpnyUZp3fmvva/7g3PnPf/7+rjWl337tKigpuSOl2pe3N3AfSSavC5iMJgyE+xIpqCy6TpCdvhZK3n0miabXG5hVvUo4nVVRiit/Z+bOn2/Cvs9yTXb/eaZkz3Z/nj1V1dt3yAJ0me3Oqd3y0q4WuXFf5x/x2z0IqZsOyE61O32DU++rO/Xv5/tTogH3DuwhCbG//mePOlXnh4iH5e5/joKYWvZQn6ALEWxVaw4xGq7a6pOLzlWqmYgBWZnc1i5eAJMapWU7A0VM22zMCEpnOpf8sDfy3wpOfxbVsW8fhnisEX7RY7iekGom1z9KjL+x53z3/gTdF7HZsdNA9w5iRIFsxr0BiKPAxTPIIgxboDZMs9tvtZMby8dtVosI4tHJBYh7ZDfxkgXAFTV+0s2QRTITSyHRAErweFHfNHpp4CBAyEAOJAB0AADYaIMWIxHHfaqSb1q2LYGN/JaVnT9rVoYsiqJuqGKS1Uz5MZ7FTU+224lO6y4TK5UQAMJwfwkiFaQqf3nwB4B7AMaLwjY132JxBSws8Xf2GM023rBsfE5OATPvHZvagYgGLSCucU/EJcMxBOekyAhbpQMxKaedxtilzsEEvvesk6J9wEk5cl0xSlSi6E4KZ9SjUApipAxuTRLu3gFQUFgBp90jnLE9o7p+B/AmKU17atTiuUHKOWeGOeYlHGkRszNdaQzp3u3XndJ8OsNTSowjNPeeEqeMov8KnrLq0k5Jonn6rdabu54PS1yn8S/7iGM/yVwEghKvkQYPNGMhH3WCBVCvHFbpyUdhne15dt/jl2d/vuNW8E/e32sdYuhajSBFpNUFnGPFYYnmbu3uoizTw56pEwwVMUa/uFSwjvg6+56VvWOab1G2RPMmBJGTOHthVyQfgokdxh+iibuoIgJ2EF3fWgWvTtVUiT0rKei9l5B2y27GzYsZdoPq1ntbQKy2W3DCPonYGkR8OnkVYf+Rpchi3HQMXQyQsQCiz89pgk6ZCCTyEwy5ppRzqEs0tMg3JoYdEWup4QuVUkFSGbNA/w+2a3+plSAPab6UGTzdxUre+7vERetn1LjVabb/ehH0XP0qI3M0HObkVKXJszo6frR8M4VRuFBo1v7zPao1GZ6/FWm/huBRAM1KSDL56+t+dOrbfj15uHl9tVtJlRG9T7XKzpI5XuL3vL+UpIexZgTPM3U9a+UqhK4PIV64bik+kuA6+nTa+ekisoG6lQRpOeteplirUEYTjpw+kPIXj50jUtAIX19tlv2p3d2JSSsF3EPSXPciN8RiVq8LXzvnvAfQb6O13vec+Z+dVOQMuYlf2YlbrankllhLgNP07AQs7hvzjx8PcJkDmjRJyHLV7DlojZNWbXdPcZEtI4CbwxmbaVuoVSUy5GDy1wly53cbRIOW70YjOS6EZY7N56F0doM0eRirAgngqo9CMC0/RpX7BvBjNMFdYlzXde6cS1m97e895tWR89znWbFmRiRpdY4ZeY7AyDK7MUaRRFT7HIM65qQ0//xZmLMxp4wH1cp+5ppZkYsUezxzY30TZNrDaxIByiwsKdhOwn1IxtQReVdMrzcDcNp//U03Zj4DXCXL0krpB1cavDwCM0RHgqZ5X9xDwe1dWRAlgAno2arMdJ4uP15KDGVpo4KxcYktT6uOzsVxH4lAfpImj1rPWHo9UbY2oQUglqbo12d7ZUPQq4ps6AvEcOvbnSmwR1mW8hGuGV7/bZfh9IDRWIgiM2ewtHZhfjAz4Cjg3h+gG+8yxsOqKrNz+TXA09598/oQ2LIkZaVu3fb5yzxrupaJkYQ1893VLkA6cnV7+7nBFX8ceXjKhUWQIOuxlG6TfVWuzybCFHEhpyyyJU6qMUTsEidr/dff3o6CH89uOJ/eJZwIWvIYLkmGKp7G6WCay8srr7SEOsbboA1eR8xchDkZpokJAkG+arynrIsIahCPebRY4iPm0gqf4+O8Pym52AZoRP00nqUWojEYCgT1GHdmnUDEk/Fg/vHbU6E0Zmj/jLN17HIIC8G+ZpyHoJEmARcOfaTp1nS48ZUdjlz4qpRarVK48J8+h/04D5eIQQ54bowsjJQYsgx/jcKaMHy2y9Ch8+dmzGwcOxpbccz6PkoYI1zRlF1eCOOWWY6jF4arvUYmF2FGyZZsB6WPtFsDSpMUCho0I9poNCEFhNT3MnAXCLGb01jWcfFswWqR1lJBHWzPUCeN0bRMLdzq+Grjhq7vptFFWIc8x7A5548YQ1Ul+tXtUpHF2nV0MqJUzUrZZQJgcs3Zmg8iMxEHHY3E3dFslGbqqUAm7xe/H7Q+M+KzPncM17/p+Prtt7mmqkM9HbB5bk15jPbpg1qTDu1fq5UdY4w27BR94QOm6mM49Dr17KAVTUTGtKRNM5u2ziGTcptMMiIQeeG6FpnBNxFeL9oY6xOkD89hKz6Kf8I22quIQ2+EBodNIK1vG1XNXPVRaUennk3YQ4TqmZrHeIXJSEDn869Fjfm32yprdVwHjumcxWlrjkkmDNNkpjr92DOuuXEI968//WkMxN++6nDx0Zyt6jBPdhvrtiJe67WKSxhJYh3r4MBkjLLL7VoxUK24zplp3l8R+NULb2Dbbat2UxvVhtG1OjkiG15c1SEIbu8D1Z9eMgJN+3oh2t1aP14XDhVeia+gA9qdHZfl0zosunHH7UcKkwhmAR3IfEGowevarXf96ePrY5Ub4F5d3GupqSbPf96y2dx8q5jQYbnwFQWeFra5JuSCgy1rzRsTuVHuFx9um6pU3wmQYMKgIImi042oFvpTkAW3IkYKjCHvQYJnwP3G4WudBnv/Dfw3glCPYfCKVR5Fby+1dT1SOMY853q8DlBPL/w+Ulp+D3x009T01mSgCzAC/CIp83nTPjNR9jlEUWVxbgUR77sxRk0MvFPjQs2IWRugNeLBZ7T47luJ+vdtwbr7jbYkCJTgmbzWpLVY7c2Ja2Z3c/qym1tTNe8gchC1U+mduRJVrv2gRkbKSlJJnUgeeVTiylqf+OQT+HQ+az2ZTzh8kTJHhFZtnrNn9ZaNNuY8UotUsky5YtJe/2hsVsuvfz2cBsI6q7Aym/AyhJkEeRbkcBCzDJYwRNzv8/H5+eNvRBPtREyERPMuFndsyQBKjKzTqkM1BYUYBTsmyO2AKSBopFM0KJVowl0sEvdgRtVpwK0QaCBKIBwNoZ0kAj+qYVaEnSKoToDVkiqkmBRNMeqkSacUOWCcJrp0BVAECBJLNAOuqgoYQVGpD86ABwQWPU9DjsycEZ15U2WAsyYSUc2+PYTYDHGu7inf7zLe7z7MJS/3Ue37OI48pqW6A6/4knqj3GxuL77qNd0eZSpjXU0+nYEJkXFEzdeFyCmj6C/BMasuVMSCME3rWm8mPB+WuE7jX/YRx/4iqyIQlHiNtHX3xlfyESdYAHXKYZULfRTW2b5el+/xy7Ov8WYIvP9az0cIXfmeRZAi0uoi5OAmDeK0AaaJTlCNZiGKLiYmI4jt1VWuImPEV7gIiovxyUL6yWEiFFVjNvRqdVh1flHkHTBVgroH1bOfozml2UHyhZVjcB1VRslZrLasWejSwLsu/3F6bbUUO0MiZ+561HISMqnmIuh76D1jxIfs+X2rdZhpNUcQBiCCpImAGg9irmu8R3FkA4mx9MxRma5ZFsL8jHMU5Qs+lPILMkcyjH7EFwzg4tRp8ksWk+EtEGDuzw0dG3GHTJMWoTTvj6L/8iSMEwR5X18eT+QGqzeO17ttkUr8cQpdbdS3XjIMilylaunwlPwcVSZ+OdttxyQMxE1m5+OcHa5nwVDy89Pd+NmJS+npd8nj6zXdzrov/HjydHP8KbeiVLpe17wx3aY0RX2JT1P90oIfxXJjbn0Jgd7GYYeLtPzualvcWlrY0WVzm2c3P83dA+xGHQm3mdVSMo+jnTgp0DkavGDD+Ly1YEJNr9expvY8rtaamuRDIxwPx3WtRVthHqUc7+/8I8Z5rk76O902r3Ga5V8KF+YF0km7snPcNzbSiY+SVgHDuamSeWshiOvbBzdfBDJm9DTJ+a22qd8ozbQlNix5uIcMAdkFmqFp/xaOIzsYtUTxD5l9jtfuIcRQeDeWEOA0J6xbbJkPFSQw0+xh7HBIAFd970pz4efj8GnjwOZoUn/37q8YpwWznfGqj+XHNra+WH4bfHQTUT+PRTPYoipovgiboDuqHteirhc3yrJ8fnazXsyo8VPHsPrWj25ZbPioH5/9tPzlbBJVBpqxNHNzTNTQ7Xp4Z7xYLCLM52VMRvHHH3IIQpAZ9PDu2474Jc6u3WaPgAo7d8LClvnnoDtr1tc9qrSB7CzDlkDInN7OX5DUY+lo5mpK63L4tlmD5DrLsnacjESA3Jixeav/ejtRtjKhCBCjOfr2jA0T4QJVFQ9qh0DP3teMZYIWLTlyvZLhYXsnnjMtUEoZBGzWYXIc71gyGZmFnK/rA3pTL3k8PmzOyuyyLC87vS7fGh9wBrYsSZVSM1K4VWcUtbDouJBO1Zr5tWa7AOkjd2xvPze4MR3HLWdqw9xZueXXugae+TXs+DzdTUDWNoA+siXDnDGpxqRzxPWvf/x6dv7l8yq8zN4lHBQvnOfjsHCMW9fLOB80Ffxow8RtCTWw4GGLSYZu42eJdPkd8qOUnM2cu6zPdZecEuv6XJ3QzJaVUTn702+h6t56Cdg6F8wLpbMts5Q6ATYSvxgKm0nFZo4ewv7xmamfZszqVq1c1tyQ0Tnz6+lcJKNTdUtmOB9EbeZF2FUvZtXgtgBTijGRb/aPn4U/6yI4mmFovO7OOHTmAciNXJGzeKDJDqsqRhf99tye1RIDbCnSJ7OGxTUiMwQ0uZm8EOKSd7gs2cNc07l4K4jOGcyk80HpRF7MyGnWrdQ5GMH8Suem4WqhuKVHGIpxEb65ueh9XJgteOUiraWCGGYj4L2ZMY2Yxa2OmWHH/Vv4mLxe6MJrn3sq9ee5twc61vso+QybDsTyvSREmqgtl7RtZmC2HkS5RNxVE/3yh9AzfzUKi6bEYWHZtJKsof6VVZ/lOcQZ/4D+en/PJSMJIN8zj2lbo+i+Pc3DbnZ0tLeyLVHcfXOeRZ8JAEJkdwEcM82GIwoBhDVL/3N6Xf3prFLFXNLuBAhdu3umkF/464Gb4RfhGv4SH8X/wrYpv1LmrFNl6nXb4X7J3gXaIjys2qwNFAk34iqlnGPr4mgMFXMuKjN8u5pb5L2Y2+ZKe87itLOWNqLTLTrseHXbZr+F4/j19ft3Kcb85dGLoBgTY0Op2GZYnrg5t91CLRYcR5ImlhuYjBoMhLfb1Kdyc+t0wShPY5hPwwjSttscudFHpDagDDs5MV5Sx67HceT2q6D6fUoJNO15GmN3Y7zOzRQVboncQAd+d7Zslk97sajh3lw/UkAdRAEdyHwjUmO27WG97ff1dd0iAO65KJ1KNNfk058mi6bxXcdDpMNy41cUeFrYZpuQCw628Jo3jNhgH+5tYXsn51RJPV5v52l+mxXNOMEoFi63aZ67OaC5tchAxtlBH8M4e8aKmfOGJz/9B8MEmnIwZhsjbp6aF911W+agZOUGcTkXTCWD+yjz3P0ccgqEbLnJ3zVDABNAduMsLS/V3x2ptKogsUOBFCw+b9LrkGfp6CBAQiHC1gZojcggM1pNbfAsr2b5d9OdSENbUy10Fg8S4kwhSMxJwEXvVESOa5dbODGxZIO4AsSV4N25CBBdzCtEYCDHgBFIAHDPF47jzXuwsMJqYBVYQ1gdrCsgXzwEJ1OJNemIJ9X5MSRRJxo8qgRJ6oNy+6KTRL+279e/GcYBxdmyWzYrbtvDzdTFFttieqqZP8zTw721aX37hz/88b+qs0ZVc6GN5lssBhB34Q5gedlcOkqmzADOFxP184CpCIMCXaI5U48S7zf3+lmBmawWNk6ihWTCYTCcXgaVuXdGowKdIEvjUTBnwt0M/l9yLQx5yVQWAksCy8LWR2bOTJwcBpbCduSciYEzF70e1lmenMzy61XZwMyaSDMLORvz2yBxz7m38O5qpTAvR2vUpknDNKW0HH2dJhPjPBNZafPmxsM8gMA0S9mVxEuRLW4tAABg327c5dMwR8YRsu23CaeMoj+Cm6y60I0pCBNeeb1p3fmwxHWDIdlHHPupLIpAUOI10uCBptzIRzfBAqhzDqtsxkdhne15br7HL8/fbVdDbkn/tb5fTiRbZxGkiLS6CDm4CWNMuwEQOUJtt6x11EYLGo2ojrjXsoLF4es3tEWnHTsABB3YCWws+fGdYyuRQ+GoDrzjIcoA1N38NqmiqEMwiK4W1gXiEnEJesvkkJS8s5suK1bxMQXveY2lSNddc4m+ggEg0vBWJY/aUdVYNN4ecYjnujFTZLUzuvmtNs80nfeSK5wu9C/Vi4uYkJjDnpaam+apZ8gS4hylcmcdE7wZjAVTyjKdZcOSnTEJk9hpeA7WQObfljK2hhgCM8hWmp8g6vzXu65DLN7Xl8RFaRjjPot2vIvq/fhZEbZUwjNvkeeAW4gUcJFVrhIx4s81NYfHMTeCUbDjR50drivaIeTnJ4u4I4MLIU9/Zep4nm/wSn3D5/MNjed/eijGdMa6tpyb9qZJSTzyRhpX2rx7kgg2pk5me+RCRZyL+mSkm+LNdD4bdrecWvR4m9Jt7jE/yCZjzQ15W7xALhEQMY620ZQplYaBtwYzGRyPY+lN30sNMSKjFBznUtn0rC0YPUD2vjyfcA1Diy1b/KsoRErDG6qvHnqyE9lIvLKtkjc+sUlMau6DJdP2hJY4hMcwPM93G7kLVowYnt7k/Bjiv/Q5wrYzn/maUrKwPDw3u2yaKUZmK7YU4ZlsnOz4U0FadbkX+ZCHh9044CAamSWKdXioxOzBth5CCgAJ4Mgz4ffJxe8197aZEcc/+poo5/k8xvGNsSUtwxpqtySg1OV6ZCiJnENeShfLTF2Mbibugmc3MxvEsnYx4wrRiusej8SUPJGNsGPOHI5UEomjxNm/f8SF5ZOB3YguG2ZwkZnZTDYaobVyArOC49HM7flCYNmO1y99DMPQBkuFE9+EtDx143zms0cwe3DuBBzr8OdgyyxSX+Io2gtyD3CZO4kYzLmIY8giGlXwxEdIrvBTpp2Ormf44IEYbxQTucV3x946SigTSgFito2+3mKZRLjQq/xD7XBzz6MvElMLLVpiQ9Zk57BHstAWWibxPtPMRAkky3KieyjFgCOD1/UdqEPFKrW+WxFltqNTEdPw+ub1IbBlScqXunVbnD8ewlNfw6lm9PZC0L3txTucrRbmhqpZ6J5oz8T8zAC0UfeebdT610zlYxFmN7tbG0Af2QIZkXlCHEZsteu/ffzcEnx9rB58ruUU+c5DD4TDwgyYQ8tze9C04IqZxG0JtUoPOb6vC+ZEmYmMhzQxgZaBrhq6Ks1ldjJNgP1T2R+Smt0xwRQW+euVzDHp07POObaUMSmFySY7Gdev2xc7seio9ZqH4Xz/EJsWJgBkCqQrRWYDhkHg2AUUxbD1TBOxaTdn9uD5TAH2mOiZ0SylZKKJf/hZ/a/TawWeYZwaj3ceGlsCNAyJt/BZE4lx0x4iV63a3dZntY8BtleZUsae0bg5M8aT3eXthfC0JOJtXxPZc7225IIwEXAmWw5KR/0QIUnzQbXLYKbIR7qQZZiH8paR6agug8jNU6q9jstmC165SGupoA6258IvXJe8K8ssklsdm07XeP9p9P10r3zb57rGfd9/313ZAt/Pr6Nk4L4sSvjgUwdgll+lFb0NPE3ki7kGwGxWmW9BA3BK3iTp5Zwl/f2SrwxAcVfE3W/ZMZhfho/nU70Y62bj/jrznLeIHZlvt8SPu5OGDZ/+TnNUcMu+Fc2YZ2sM9KOzm9w6TOoMtFYtU0kmF+Xryo4VrZmzRL4Fijy0O4moxq+IHC9y3D7DLfwSH8X/x7atPjP9eQkDOA+k9W0jDrHnmjjrs+DgAtZowv6vb9eZ/FqvMxLr/wgzQ1cP6dR3u2exNbjvvnbnLE47a+0y9aajnm708OdpP7lp+v7+x3+sFeCvnlsNHABK4R+vW2Bs4u79eU+D1OTG08idUOodJmPgXcGfd2+o7n6dj6dZXwDeX9CAbbd98Y0+IjUAws61Mt0WGIIJ3H5XVP94SQ007XUB2N1SXtcJVYVnEu6gg7g7W0/L1/Jaihru4+uvFKgJioAOZL6JqYHzHKx3/uPr+3XPALjnSuhUooUm3/9vsgyN75gOkQ7LTd9R4Glhm3NCLjjYImreeOaG/zZQVHCPdsvyQGuNbYMRywbn4BqSddkr1B8SIQk8MisqkBvjME1WBC647nSMZICBgMFcgOdc+JnUrN+8c7fpGB9iLPu1axrSM39Va/vfgyIJca/N0+abYQACUGm2oZMtdCliDJ1uIkocaEnOuVZdDaiJ2tDZRwnlH7EBXMtw0frKd9M1/LFZxeAvT3MxuoPNh4ghF6s5+7IuAalEiuG7NTJr8IuKDy/8s74jlkPwB1FBLFTWHRf0KKQoBTUg8jsi83xPiZAOOoCOQEfOB9NxEPJF8hxhLC9RI0mjfI/L5ctqMSeOIYUlJpP6+sJZfEl//t9pOlF5I2ESIi902zMRiuM+B5p2JOJKPFbmGN7YRw/+DWMbgDVd0rWoeReLAwhsheeJpOPeFC9WYJoZVjA2LpP+kQ0LdKZddCmUowb2E3P9rABMVkvcG1FPhACd6GwwXYkh9kiICjDibE+Q7ife4o2INbNR8AqzdMVp5yyNbuoov+wCIGBh5DnP3gMVEbEwg4LiWimC2+3IrMfhgSYiis5F5ocIWXtk60RUU3w8Gcl7gG7r0cY3Yu0bKbrbek+IU0OLqJq9lc4MmeQxu/kNdXiEEM5ydgAAQLf9Lnw+5fMMRsYRsvO3CaeMon8Gh6zqm0B2BJToIepN58+HJa4bQMs+4tgvZUUEghKvkcLsHrtzxA3P1+nkTTiscoKPwjrb6zp9j18e/zNzYOb993pep6kr37MIUkRaXYQc/DWAjqBuoljrg/2usjFFJx3UGLl7Qr7YFa4OX7+hHfWGlZAY9ZNzBh2LeCbvQtFctUR64R1+MadmYgEoIYY91TkYJL6Zed+obIW3HKP4vEZJjKdIzYVr91SWnJI/Sk2Ju2tuJR0IhKIx91lF8UH+lHSrqYj58vRJ2bzXosFZJguI1qhBwIUqEuXbuSdPRRYhxtLTRa275sYpqxRtyuXBBdqc7GQd2a3u82Vr3VaydobKspTFzH+ude4cOhyfM2OaH0Nzezvdhaqg82R4T3haGuWxbNm6+fGImOZfB+O5bPlzfS7eJn7mIln2sIef25jY8PtYmlNIOyCCSLZe53NPHNlNOddMDZ4+KlLOq/lr1+brauGhNh9/1TQ23v9/hHBuFz72Tgi3thZLYrrFpWALyo+ooaDLS6+r+1irVM+Uw6cXvRuxuj5WUHqodDTSe1HVwQziFnBwp2LtMeBaMyohENZ5lYoJGgJltjPw/PGx3dz6rEfOmZVD5dnWU+2Nr4fD1CGuMdbPC1/T1OJanfx1lg+RqUXzq5MK2RvYQfZsZ9TjTjiRkwm37BS6rYgTzXkcx8+PHy5rn12AAGpauQovuSAhuS6IIFdZpaof/MCGBrJZsigouFqDWnXFuPl3QN+a28OPox8j7oZGymFGs7JFYj09VNMa0XUeQgoACeDI5yLfJ3t8nrl2MyOkE63L/nL90UvAFe11m/Z09L2iLn1tHyvWRYjEb7UvzWpfMlnVPkW9/0IC4br3pcqOxQXu371bVEpUdQWfvK6aP5a6SCBZ/Jo+v8qm4acf6zYxrVYVqajNAOMy+KU251sQDiSdwHS3m6BTmF+/w8gZu+yk+qJ3xdhA51URxOy4gnnMKZAc1tM77vUqz7L0FY2KuyAakFbtNaXJXVtgxdWLRgMmYXyhqq0mYIvV1CvF9KGVTgrgUYvvjnt0lHBMKAOIuS76uMdWESGUQswPfWxiNPRlYcFBi8IFbiBOAQ+XYXHYNVpmiXEly6oLVLbtQp8Zg0ikvO8/IDod2M1r/AEbgjLbs15mGl7fvD4EtixJRdLGbWHd3KsPbfJwNStGX8ZqL+j6Duc8qmoDt4bjyMPWVlWP7Ep4v/Eau/hYtf7YvSoburcB9JEtKIRgZ+Zp5s742+9vP58Lfv/YI/pcyylSdGA6z6PfOoqt6wXbHTR3wSuvIm5LqFUd/PF9PDSLrF4UIqaJUacoV/C2bgCqFIxBuT2Vm/k8oueSG7rcHV6qe8sSa48/As4d41wp78UtzgBZO44jBMckXTQ6jtfnV3DLroLIXrLEXYsqIHgM+PH0GDmAd0llVoVu9/DMUT+WhO9lkWtlu9Wqiy76b79f0++PZ1aLs2m8+1QUFWRQXPRMP89FApB5z1nPeMb+flFcNMUAe55ySRnPlS3ZVTGe8pAxX4gkWxF9PvdF3Mf+dS6cvYqgikoPSkf9Us31gVhc5/dXlV+kK1ODONS3hKpkC51Eb+7a6OO4fLbglYu0lgrqYHt2+ej7re+KAGW91TG5mKBWPT+/+70a8yo7Hq3ZIPX70rsGXOrzKAmL1p9ObdorWAIKEn2qxs8hjCmF/owxWUoxbqRZtvoxa1b4jruFx3JVfp/5ynp9j/K7F5/YKzeXf2r75Q9/GMdQy6x5zjymr2PYWvyqLSVN2g40HHF7Xf0bv/lKHZbZOby78Q2+1tnukTZSOrPq/X+oCy5+0iDBmgvem+ULKWlcCmnD5SrBAZXbd4S38C0+iv/DNjcGOc2a72St206W1150DZ+VJ8p8lEaUEWWof56vM5JDDaIqvhYVDt+uOOhQEw4nnv05i9POevaVRdezyHb2jNdlPzlj/u7v/v3flwPxr97vZ9KEWCv/eH2HsYkB8RrSoDSa1IzcifUcYDJG3ZXiNaChGnCdj++reSHG+MIGbCvx7SXuI1KjUIadayndlhQDA27/7kT17y85Ak37eiHa3Vq/XxeeKrySNIAOeHf2vCxfy2spariv33+lwFywCOhA5jNKz+F1Tdb3179/f/8etAHcq2tKtdRKk3/+/yar2PieZkKH5czfRYGnhW2uCbngYMtQczJrUbWhadQckMbunMoRF0d/XckF54FtpoY2dwHnbql4HFaNHFBoLtPzKL4z+MLX0I8ZBzghOLwW4mWqfi619trzerp0TMyl1OfrqWhOX/VvDuduvweDhdKjN5cvNi0AAnS1LvdqzX3JUnJvVx+iaJJtIaLWlLc6++hypyaLbJBobYDWSJ7zjFZTX3NM/9Bs/M6OE2loS7aHPaYiaa0urGuqx5ZEatGck9PnFXPaYojpQNV35u0j8K/e5pmr1OOdN04cJLKvHBKz/3F7RA+XUrn3lMNA0gPr+q5yS4cvUueI59Etl2LPTshbSbznrKmsi5a0pK0sS44lL3uqy58PIxm5vkvwEkSil/tRm6GJtK9JzHOqmXaKzqeulVv+7evvv/1vzl0AzokR6uV5F4sjEYSfCVg39DKaGoMLaKyn/e2YspnglBDU0D7aG/VRQKL2I98FZDK3yDXhrSh+szeT1g1PdwLElbF0Lt/MxoXQx1SjDcGBhYApogl987H3TmYyPZOvh63n0eGsZrUxotRwjaPFKxV5P6UgPd2sGt7fE6pRkUKUVccQ1LmP1fGvm/tLHidnKk6Jnpt9za60OM8tNtvv2w1xNlOLaFZ3X1ZVXMUPlk2LNg0ppatevXo1th/DgPmUzzMSGUfIrt8mnDKK/hUcs6pXgeyoocSeqt708XxY4roBtewjjv2lrIpAUOI1UpgPfXSR30C9TidvwmGVJ/oorLN9vS7f45fH/8yaVPmzv/u7JYoI2TqLIEWk1UXIwU0cxH4DMKYY1DFkY6ouephxT3prOj1H2lp8/Yb2LDqNyqKsSgTxTWsISSVRqnE9Ys2CBgb2Pg2YZU2imkvOXnXd7CDlzVzfT6ln9c+1FB/XvYSifFnuiCSvUuq2Lkt8r4dJ7W70rMsHo3AIZVWRvmeKXzMEyQfv4aLU1zOlUGMmp+KQxUEARt7kOHe69bHlJUn1myeplu+hZ6O4/XfJwBpTcoMK+eD1uHVxsyNx5/G0r2Li7+L+QlhTZph/GnaQ+R/nYXpPPYW/6mVFDsxPoLu3D12jekJ4Mv2dSKPwq7crwmYcMi/294eXaz/Xn8e1RbfotVa/+md6T38838QT//i+N1cl3UUci4x+f3w+B8miZJ4vMkdK8nWwrutu3/xqX68O3mnf/Jtx2YBhG4n3j4Pvt5ek9YZ8Dd59TTw8ob/+cTV/i2QvfQnyjQMEQACBHuH0/mIDgu2B/f8zfLS1WRH/jhpeyCVGBS6aqlqQvHOupDDeXEn0vcZ5Bp2jP0+sL5GzyoT6nFVSpMebdbukOjmVBoHSPbSfimmQdlIjbVSMwr0goQ96BrTV3xRjQ3EpqiRejWFvYZJOComwFst5WAmVUbaBI0hTOlKfNlrCOTisCDB+oKTlPI3jsg5VIoTMQkyoRJfHekSEEyno73EjZJ6LKUioT+0IKAvKAhpdghcd6zKIVolRZ9ymx+HPOq+CdmtfTFhn4SgwDXsHrjA2T8iHhUum9Zvxqp/YXBavAomaINarVw/SZ9klqlUveIYOcpKRfsA62Jm3oz1DKyvcuXoi3UJnD/3TVkcBS23SVQDkFwxW4y1+VHsUawonqHy1dsNHvKWRfoyutLlqqaSlQ8IbzAOfzzShzaDPUFHCJ/TzCN4WZ+Btq9pr8orQkefcK3mUgvRGywuueRpNk6MU4+zhfa3HTncmD7xQFXlGgo4HGzPGgwnWlSdIexGxBgDOAc1oH7Sdfu3KNifIF1bkEPuax+un2XhmxqHbLgcoAO/I5ES/esEU/FDp50MMYkBLUta+SA3hjtXrQURMQoCLiycLTbokPqDhLWtPOivNUYcij2k2no6fm82qp6AOCa/ADLAJfAAbqaSTWrG2wT7wDYzZmZmLpFuGucoSu49OkOHB5TJWoEXSvACLnKHLc4EtYEYMOAPuwTd4BKayQ6Y75yNYDwpsiQG5M+U4odfzLp7EArMnOU4ACbAGeYRM2GNo0grkEzICjSkWsAGLQgUGIRU1ZoKHx3qZcxegFYXyW82ap0yaF1c/qrDptjst7ANvWTu8Hurg6ecWDMd7i48pxPzAKfYb+yJm15lF0BkT+p5nCMSdJU/1z6HSTBll6531fjdiFdkeqSOLGb1jQ6VBrUCtQbVgtxAf1xGkndG2yzwoOypUItQSCMh96ifeO2QasmnPVzl8iKtidLwLeQP0UB9z3GHneBqOtUfnlvGRNycpb31B9Y9S07O4HVg1kdiG6vCkxC2N9Wt3nFvc9HZTro+fgxwSYEA8AYDoviAQX/+BhaiVpQQz4svKVLAFtR/UwOG6gdzCJ7CD3DSSuSmH19qkvdxhZUhPV3k05iLNx3N18DroMWecDjcg0nNV1ejUrL6qu7eRA5EFLO19Tsq18QnnMECxRnwyFb/M6xAT2GiYITEz3pPmiCkPxCvOl8qhr0kKXA9CEn2/S9e6bEds2BTYCPq9xBBqm3/gFgTnya41US4x66TFDj9p5RkklUNVa+b03bzKcpWqlUr4PzKL0yfwQseYPRGsH8mC6/n0zt1BgdFJHxeTmgcFvzDsJzSQLRkXJTN6wfNXdkc/N9ZUffFNU72SLIWpEVe9xkZpCg6NtWZcnSI0MA1P2m51FNNgP17KWpgLq6apVlgywBOQciYLZ24sO2Vx1VDQKqWr5Gw+3uwgXMUwbsImX8glvLxlnmvkR1BRPG7i1EtLrepihXNU4YA9XJ33CCRbofOPk0vb0ouonoUKFR+X6MwU4484TK8v89bJ/M3InrchvkVq5/pB3ItUUSsdRdSb8AI5ABbF+1C80wJLUfHXZWy7XHM4f5wQc6xYsgNZAB7bZwOrPz0jURsSYw55wfp99/UM1kJ9JN6i6dBrbiZCWD2QxfVURF5ziyxEitoFwa8Ov01HFiMIZ+ITLCMr5yIBszXMtx1H1nyGBoY8vinWf+X+UlQMzUEniPGVP43tPRQ+El8+WjBDd0THcbeY8deZxJyUBY7HBUJ8CYuC6LkFQfT2ogArCawFgjqOU/im4asURvSkmIM6EjwHlIY0iIE+Cs6q6hG3YAs9h0istmpFDQNgPM6LpBNbzSeEzqG1tFr/GJkLRana5gy+H+dW0VpaTX+EqgYoZ4LYIh2WTxZdTeuKYEBwqfZqxEqTuX+wWt9avx/Q7wDvPh8GeqvVgzWT2aqsgdG8YNorzq0pqbX0h6oa4wtHIr3VgzWT2ypaS6vpj1CVeHLxhOJJapST7+yqJkqLnEv1hrS6UMfGD87i3iSnQws68uJbvnVVFgKLr/se1WpXM+2ZjUIlU5zU80OPUSKxBSP11RFHf/6aPNpjB7Uc1DtyZVSFH9NR1T17m8xAcLHUmZPPpLW0UYlO7w8zHpjWqyIwEOem1OmBSc2N0wzER+l+GgqmvRXz87zg4toYTQP/oqvNAkpckdVFhoyp0ovhWtrU1Q+I9gohVRgi39Vi7m0RwZHcyr4CoJVYV0IMIB1nPKQN0inSRXTlbKlOuNSFdtQtvmhAqZhai7XkYNrtqEvoekAga7ghP8kfFm+j1dqD+jBn1so8EXfmQ5VT5vPory6h8GILZmRdMnvqvKu3oz32MapcXctZPSeS0R7rKm2EQqOd2LVYcp5hvt9S2T6EDhZpMoO7OpB3FDnzT4y8xaT6sNdQciC1kTpWO1tQUqfLTU/MKB8Gy8ogodEsl2a9/uHvsJTywhi6RSeI5kxfuDdNGI2MnpHJZnn1sKzdLV7opExmAl4GKAuNnytPHklN1s+i8I8ErKuH7VAqw4BlCPibjHJqCOv9Fc6cFxRlm49YVhQjcUlGE8w3Il0wroM5Dx3XXDHmO49fPg309I7NYG31ihQ16wuJFuO8Y6mPwkicnVdZj5V7a1J86HV0OFmAzfBx/tD+dl4dgRgFkM0zciJftZzGz+jeQpRd3GwhRjF8FTN5lZOnPhKWVyJ/H7wukwNNDahSo2avlqSYTnmeXg5ciUajcn7rfhr1YDhnJpgJDujNhBKd4umCiCGkkiaYqJLmZQKFubK77pUis5R0UFNglCASbFJovRaTJ5eLYPAJKu+ISHsXYrNaLGe/bxLdq3RoLq1rzXKFvXx0G4UZWN+XNg3RnhNEuglhyRjBm3MGl8kkpbiG9skGn03y9kK3h5LqsavF6ACuo+VTEV9yNFJ50oJ0pnlRmjpZatatqwJTTDkBry05n2q3vdbIZtKxiBBbxNDmkfUHPA8YacObTeRhRLGSJETTN6qnMwx5ngU6qQ/95vh0sn//zAnJiwjgymV6mk5UGtcjNY2MfQ8cjCXUlfMHvNncfA69Dj3CVAV2ty6ShajVv5UR1Vg7knLi6Ij9n/O80jjZexqMJZsAwibulqO3FLVmrlCI3/dwBsKZxFwSBzKduRvqm05a9LA/iJNGuWTJJZUp6jIbgDxSRskeA5BEgDyZaYpJU+B0KiOR4XBhl+JNkoaVX49VlnpTENqXEuoklUvWchYHdkVYaaU0crKDpbK8wcpV6n6yhLqJkAO8qVJrDh3CVCgrZ4CkcBivd6+R6wbNEGuXWHs7yVICYh0TLHJB3SBTwBV6UayHgjv+ziB9gPwAUgn81h25Yty1gEG5wk9g6NWG9uI6nZkBVGkk832mtlXGXHwJyFmesralpRxj81J8T8zN+G2IL8PnVU44J3+ER0SZytI2Ciuo27wQD/tTxjT1p+hJ+dPPQTAvBYfGjL2OQ2sOnTkkLFHZlaZjSJoIGbR2mrQrZNvFfH8NQCqRg0LezkHtIbPZO4+M7A97EnAgawPwWjV2w2I6ojfAJzzXc5FGR2dCVYv5rO95yxIfpQ7ns3xaMEIVy4k8le2Xgq+vxE1Py+Gzb26+C83JLNyFRnIt6rtkInIuiUkttNDeGmJjwoi9SyZbLfSPlY/Nl0wiLXRsXckKaKG/pYbY502uIS10LCWroYX2gn2k8aciTsR8n84oflHG0hMf1LocuKojeBHzHQg/bvW5nyYVuMvxjF3uHmKKIl2XGzygBkjw3EtXC9o+DdYfCedWy1qyBMqWpxcaN7BelCZovk7pq3qAYjmftP0aP3WCXkg5pSpPK7X25JbUIRiptm2snACU7VaeAVf0ca5lILZr2obXz5hTQ8NiP4n7lQlXetn5EJsgha4LvmFIVx7dwUNCmum6f+wOG/VzRJJsUgdZqVtxjbzLJ5SJXkJ6AKN1yTpsV5T0O+eQlFnWSwarOxLqerptIIaxcEbMbMwBTdChc/iQeJUS8iVor2c4Durpz6z9r67Mql6qRrgqV8ORJ52QNqKZUjPxWOJqfQ6SBct3LpPKsp75Xt3JBV8lxEKMCEN5gcC5/jZwhX5ec2AYN1u38XotylZnU5PUYeFsIX0cN8tdCAA5lUL1A0BuUWS7VPIutTRhAnt34PvftSWiU6geYZ3GchPOU76I7P2h/fXTau3ZP5LW57f2esCwJ0CpfrKk3122u04rq7Ot5cH3MptZi9oclUphWdfy4nyaKtLnD+c5J0iiScJE5ZSrdgmlbbSfgZxls/tw3IFft47WJXOkpuv17/VVT4FsBYCR3Tr7Klb2gLHMMgkyLczHMGvCnAtjGt+cyh1UUsLq906e+4R4rzTvY641RKtBzMdLrOXWcf5BezmnrSfwvau0VvWG7uoRE7JWO79pp4UWaJR/KgvN1+8+tZLiJFp6yReoDrWu1Sp9XYZ9GPZq4WGv+fKI/qz5nNqgIto2YmC++Xw5nrTq0+cf0KJknVHKtTCDRWro1G2iRclX3Cs6qWPoY/2baQGBzwnvUDjhst6mhL+nH+SOp137aHs3vVy3gxkq28MsKBXu23baS5Z2HrURDh/45IvxBzFhVQIvTUjSgv4EtAFjlnRcF1A/jWnC2ckgi9DRvCI3+M8RgvkgZa5k4Z6CViLqwlMaAisVwC6sJmd333hpBiGFNbkwrtx2yrJmuiXLqlLGSctOX2lyBAQLGh0gQVg+T+UjCkVNXLV2UcyacvgdmHFC0Fmrg7KQQwBLI8rNmlG36nEQ/54MYl4uGtvmVQG7hcaMzM/FcA0SAtsX2AmC2iUXsCughenYb9GuUiXwszLBOc5PFWC+0HszWVy5dBE0WEJCr/w2CYCpiJ5BV/gB2qeqoNNfhRCPfF+R5RUQCHRgF/ZigOVKXCMEgSO4IgauJlTrvoNZSx2jxZGgcqzIEvAAq8UagUV4a7GUxZlz7GaIsSYhyDDVgCRpEbXxAM29MCsTdQCch4noMMK9G4xWAbzWsYMa+iJCJPU2DEcu0cOaCGBowbuwvySjhYml30QciGvBHVAK4dWAVvYgjx0HcHjShYngsS1/gLoN96I3wAv9Ue9XCRfGz3FQB5wtWoAVwLlo7fhJ3IbxuKH/OdmdcseVjPch2IvhA+SPYsk3hmJlpNHe6vdA7i2UW+jYaSYVe8yZ20IIquRCYfJ4DAXdca0Qrg8ZG0vHKKCOoBa484y+XX5Y/fJQysSKqKwk2cBtqvp1zHmb80v71Xm/KpNyjCkW2GY/TFoiskR0RJ4W6hv9AWcP2ciiqGUzLC5qAP9r6GeVhLRNjvnlwuyfcEzXWFYUcQQuVICBL7lgYyIBWELLKOPjZDlnb/FjkVlry06HGBa1X1A2YO0iN4y3SB2L5xx6x7xDzYnYgRB3HNo2Iljj7Dtz+UYppIkgCzfijcSxmVRosJxC5GnUVVHpkFTqregbuktg0JIIbcGjeEuiJne1sFuA+RZ0Oa6P97YsG8vLsQDtQoce/awrCpROl3+jelLaIY2V4gekcjbMz2Msa6legRSXI5EgR62/TaF/FH6hwtLCUu/npmG564rOBnW7aVyPW2ytpGBGWykx1TjC9eRx5fGnrOLRl/6FZ11askfamWaHyCVvpUU8aXbH/Rd021VACgl/ao52XJF+vAt8auJpfJabA7ShDQnxad9DXkVGKjXr/AW4pZ42EI9z+NxHTBiGRp7pIiCjNjnHSOx78bnBwK4lC5+lZd6f48c+56AJ1j5X6vsu6DMAhPJLc+gdEhqRnLCoocJ33odXUgPmR98e/p7z3gQQ5BbuMxCM806k12M5GiIP0SIV3Ut6vUV83JsggXUcIsvuqu2nIS+6nT6CE9LVmn3E5wEaPMsa5PqsxJL5q4qcpXWorJ5mS6d8a7rXooYvBwNyIvr9esk/7948UJOopa0k5MI8vr/tOXkMWRnikeZvh/V5Q4cS5Mxa0dEKtCFaEPXPW3tARTdyQgqEm+Ko4YcMnhzKYR6HCkd7O0Cs4OU+FK7iHN5OBnEFMVW178KfeK19eeybezq39XqYGTBUkQg37FuCvm74v/lOqUR1Br5b13y9fK7L9HpHy8nLBVxy90CacxvtyC0Wo3ryIODxmzKNjp0n4suNOPmGcuO4hq7q3zFdJhu0yP4NvGTNUz2xc4PUstOpYnHXnKnK1ZnlUGs4WzX8mdz4SkKJpZ0oD6D8OdtQDcUjS37KL19f8k/N3UXF6FKqPuSvUz7ud3IAWKlmGMrOsCvef9J4pXzd8fQecGeVKXxecrsjZzmayfnKetTk5de7a8sVqUHe7Myb3HtXqvVtZbMzaP+oWoygXdq6n90wonJyLqRy7lg2wKYNEg1O54S0gI/oIHtzyl3orBCfBYNWKr+AH/hZ43OW3XDynBXscltgvuGaaMNnP8Ek2T63Zx7OHODJ4Vrc5/Qo2XV3e17TqRiDmteCU0p9hzGNu/riu925y3UC3FQ97pBxIbySMHxj+V7+bd67cp1dtUD2SPc2B/EkAG8AqkjkF3CZckBuVuz7nSNKivKnwVFmT1w56vitGDDeq7RIiszuKqULsi8pZu0cXip1j2ndsVIYJU3N5s97+5iSq2FXc42jvESUEPtLwO46ziYIZZcJS+t+UKtyWRbA/rhWM94Y1Q1nHXVaUlypbztJue6h3GulbOWAQi8/j2ngW0oWI4Ok1HycPbkw6IW0rhYTk9nu5xxmUkaSOlr24y8YBtDfXTU/6l3gqgJCLlWS3VImDK7gR4kNl2QPq0A5aieyMqxJJqzLJA8WxUoww4yFge0OMUGm70iNUOVDWdWZzbZXGAg2pc0skGE9fPl5LdSDtWQJUJIDGA5FZGloso6OgBraAOiYF0knt4x1QO6OBkKIPD+SKDipDMLkJwPO5G8EpR9MwLGI2uQVo7bSyCpiAxX4hAiUbQIe5hXA3CbgE0RgFwKeIQJALyK/heTM2M46PM8vWQOFM4hRxB3ojbLGvADREalshRVBQOijbgrOYNDqG8yz+VGHBK7AMUQGG57VX1DKMHNYwC+sBAWMaY0UZRPHPEVpc2LLek+Ac2E9fMI9/ytiTi56EPQ0esxoPREvCi202YYoQWBeVnJHSbOnwd4pl8IDzyjzcUYgpbZ+TTxCOrWeo8CfguzHRupATqnjCX0g2ehr9QOjKe2sp0OFTtGoaIq+XmErgZDX4SsGzSyPodrTg2HVn5zJFkyrFQSAPfafNQ+d5IirJ2j7U7Tq3Apxp0W0PnvyBRZH/rL0c7lAIewEDq6B13jPsviNke3ncs6ovJc0mjnh8mDojEHL6ddJu5XRh7MecbrzUXqoszoeoccR2lg4zRH6V8gLee6T9HNC8wrrrbDuXJQOcgNpKoMQ9AKkOYJKtJgKAe9i74ldXigSQ2BVFSvrqS7pdLTEBVmSRZfywbqp+kpdMaB8KevrpHBNzTIt3ZcWi+U1f/p75c+S5p7F91GDDD1leQoqVWolabZIdeUaRvSpdRuU4+x3ib8PPaFpoU1w5b1aS21xJqi2oDiHLJFqK890qLPPG9RfAPCjAIyXxqTO9m9qSzzy9BRXbO5jvZ91FpnoSJWRCLqfYkocWZEJUIqilt8SZ64lTX/Hl32Io2uJKquHakI/mfvm699tF+QUwVwYMSxeCBoBIs9JVHKkASwLyFQvBiAuaGwhf60kC2XGvIMiTSWMiPyUWi7ioPV/66QZPw/m4q8zQnx//3qRi6KBuHK/VP/HqFDI7qe5kKNUFsRtcTVC5K/UsjQF5Zr8GRcs02jHtbIaQLjKdDvXeV+QYTxH0FnyYPmRTvobRRQ+uJMXeWsIW0mvaI76ij3W1esSVk+b9AJvcHqdbcRxemPAZylcLtpXPrgjyZN9vn7cJzAOVUJdE8XnGFOOeQCRpogOOkEb6CC9T6fZy2OuV3QZdjTgQdF8k9BUJnGyTdGw3m+NmDGf6ua2MEZ8BdyQ27jEQbzBNbjGgnNPQQ5nZDOpYQklJ55svNh4uXnnjNw3f5yjB7pbj3Ww+iroaruminERrmXvL91Z1JU47rzn9gAuitRZbHVj4jXOq7B8KjsvjrTRNJ7A0awrjQd7NEXzePEbP8Q2Br8hhdxV9IS1hWxrOB2oq9IPspNSkPdp+WZfisvOcmqJPs8AkXbNRePSxj7HTtIZXssOSXkGOpfjgCu3HO9oJk1YK8aIPQz7OTXxkCPLAv2wPMYfPMpsM1mecls7e40Eytcag1i9RMBDPJXGtWYNxwx1CPqrCBUbDfFFMn2/2rW5tOxIZIvJZsRXJJHUCLu+zQoIVhQZzMvQTk54YWvhBkdxNoNBO0KenHvJRDa42TV+Dz+HSzipGguxlV7rFgLg29w9iXO/Vgr7mZbSjkHaH7wqG6D96tgcCmfOXLTQx3zrurrVs9boQ6uV1rrky69oLdIY2h98AOcYPHqFlZaF64MchYovpXPdZEyoJPhuEPToV0I+aktlJAyY1+femlW6dLCuEiukM+HUtO5ziEw30v2hq6+i24IexUu4SIS6BNuvJt17+p27993qJ9pQHbisNeczlbwGQvFB+JQ6ZUoWztqrLFX20mxNqSWVH7qS7qbVe4d+53j6lS19RLdcJ3RCOWoO9TQV41P3EfiNg4B3audTZPFlMNuDa5I9b2cdXxPa2ndcOM5xjBVm7csMuwJa8MM80+ZqAEHJbRi6oNp/4GJqsUFDZKoxyWCMMDjMkQfutNS/F2sFzJLziaxRFswuu0GWMDDuE5TT6f5MoTolJgTveDofdg4JswUvm53uisF8p1OQBE00Ubog13TTN+XOZXm9QNo6N7XW8vZnaJSWuSZc7VOEMXUTarJpEb1GhmH0/APQE5D5TeMOmi6KNvURw4WYuIi5vcKt0RZz0TIq5V8w1MboTOsM9ggeJlndBk9llJ6+7DFhEFUoaaJ5CGLlWq31pmPHlH5e0tApU6k5kfVnSAqVaWTW2UO9p/xxp5uM+6UmiMVJnK/Omm7hvtTCNKf5rdyM+swGEwLWxfIhp7/dJemwSXdkXwA+GphG/F8U/CUC8OlNNwDeTeGT8KKUYbwaANRTOvsEgvR/ASCE2kDY+TqAYHg1QPjY61fe8dddpeof0pSuYGCD4/1Bb/895erbbFNqnmQEgiAIgiAIgiC/Ap1iY74uxDxiKtNOVIEoaB6GgIQCwPgXeXnCvwK+jZAPBQiTkJxoQAQKQUQWrJLHMV8wsX/c3k8BNko06HEP6hHqwEQauKP5GN9X4v1/6sf9uEKaBrJnwB3NIsnPC/svXHhFOwXVUDkixkgSor0bZqYYXDHNMoOIi/l82QpyXhULLU3wY9gD0IZZuaLpTcXdGsGX9ajf10AN/Rh921BgNDJYuE7gzIuyjBOLNDCw9Hq3AKKSQcx45LlXeDdFyK58oV9WTLQtEpatgp41m7YdY/e6VIpTcZRbtnjAq1d8H+xnYEnKa3vrEetCTxnzjoQYWTIqAWe5cHv4VxynGt0tOKJTFwYMj9HagCkx0sDAclIYB3etLrFiK/SKF4ICYtTn+Qkms+I+j1esxWIFyWzFysZbtC0WsENqc3054jb0Nmyt4gxsF0lj4iGpjF3n8ZOijYmWM9UzZgqb7XsVFYvlzmRZNhwe7W9DwYSegY03J53JAffypt2W3JZ+rmyqVouiFWP9+GkhEMSoTaKok6SpTpvjO91YxTwWy8WtSMrsxsrGlgRgh0Vt+nzo9ZjvQ2cCEwe/o5rQ6VjiEyfFc8DVQ7tvJalsquZqBn2931+JUnhLR0tw8+jfBzgsSUVt7zzQQjCIUUIULZdULGLVCq3CGutssGmFXZXMcVjZsgUGaxwe7c+hXAP7HBbg8Ah6aGVBVc1oXpcLFS8RY66TEG0hjJKY7VLPN5XvixAkFADGgjLnERfEXeJYguPGxQsBESkZP8QrT0NBRUPHaG9Qjqp5dbo5zVa5oDpK6kC3L0fXb2pgeWpIPoyuID6HOAQklEPXo3GkLA4vijNOzJGSQUFNS9AzAhMLe+10LnP5pNdCQU5YBHGz+Ve29l9WTLR0LWv1zmbv9q+JTpnIC7DRssZQEqKVxDwlacoRr/i+TvIxITexkQUTY2KNa2GES/xKxNFydx/n7RU5Ts0DZo3RuVGTbo7oVsfaZibGxKKO0e0/o/uv87++XFY9o9+AhnaM7kOJLNg11MfgUZ8vCmNiBdx1Mm5mdjExhk8clAYGll6lgqFFlIxjxiPPvcK7KV7GlS/9tuJz5Zxqq7UWTSxbBT1rNm27x+6FFeIUxCgpSpcqzBLi1DpRB7byWMskK7K1ztIBJsG0YatWWzPT1Rv0fehhBmydqGBgYANbiR5NUt5HSb23h9fPCz3HBTEKmKBFITPFzWLmUPN8CEgogAxScUQsrXS0Cmuss8FmvCEgJoGMgoqGjmHlua9K5gNgZau6atWEj81hbTV4yDzL1xF8GyIKwAHQsACPSCIFBR2fIyAho6Cq0enKCEwsbD2IsBjT4pWjqapFU0eLvJWPhwrx3hzYyCLsSjCwdRYADKzWBQCD97UAALxh5U8AAACAUzrAJbXyDkrqvT280kUCNeY7CdHSYhpJmhIXV1M+IpD0BkrgVUzNEhnXJ48mCBEJOaUjFTR0jPa6c6BWvdat0RzVoa7VW1yDB8hbUMPIpxFH8DnEISThzUXpY8MRH6P5HCSxfol2m/Q5uSlFqGlJumVYZmBh65UuGE1YBHHJUHM1tTW6vT28JiugdR5fb5xjcpfpZm29RTF5OvpfNpoDx8yMrEhaRr3Y7N1ZqTeVkdpJMayOiFHQGIeEqCNhURJTxU33szKY9Ve8sDnDzRsbAaTTLkXh21KaIVBAx4irzS6iOdaJPVJLLS63JeudB6ioWK9EHK0solVYY90Ns9oMeYMSZiYKCbkP18NrPWc5vo+WkpKkGho6Rlt527DDrh8HrOjV3uKo9tcHcx/HzHqMbMuhGtVHfzTSrVk316C73dyzpV/QO6Q2HVEHun1R66v1s1e4/qAG5M3pOG9Y4DeKI/gc4qIAHcDwMMAjkkhBuSeFfYecaGKKDum4+wbFeqfi3EuoK+KbboLEQUjJQkFNS9AzDDMrsJ3E5xiuniN9m1lghEVG3F3SwyJuST0VvThvfJRa2TjzwhVR2XerVENTO4GuhVi2op7WwabtuGP39f54XSkqrBWWLdcPeB8KIRg85agf6UImixhklGVMFQlRT8V0lCzWu/hIGy+9DeahCIOE8m0+MwGgY4KrzqLMVZwca5Z8jZvZyoRWxRrrbLAZL4REkJC9VthyC31ESi1VaOgYbeVtww6762ke6T1fe8ui6m+tWVdROz0Okl4PkO05VKP66O422WIGiw6p7R1RB7p9vt59sU4NNiBPPa5xzBC/URzB5xAXBcsBGGGARySRgnKPz75DHdHEFB1yHc287fj51JI+w2nnHj8BQVEVEnIKqGmGnhGYWNhOWsgRrp6nfZtTsETCIiPuLul+oTyQ9GS89EYfXrlcquqgqR13dM9LnNLX9D8zhfZnRSCjyHomRkZfZnMQkFAAmIodsbRCq7DGOhtsxpMAIhKy13rOcqWUIhU0dAwrcNVx/pbDX9tfeubDYGVbdXG3ezmt4MN3SG3yyPcj+DZEFIgD8MMCPEKQUUALxWMtvhUBCRkFNR1MbCeVcHALIS4ZSklVHTS7U/ajwlmR0kYCxtSREO39MCuJqc5XIo7KHexljsixatQaHcw5qgPdBjTkGH1u6ELnYROLNDCwnARwcPV6vyApoqR7tC+8kDQiZhgFjKkgIYqGRUnWCQA+cKfAdxIIyKbzqPBtZjMKKFowXHXWJuYqzo81S4K4ma3MaVWsuQ65AbZZxI9LECIS8joBBr4mpBSphoaO0VbeNuywa8Ws9pZC1d8aNP88U+b6YWV7DtWoPtS7sC3dgnTYVJuOqAPddfQP3E3wVeSNWBr4qjHEbxRHMLNcFIADQGEShykRSaSg3GOy71BFNDFFh1xHM287fj6j4Gc47dzjJyRMSxyBlAwKapqhZ4CZFdjr6AcHH7gUvlTQRFhkxN0l3S+UB5Kear3AWx9euVyq6qhZodpxR/c8+gf+7zd5PjRQU8VdErdcvv3Cm2j38qufrHWahXVSHgdXL1Ciita9Sy98DOaFpi76zzhNu0gtmGKKKaaYOlHtfsf1gHV9P4EjUI3mkQ8tbwoW5x+9+wCGvbz8tuS2/Ou2L7Jn2cbYY7qTfWwIchwOCcOBInihV3qpyanO9BoWuuR8cRZarLnU+d7v81ehXcNyih/36/ZbM+d40Ls0coNm93Jb3KDXH3r9f9Dfb9SlwPVX0T84ScHBbZabFbfofMuoF5s/3XU+qjea+Lrr/QYv9sbp8WahgOPWhFAYIuaFEmQkUQBiaha0xCuBRENCRkFFQ8fInEM9D/wjuA8JJERkEQW0Iy1wSSSDgoqOiU1I3KxvdM3sHWY2WHv5MLZ2/QBbWAAAAAAAADh5wLNhiy5aM7o/4nqg59MAAAAA0ZOhoaGhoaGhoaEHbRy99weX5gIaGhoaGvoX0xv90tddP64WAhyHROQYDhCZ9yYISKeLR4Vv+98MgSIGZzttoWzzI1qgRWOpdwSfIEQkZBRUNHSMzIVWNw/6vY2U3KBZ68GC7hed7quZ9YXXcS2fK7DPIQ4BCQV9HevLRhOcl8W5SsqTQUFFx8T2m/+FEPvQ6WbjzAIVqqNl1IvNsftxf9x4FRp3hBfE14ZRGIXdAgoA42Lh+BwBEQk5BVQ0dAz3i1ene4G3VpEChXMgJKEFCjrJki1FqOiY2ITEo3vUexYdY82/MzF/MkeY1yGhJdKiAMTUWmlqVayxzgab8a0JICIho6CioWNU7c5cUHVqLRGYB/4RfAyxLxvMgkcUkUmUoBNIMuQUUNPBxCYkruqr8d15NQu5TgQ2768EDRlVBIgBPiESSQI5JUl1NHSMzAnUbfGD5IF/BdyHBBoCEio6SSIZFFR0zGwIiUf3aJXXkh0IJArA4AlEEplCpdEZ6jz+PXgOQSBRaBKZQqUz2UIxNUf3aPdsYcYMwSK2e4FvnoaAdLpnoiIAjIW+E08CiEjIKKho6BiZM6vLe5205VBQebV8juDbEAhIKGhHfQcuCeQUUNExsQmJm/WN7le3N/q7r7uueI+v4g2+ih/7R1FXccfm6K37dBOsXu+WhCm3PG9BK2O9t2exo2FhB7uJBSwsLCzsG7uangx2RStnvVTpXtsZEmAkGTA8Rt82RETDwCIgGu0ffxHa81/nxX2YhIM7+Tx+fPn8oAgHBwcHBwcX9ykRLuXVZygqygruXw/8Y3jxfE1JbYJCpVKpVCqNRqPRaDSPhUmSZGZmZh+oecRG6ZppWmut0VrTxhhjjGHEC+BTozDnBNd/3HbzbR/2R/tl87fd1m3Z6bqJp7J3YM8xzl53VIeyZygdR+bvl6hCasFJY5URwYjqwsYGx4VxzZZ2gbjWkW2yIwqJUXEHOvm4xN+STw7glRHORM/jUif7kqO/bsDNYNMTgIItWiNfqbUmtY1uA9j2UBCm84LLHqNnjq/PI01dp8dQ+ws9kSYzf57p6K0lTtiIkq+Y0KRNt35tvsvkETscS+3PZz/z7jMMJpOZdTyxWCwWi8VisVgsFovFyh7NZrPZbDabzWaz2Ww2O+cJ43A4HA6Hw+FwOBwOh7f8qhUt3HW/ldrpPdv37uMTYYRaegZbdCFbjiiVzXkcFGKDGDVUFDAVMA9BQEoxneVZebjMvr5QXsJxvo7gc4TLh6EIk1hyNPO0BLBF5yADzEIQkQXa7CBapTWODouwe255l3hrMI89c33VPo9EBSCUaNDjhtLH/X2Kp/ESM4EYBddqjYYfNTYACQVwFrKiR2ZfXxR5Ccf53VfgHyNYn59nECYpkqMZ0hLAFp2H+ggUEpE2W4lWaYojXHTp3XJ8fR6JCgAo0aDHDaUPGlO5O+hkDBW1fK3KcFeyGO6KKAes3ZRrZ3RlLQ13JRw3HJdfNIoj+Bih587CHe6yBS4uLu7pYrq/DRVwQkQudtHP/YWLi3smXHji+RIuLi7uqbe8T++L68c+joznjsPFxcXFxcWlSXM0d4H1pNI8mWObNyOiFulQABnLnWVZ0S1zkE1Ztbr7Ismj48gfdwX+XOnR3AUQKgI7SS05l7njud40R3M1hboJFKKIw7bZQbRKaxxtjQ7XOqfL6DbpsejZr6/a55EohtMqAKBEgx43lD7WmOrmu8gJAhIKAIOHfwTfRiBBDiJAaEQ6/tQ0bu2vSICZFDhJ8nmDWo+D4TXS+rAxIUxTaCKhYXru18DAIiDqvpWymqvledGfXlzQm6YYBCMYIYTQm1b3k8ErWjnrpfi1IL2sIIQQQvAwG8+CZdmxC1iSBcuyLHtS2jCby+Pr65GPVgmeaBtirpsy0Su0aaYZyGxpcd0E/cB5VgtJvdo1GPQxzYjbLB+zcZvjcy7PnxeEsGwbLXW0QlGIkywNWfMQBYu6VaNmUUu06dClV781PNoTjufxXVqP0TO9JX16X/Rj1+8afD/SrBLiRyhQokGPe1DBbyOCazzg9rIAjlMRqAUaD+4Z1uoC3+AqTmvEaXU/AQI5HacrL+iElwZcHa1oCcgpp5y+na6ZT97gYlodNWu0agcduvTqt67VHXC7FkAgcMCV9OlLA654/4WXJj0Jf5Fl8zEzMzMzMzNz/zs3InKOiIiIiIiIiICAss0Gm3+ZliRJkiQpQwEAAMC2bdu2bYcYX5AAAAAAAAAAAAAAAAAAAAAAAAAAAADUHWpJkiRJkqR+CeiP/bZt27ZtO9b4Y/lU+12pZdvytiTbtmRbzo0hAAwAAAAAAAAAAAAAAAAA2AYAAAAAAAAAAAAAAAAMAAAAAFA+/IgAAAAAAAAAMKONdQsAAECgv6UDAAAAAADAxFwLAAAgsPM5pLm/5mSMMcYY4+RkjDHtm3r7nb211lprbf+Wlp9XCgAAAID6NKirszYyzu9vLyRJkiRJkiRJCkh3AyVJkpSHBAAAAAAAAHB3d3d3tOMfH+RmxXp0OUlk2qrCNePYrLeQr7CQuMn/YnycH9MAMLk1B6beADCNYuOeE+9smcYzaRlZA5gee+619wEAAPgCZQMyHwAAAAAAAAAAAAAAAAAAAGC1eIQJqe4co3ibeXjoBQAAwDgNAGBB96McAAAAAAAAWNS/G7IzR7bmcgEAAAAAAAAr9Hqj+ZoGAAAAAAAAAAAAAAAAAADABZONZ3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAQAAAAAAAAAAAEC48U4Arx/+vdzdD1bWkPk4PwAikiSRRESSNGHnRaGq7iQiSb/3tcqmsXHOTauttd5Gm1WHY46dm/CEqlfzQyTwN6YrcX77Yl8AAAAmITEpeSY1LT1jJqfawNSpOwDARAyAiR2YlNQBAPsCAPC773gALEVmIiLHGAPMYAxgDIyZhMSk5JTUtPSMgRkMAIyBYa7gHRIRGRU9mLgxxphJTklNz8wemMEYwKa+zbU7fIHaKiboOQMAAAAAAAAAAGABAAAAAAAAAABA0RsXdBXrCCHkyJEjtMY1G4Smvs18+arihl9lAZsiA0yJAVNyAADAADARkQMAAAAAAAAAAAAATOxM3EyrrbU+AABMYlLyYAAAJjUtPWOm7XbaHYABADAAAFNtAAAAAE9wAGDq1B0AAAAAAAAAAACm2sMCPCKJFJR7Uth3yIkmpuiQjrtvUKx3Ks69hLoivukmSByElCwU1LQEPcMws+Kw16+yyAUAAABgiooHAABgeutjADAVA0x1zQAAmFb1rdsMAP4bNe4efX1LCCETiBlGhExSckpqWnrGTPXu5Z3juJRyR8tDefRCJq9CodKZbKH46kLrcQYAAAAAAAAAAAAAAAAAAAAAAAAAACAsJQCAAwAAHDgAAAAACN3zu0ODiEtYfOWr/jny0Zd4dndpt9ullNLt3H0fULuw2oXWdomdyckd7WJeO4A6wRirMTZGjY2NMcZYa93XkxehtGWdEtwTYNz3aQXLMMHWCaImU2EZ+kz4kvW+PPclCKmZ0ebcRpHAwpEklsXmyybvE0C6W6xDKnKMY5q4UynNBrlQ3KpoI7bs2s/H5VUfBCPEoaHmseVO4txFx/W6q+r1r4YvTz8tHlnCu3f6+5RZ7wWBrHwXORJlTcD/ZoXpIFJS0rd0FYs5wIKUdKS7Anz69yxbprnkCCQGR88wzuXXmieESa4pm0x7fmVifZd8Wis9vUe319fJ/06sqK4u6rJr6IrFuZl5FMsIckRFDYlxEdqlcXq82MTAeV+TXCgSiUQikWoTCXA5BlHvf8wU3Xt375BzPZ0znHiPAAAiBIQQBABEAICAEHIT7rKduT20lhgxUyluTBQjZqqNmKlTt0HDa3QQM2kZWTM5uTNFI2SS0Fy9w8SOSUJzoGcfdT7qAwAAAAAAABj05auzXEmOJEeSJEmO40iO5DgACCCAAAAgIiAgEqHevtvIa0vdvPqHaX1Y5FsjgJVSSimllNbGGGOMMcZYy/D7bR7vNvTmQs4/jiiPTuxMq6213kabw6O8yR483lxtQw/zYBEen7Dw6FS/muc9Pbq+/f8d4ePz+UvY8PHxYSKjAjEDfODz+TCJSckD+DBp6RnDn2oDfHx8/tQdfD5/GuY3uoI5HhEZdQ9zo48ApqKNLRGkZFBQ0xL0jMDEwm4yIsdw9VooyAmLRHzN5q//HcGFqa0bAPi9+eEjN+uDxBOmyIbjJiowHMdNYlJySmpaesZwM30CMHuVh4l4yOKhiN5M3CPZI5OSmp6ZXVi88X1XIm9hU1NTU1MAAGAKAAAAIJhuxwAAAAAAAAAAAABAsDr9AAAAAAAAAADM6l6PJEmSJEmSJEmSJEmSu7u7u7u7u7u7u7sHnbUEAAAAAAAAAFBVVVVVVQN1wnR3AwAAAAAAAAAAAAUAAAAAAAAAAAAAAFNR8wUAAAAAAADTAAAAABClKgABKKEAEAAohUIFFYoEgAAgSIIkAAkiSRADAAAAAAAAAAAA2kdKM7OJ4/MvrlvdkiRJnufxow50Oh0AQDJ8fSillFJKKW+iPx/Q7/TH8dLPnD9uSUmlExEZFYiZiZ1ptbXW22hzJiExKXlISSc1LT1jpFIpPynpZM90d0hJpVN7Jv8KIAfpVGNYgEckkYKCForDxrciICGjoKaDie2kEg5uIcQlQympqoNmd6792p5HkckYY4wt8QkzScnDJi09Y6b6yGRsruCwRkRGPXTySDwyKanpmY9NYfGru78n+4EOMCVGPiUHTETkwDQzADCxA9NqawNMQmJS8mBS09IzZtpup90BgMmeqTbIJzhTe6ZO3QEAAIB5iOQhidpM+wPT4cDEznQ+wCSnpA4ATE7uyAEATC+99TEAAGZpGhsKCoqJiBxNIGY0CYlJySmpaekZQyFNcCb/Ct5IRGRU9EzcTHJKanpmdmHx6Nfft3zCJ0uRgc/ptcG0MAAA+AQAgAkOMHEz/TOTkzsApr7NfH13I+9m25gplTYobZttYIYNxkDJKCkpOep+aFdVVVVVVVVBmXLZCgAAAAAAAABg27Zt27Zt27ZDjNd3AAAAAAAAAAAAAAAAAAAAAAAAAEASAIBImJrzCwAB38sAAAAAAAAAAABgYq4FAAAAaNbrAQD09HoMBBK1AAApBwAAAAAAAAAAAAAAAIDhev4CAAAAAIAxBgAAAMBgDDAc11sAACAEX68AAAAAAAAAAAAAAAAAAAAAAIAqSZIkSZIkSZIkSZI0cVzPXyRJkiSpvpH2QuHaP+/d9rZzetrr6TgyM1vGFLdwJF3MTCJDErOxIQ4Xbrumdrz361u20t5XJv6igN+xnv38rmgC1tc//DzB6yui336Vh8pKQVJPBfYi7ktUkJpJMsccOZfAAk+GSjRQukMMM0kTbGGXiltNuDYzb9vetnt+gzV+LcsX9VHoMxIdaKhx6gyX43rdPfT/VM523X8R335K4wl8/kiTL/TaKhQKhUKhUCgUCoVCoZ7/RRxb3c9te/4R8ZNfdXHb7faM201rQ8UxYnfbjMPhcKf/XyeiXDjvXy3PS9sQwz+36T0lISA3fvj7EtdNHTOjyBEWcNIsm/Y+THdYNWadtiEwzUTrQllrtaFt9/wcU7vI1eqdwIGBE5dxDbYw2LZgwwAAAAAAAAAAAM6xpZcAAACA07jUrvHJKr2a0l/modHoobfMYugVCzQ6/Z0fGn29/PR8FqWVF0XMu3/s+zIeOQI5/4QTYI1latnA6V2qLxo0zr+qbKb3JRSpBfIXAnxOpxPrQux6LsNvRsGBKxYgCIIgCIIgCA7cTkkXIAiCIDhwQ0C6TwylImu/41gGguCJ1oXilt6qaANbdu2XgsurPgjr+1EQBEEQBMHohRWKjulBe8BMkwlBlMxPNsm6XN6fxzcEQRAEQSfLdtfegaJDHIIgabMztGs93mgtZVrFOsohCIIgCIKgTVlz1oEOQRBUfYifNaBUDQktazNREeeXrz33MvWoN5tKoa0KxdqaUUsbJ3DwmFhHEnXNBtQcneeQI5Dzlz4BmSIHPQPncf3P42zh+GQmiDHGGGOMMcYYY4wxxhhjjDHGGGOMMcYYf0yg2XOZnCA5Pa95DE0v4pk2O9VrL7LPOcT6fnfSUiP+cb5C2Vz/vnixnGRRHet3Tz2/PB7LTZAjLGxPmmUGM38XkwvMzpFcrd4LCYcGdSo6a1xaPQArNm3P57MGHqfCqOWAi4q/XyZEjkBitHXloG+A87g+7AquLTGvTnbKCrbOt2FXdNK+qJtJd0IgMVrEPZWzfIe9xjWfju63/TInRyAxOIbVmtvaM4j19TYOh8PhcLh8Hx6Px+Pxw2+VBf5nv2ydIUcgMdp0js6Ma2EagUAgEAgnFmufEgozi8dZcfKI+1wdCRNFEkyTWm1rVjnZowRjdfyQkEUJOtb1xaIBAAAglgv9/s1uRETMvpyWKh2EEEJI2ZjaSimllNYJlDHGGGON8/snoWGNV6fSRPiqEvXLS/j5/GFDvOCyMF5414xIkc4DMuCK2Lsv+nHB2vdrmGOTGvvHOZk7USYc6eBF+vtZIS+uwOKF9yIdKxNKab7FBGSacC9M/v6CYYxRxg03KYWUxAXTRpcrykOholUS5SpNVKlVxwZWy2xLolNX9OqrAQ1h5FiUiVNZzUa0oGW4Al33EF0QGw77pOWF6ezxed/FOzRw4P0aBIPf1zVtfWObDj+vbkUkDv9+TXzsY/tibFuJBzogU4DvPvDceLYzY5DdTWFT2NgUNkVhw0+yjFxeIlKsvsFN2f/u/nH+zACy8cOvf5xOsnYRvjpOxcwUGKiXfvex+yVIScelMZOpWFCpLpuu1KJuH7OWuA6jHXt/6XUmc1pVRh+0noNJZk08dExOFL7SKS6TfF7QjdtgEiEleR7TjpWz8lCoaJVEuUoTVWrVqeW1qQM9+gwZMXHqdrMOFi3DFea6u+hkNuw6ME71m/FZJePAekumaZp+9SwGL6Ssw3iRCF8ZVDoPLMM6toYzTduopHUzYcWwqQY69j328hk0AK7927VzefT3nL3dy+6zXIFj3n1VP15Ja+VwBABg2GELWAAAAAAAAAAAAAAAAPHn6QfwvX5tuXWVJz8lywVk24e/7yKQ9aiTSYSvztNJIHAdGeP5W+F+sYykWJmgaFOZ7SbtUq5bjiZj/3rP8jVeiLjQARkD330ff1zwkDz4sIqIiIiIiEjyAcrxRwo5o6iykEKSJClChTGWo6B15cRoPDFnvBIyOl54p3TIRM2XIBWZHPfy+p5PWO9V1FkUBM9/oU73XWgZtEaP/x2VKHzhvWsp0q2B5xLau6f47y/ueSQM07yKQaU6tJix3HTfd6oDwBlfda2zHQAAAMilFYZdF2CR6ypgAACDHD0Y9qGZJh0wUaRI5wEZwnj3/H4eOsAAwMmM6+Vq5Z1CxbySKK+jBwBOV3NBzwOILgDAAADAsGnn7SfvYUTgnfYAAOS5v9n8q6C/z3yAy5BXWLgAwNDR0zc0MlkAgAt0R4BzzjnnoCN53GZZgCff+DoIQI7jTsYpiWOD1gtHXcNRXcAR/YrIrNpmHcqTrON4kQhfadR6ORjeasrkF9rtgs/jvv+wPgsffr3mTgjUu0/cj6QpvtGPm5gA+PCre+JP/PN9C18jboGJ3RfX/Ho94xfVd/Dql/4K/r0/Nki7YWm94syMAdGNxGCAwYwbvLvxS5f01hERVfJxTgCdPj+/kuv32Wz9dgK6qqqqiZqJqFmd/Vrn+T+++M+jh/uir1pi1PtZu9ncT7ue16uQGJX7B933F2I+iPgkEQOZQRvmoXagGosWbbjxeu9ZlUzEhnU9r+1mhnh8CtmyATOlIoCD7vtHgT4p9FVMx2rJIkPeTFQjLBvu+d6nMAcAAMDAHyrvN7DNyMIFAAAAcMkrkhnEdFu3dVun+11Iru0Za4emqVCsTcpGYMN8Yfps2ZF5gmEYhuVbi+Pbr24xPGFIjLbK7YLFsTg+fLFx83LlF0Eo2SrIVl4UfpFZl2cdfJNP0jFDZtCGeagZW9hwtVgholhpgiAIgiAIou+Wj7CbKwuTkQFfampUCwOKtX7++N+TOpAYrds6JI/JbupGY9m4L7uPCCAlUkJcD0RERERErEYopZRSSimlOs+6U4/TWmtNc/RurpYqBGnX0l7OYaJ0VBEREZnJTET/zf7kvanaOoAxlx5rMwAACAIQBIBotyzLKCqjqCynrx894wjDxsbGxkaOfVxinDUEhBWNEpA2x9moQnU2uRQ8x0AAAByAAwAAEEAIIIDwNt3sNfQz5xV//jzDk3MVq5hkkine9GOmfyOZZIpJppxik2sUmwrnLwpAsFBSWESKNhEjXgKTnNHSZobTTLacyFdQRSoBUuHYDnW94j9txVNM8RRTPMlTbIBn+uDxnwk8HI6H4+F4PBwPx5+oqwHG9WRcTZ/9Zt7v4/3z6zZu3R2/IFEdMzMzMzMfh4/DGmrtzMxM+zs4O+0HZUHsZ/gPrVUqmFyAbID/0yt88g5YE1dBsMiPVQ8irE3hQthqFthRwwHRTKcAwNEdQKMbWiZ60JIV52qet0LP61aKIbXKL4dHq50V2zqvR1sbcsbHRyO1y+zHSO5clvCAjq/vy7pOoB/LrgNh+mWZqSPciGo4KQYiKXMz0mOPZEGdx1C4ngSh9Oat6oKpGuPt2VUkhz3dqnVy2KOZ9elu5ApX4ce0s/kiWvpeje70bLiXOOZ0Y+VCuVPueb0b5WY5zV9LcbFxaMSJ0qZl4nXqkmfWvc8JXabk9s2aSW06v5bZJgnrL8kZ99TK0ntXZaY009B6X+NGZnJq1SmX/x+ITtXWc4efg4NT8nM36Axdln8nJ+CPSyThLFfwfA+WHl7l1zj5Hp3LDvJI0nULrxjWc2vr+VOmZWJ7TIreFs0zo1r3ntQCfndrLXNwUGvIFFrWcleG3nqe7Cz1MktOJHILy62WLndqLrw6RcEukDKJJrWXJYMhTsj6Pfki7If7usJOlTbJRkcXwOPbnB4tktltm9faWMtbtpRaeOFs1jvnDCHrxLNGZm/F/cXaiU1QJx4yb920sUQHIzNy62FU3VYxPTeafCtH12yq31s+ubJzKtb69YoZszwkoStfjg2WPY3/Di8hLs696lzfTLcdXUzLkjtDW2dXDhkzvp6eJ9FITDYRaOM96wm53Kn3BhlNGrDMevwO04kfNHI+ttX2wZN9CF03kZzno3+2cRUMDGBjXMXD3jHo5u4HyaR64r3B+QBLmzhsPQvclZMR8iRcaImcvnK3NDpLVAIyulKO7YsxPmaO6WN0TBvzjFnG5NXLOiiO02t2O9qbGQ16rYrDYpCxGBQSAYOAAF5cu6Dof0XyXLxnjBwXI1qERx7ygmer+iHURaUa9hnWrfIWVlve0F/p2jIxqWB6p5+PnjCQiJOXd/f48tFOjBywR/Z3ju6zJeLYZfOzWnBPJGza1Q6RnW2jOyyROHR74a4e7BGSsM257HHdYJxBGHee0u2rdupaT7I34F4WWC9f2uMu7l8D+wv83+vFrZRvTg4aw0X3Ax+JGD92t/b5dOIBw6WigL9K3ifLTwiv6q/szn3pjgSMqadwAtU46BLjk5Wxyz2DvVDPogcCdC7s/yR/Vb8MXKR7su3gPdrfvqGreJNEq8ZoB06iVHXkdwtI3Gf3Yt4sZKy2kmb+VTUfaZMvwSpv6GTaFGE4fkirytyrvS0VKIli9xDmHh6s/+4yeCNb+tmADbg3DZmPD/zm2Ey//UKQHE5L+rRXDZifa1jNEfw7qVYalE8MNxobari+dYV8R/JtRUDuBPw/C8yZq9Yyl7doNWr4OhZNv7yB4aRu7G6cScrsYZmdLTj0Qv7gxS89qs1EIwjj5pl3pX8oXn2kGAePXqzATkg7nWDc4ic+jpiUTn/eGHFafJDrErO1Uuz+D0Nqk8KJvZU+CE3YWZu4+dbKkXmrHbl6Fy1bYV5vPsKTdfdqWX6EZ9TeFLnY+j7/eR5/vcZ9tVeU5TdR3baZJ3EbhyFAWmx9Z69UuhSVNHKY817EOP5Awc8PEI56AcbDIcZ4tL+pXS5PZVhmcz/4KdE4GvvWG32A8VLMXgw1/0+oxES7sH/eDbZdd8u1Nl3jTKHeU0inC3GrQLMCrLtP9vCd+BnIwTvxswB4Aj8NwPvxATDwAt4HOp7D86CDxgtwpqNvo1+UfETOcaAfGUHg2y8DQBRfpnfbL03EqMFhhAoSFCghgX+CCrAjEQf6XfTH6bfon+4uQGMMf4N+MUfh8s0P/G477+trq8bZc/qZc8aJDX1zw1hc0peXjNFYn4wN+ElOAwaafqlBALg1v4ZP3L1zPIEHoV9mnd3O/ZNzPlVVrI2QkaGMG0BiVsRgLNJ6bNBL9Fcp/Y/wq8C5auwTH/0/QOytoY9DW8ueLbyvBZbbWR/+t5DeqA1a3rqt3Zqt3i7aaTtuaYupo4YqSjfVXz/rUsw5xHErmKeOtDLPGk6Sgiae6YKD9cteTOmrfuZIVF5IKHExPVJlJGddyvsJnZxt5Vl9n1BA8A357Cu+YRzC0Gl5+MQhH88syOsl4qg/xgbqvGJAffcLB7EuVgBOHx+fEXhSBFgU0j4w7Z6E9onuRoZkYEvchvzAupS7OdrlTa8W9uTKG59I2V43LpALWKCVgU85vfueew2YLajJavEB4B+++x7OcInBbx1O4KrTqkDgxIMSH6k3K1t5oEn1+mWc4gfX+ZILTj07JkrGjZWAvuMuX/ZuG6UrJKRLyDnOUGKOIippUv/FpeYlS8UtMZJD3FaOZcgsQ5EEhkDAy8hgPx6HxSDKoNwQN8gZOT2n48SEj3QxAAA=) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+body {
+  background: #f8f9fa;
+  text-align: right;
+  -webkit-print-color-adjust: exact;
+}
+html[lang^=ar] body {
+  font-family: "Segoe UI";
+}
+html[lang^=en] body {
+  font-family: "Noto Sans";
+}
+@media print {
+  body {
+    background: #fff;
+  }
+}
+
+.credit {
+  text-align: right;
+  padding: 45px 40px;
+}
+.credit__header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  margin: 0 0 30px;
+}
+.credit__header .organization .title {
+  margin: 0 0 4px;
+}
+.credit__header .organization .creditNumber {
+  font-size: 12px;
+}
+.credit__header .paper .title {
+  font-weight: 400;
+  text-transform: uppercase;
+  margin: 0 0 2px;
+  font-size: 32px;
+  line-height: 1;
+}
+.credit__full-amount {
+  margin-bottom: 18px;
+}
+.credit__full-amount .label {
+  font-size: 12px;
+}
+.credit__full-amount .amount {
+  font-size: 18px;
+  font-weight: 800;
+}
+.credit__meta {
+  display: flex;
+  flex-direction: column;
+  margin-bottom: 20px;
+  font-size: 13px;
+}
+.credit__meta-item {
+  padding-left: 10px;
+  font-weight: 400;
+  margin-bottom: 10px;
+  display: flex;
+  flex-direction: row;
+}
+.credit__meta-item .value {
+  color: #000;
+}
+.credit__meta-item .label {
+  color: #444;
+  margin-bottom: 2px;
+  width: 180px;
+}
+.credit__table {
+  display: flex;
+  flex-direction: column;
+}
+.credit__table table {
+  font-size: 12px;
+  color: #000;
+  text-align: right;
+  border-spacing: 0;
+}
+.credit__table table thead th,
+.credit__table table tbody tr td {
+  margin-bottom: 15px;
+  background: transparent;
+}
+.credit__table table thead th {
+  font-weight: 400;
+  border-bottom: none;
+  padding: 8px;
+  color: #fff;
+  background-color: #333;
+}
+.credit__table table tbody tr td {
+  padding: 8px;
+  border-bottom: 1px solid #cecbcb;
+}
+.credit__table table thead tr th.item,
+.credit__table table tbody tr td.item {
+  width: 45%;
+}
+.credit__table table thead tr th.rate,
+.credit__table table tbody tr td.rate {
+  width: 18%;
+  text-align: left;
+}
+.credit__table table thead tr th.quantity,
+.credit__table table tbody tr td.quantity {
+  width: 16%;
+  text-align: left;
+}
+.credit__table table thead tr th.total,
+.credit__table table tbody tr td.total {
+  width: 21%;
+  text-align: left;
+}
+.credit__table table .description {
+  color: #666;
+}
+.credit__table-after {
+  display: flex;
+}
+.credit__table-total {
+  margin-bottom: 20px;
+  width: 50%;
+  float: left;
+  margin-right: auto;
+}
+.credit__table-total table {
+  border-spacing: 0;
+  width: 100%;
+  font-size: 12px;
+}
+.credit__table-total table tbody tr td {
+  padding: 8px 0 8px 10px;
+  border-top: 1px solid #d5d5d5;
+}
+.credit__table-total table tbody tr td:last-child {
+  width: 140px;
+  text-align: left;
+}
+.credit__table-total table tbody tr:first-child td {
+  border-top: 0;
+}
+.credit__table-total table tbody tr.payment-amount td:last-child {
+  color: red;
+}
+.credit__table-total table tbody tr.blanace-due td {
+  border-top: 3px double #666;
+  font-weight: bold;
+}
+.credit__footer {
+  font-size: 12px;
+}
+.credit__conditions h3, .credit__notes h3 {
+  color: #666;
+  font-size: 12px;
+  margin-top: 0;
+  margin-bottom: 10px;
+}
+.credit__conditions p, .credit__notes p {
+  margin: 0;
+}
+.credit__conditions + .credit__notes {
+  margin-top: 20px;
+}
\ No newline at end of file
diff --git a/packages/server/resources/css/modules/credit.css b/packages/server/resources/css/modules/credit.css
new file mode 100644
index 000000000..a50f62304
--- /dev/null
+++ b/packages/server/resources/css/modules/credit.css
@@ -0,0 +1,553 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+/* Document
+   ========================================================================== */
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+html {
+  line-height: 1.15;
+  /* 1 */
+  -webkit-text-size-adjust: 100%;
+  /* 2 */
+}
+
+/* Sections
+     ========================================================================== */
+/**
+   * Remove the margin in all browsers.
+   */
+body {
+  margin: 0;
+}
+
+/**
+   * Render the `main` element consistently in IE.
+   */
+main {
+  display: block;
+}
+
+/**
+   * Correct the font size and margin on `h1` elements within `section` and
+   * `article` contexts in Chrome, Firefox, and Safari.
+   */
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+/* Grouping content
+     ========================================================================== */
+/**
+   * 1. Add the correct box sizing in Firefox.
+   * 2. Show the overflow in Edge and IE.
+   */
+hr {
+  box-sizing: content-box;
+  /* 1 */
+  height: 0;
+  /* 1 */
+  overflow: visible;
+  /* 2 */
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+pre {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/* Text-level semantics
+     ========================================================================== */
+/**
+   * Remove the gray background on active links in IE 10.
+   */
+a {
+  background-color: transparent;
+}
+
+/**
+   * 1. Remove the bottom border in Chrome 57-
+   * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+   */
+abbr[title] {
+  border-bottom: none;
+  /* 1 */
+  text-decoration: underline;
+  /* 2 */
+  text-decoration: underline dotted;
+  /* 2 */
+}
+
+/**
+   * Add the correct font weight in Chrome, Edge, and Safari.
+   */
+b,
+strong {
+  font-weight: bolder;
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+code,
+kbd,
+samp {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/**
+   * Add the correct font size in all browsers.
+   */
+small {
+  font-size: 80%;
+}
+
+/**
+   * Prevent `sub` and `sup` elements from affecting the line height in
+   * all browsers.
+   */
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/* Embedded content
+     ========================================================================== */
+/**
+   * Remove the border on images inside links in IE 10.
+   */
+img {
+  border-style: none;
+}
+
+/* Forms
+     ========================================================================== */
+/**
+   * 1. Change the font styles in all browsers.
+   * 2. Remove the margin in Firefox and Safari.
+   */
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+  /* 1 */
+  font-size: 100%;
+  /* 1 */
+  line-height: 1.15;
+  /* 1 */
+  margin: 0;
+  /* 2 */
+}
+
+/**
+   * Show the overflow in IE.
+   * 1. Show the overflow in Edge.
+   */
+button,
+input {
+  /* 1 */
+  overflow: visible;
+}
+
+/**
+   * Remove the inheritance of text transform in Edge, Firefox, and IE.
+   * 1. Remove the inheritance of text transform in Firefox.
+   */
+button,
+select {
+  /* 1 */
+  text-transform: none;
+}
+
+/**
+   * Correct the inability to style clickable types in iOS and Safari.
+   */
+button,
+[type=button],
+[type=reset],
+[type=submit] {
+  -webkit-appearance: button;
+}
+
+/**
+   * Remove the inner border and padding in Firefox.
+   */
+button::-moz-focus-inner,
+[type=button]::-moz-focus-inner,
+[type=reset]::-moz-focus-inner,
+[type=submit]::-moz-focus-inner {
+  border-style: none;
+  padding: 0;
+}
+
+/**
+   * Restore the focus styles unset by the previous rule.
+   */
+button:-moz-focusring,
+[type=button]:-moz-focusring,
+[type=reset]:-moz-focusring,
+[type=submit]:-moz-focusring {
+  outline: 1px dotted ButtonText;
+}
+
+/**
+   * Correct the padding in Firefox.
+   */
+fieldset {
+  padding: 0.35em 0.75em 0.625em;
+}
+
+/**
+   * 1. Correct the text wrapping in Edge and IE.
+   * 2. Correct the color inheritance from `fieldset` elements in IE.
+   * 3. Remove the padding so developers are not caught out when they zero out
+   *    `fieldset` elements in all browsers.
+   */
+legend {
+  box-sizing: border-box;
+  /* 1 */
+  color: inherit;
+  /* 2 */
+  display: table;
+  /* 1 */
+  max-width: 100%;
+  /* 1 */
+  padding: 0;
+  /* 3 */
+  white-space: normal;
+  /* 1 */
+}
+
+/**
+   * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+   */
+progress {
+  vertical-align: baseline;
+}
+
+/**
+   * Remove the default vertical scrollbar in IE 10+.
+   */
+textarea {
+  overflow: auto;
+}
+
+/**
+   * 1. Add the correct box sizing in IE 10.
+   * 2. Remove the padding in IE 10.
+   */
+[type=checkbox],
+[type=radio] {
+  box-sizing: border-box;
+  /* 1 */
+  padding: 0;
+  /* 2 */
+}
+
+/**
+   * Correct the cursor style of increment and decrement buttons in Chrome.
+   */
+[type=number]::-webkit-inner-spin-button,
+[type=number]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/**
+   * 1. Correct the odd appearance in Chrome and Safari.
+   * 2. Correct the outline style in Safari.
+   */
+[type=search] {
+  -webkit-appearance: textfield;
+  /* 1 */
+  outline-offset: -2px;
+  /* 2 */
+}
+
+/**
+   * Remove the inner padding in Chrome and Safari on macOS.
+   */
+[type=search]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/**
+   * 1. Correct the inability to style clickable types in iOS and Safari.
+   * 2. Change font properties to `inherit` in Safari.
+   */
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  /* 1 */
+  font: inherit;
+  /* 2 */
+}
+
+/* Interactive
+     ========================================================================== */
+/*
+   * Add the correct display in Edge, IE 10+, and Firefox.
+   */
+details {
+  display: block;
+}
+
+/*
+   * Add the correct display in all browsers.
+   */
+summary {
+  display: list-item;
+}
+
+/* Misc
+     ========================================================================== */
+/**
+   * Add the correct display in IE 10+.
+   */
+template {
+  display: none;
+}
+
+/**
+   * Add the correct display in IE 10.
+   */
+[hidden] {
+  display: none;
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+th {
+  text-align: inherit;
+  text-align: -webkit-match-parent;
+}
+
+thead,
+tbody,
+tfoot,
+tr,
+td,
+th {
+  border-color: inherit;
+  border-style: solid;
+  border-width: 0;
+}
+
+body {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  background-color: #fff;
+  direction: ltr;
+  -webkit-text-size-adjust: 100%;
+  -webkit-tap-highlight-color: transparent;
+}
+
+@font-face {
+  font-family: "Noto Sans";
+  src: local("Noto Sans"), url(data:font/woff2;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Segoe UI";
+  src: local("Segoe UI"), url(data:application/x-font-woff;charset=utf-8;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+body {
+  background: #f8f9fa;
+  text-align: left;
+  -webkit-print-color-adjust: exact;
+}
+html[lang^=ar] body {
+  font-family: "Segoe UI";
+}
+html[lang^=en] body {
+  font-family: "Noto Sans";
+}
+@media print {
+  body {
+    background: #fff;
+  }
+}
+
+.credit {
+  text-align: left;
+  padding: 45px 40px;
+}
+.credit__header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  margin: 0 0 30px;
+}
+.credit__header .organization .title {
+  margin: 0 0 4px;
+}
+.credit__header .organization .creditNumber {
+  font-size: 12px;
+}
+.credit__header .paper .title {
+  font-weight: 400;
+  text-transform: uppercase;
+  margin: 0 0 2px;
+  font-size: 32px;
+  line-height: 1;
+}
+.credit__full-amount {
+  margin-bottom: 18px;
+}
+.credit__full-amount .label {
+  font-size: 12px;
+}
+.credit__full-amount .amount {
+  font-size: 18px;
+  font-weight: 800;
+}
+.credit__meta {
+  display: flex;
+  flex-direction: column;
+  margin-bottom: 20px;
+  font-size: 13px;
+}
+.credit__meta-item {
+  padding-right: 10px;
+  font-weight: 400;
+  margin-bottom: 10px;
+  display: flex;
+  flex-direction: row;
+}
+.credit__meta-item .value {
+  color: #000;
+}
+.credit__meta-item .label {
+  color: #444;
+  margin-bottom: 2px;
+  width: 180px;
+}
+.credit__table {
+  display: flex;
+  flex-direction: column;
+}
+.credit__table table {
+  font-size: 12px;
+  color: #000;
+  text-align: left;
+  border-spacing: 0;
+}
+.credit__table table thead th,
+.credit__table table tbody tr td {
+  margin-bottom: 15px;
+  background: transparent;
+}
+.credit__table table thead th {
+  font-weight: 400;
+  border-bottom: none;
+  padding: 8px;
+  color: #fff;
+  background-color: #333;
+}
+.credit__table table tbody tr td {
+  padding: 8px;
+  border-bottom: 1px solid #cecbcb;
+}
+.credit__table table thead tr th.item,
+.credit__table table tbody tr td.item {
+  width: 45%;
+}
+.credit__table table thead tr th.rate,
+.credit__table table tbody tr td.rate {
+  width: 18%;
+  text-align: right;
+}
+.credit__table table thead tr th.quantity,
+.credit__table table tbody tr td.quantity {
+  width: 16%;
+  text-align: right;
+}
+.credit__table table thead tr th.total,
+.credit__table table tbody tr td.total {
+  width: 21%;
+  text-align: right;
+}
+.credit__table table .description {
+  color: #666;
+}
+.credit__table-after {
+  display: flex;
+}
+.credit__table-total {
+  margin-bottom: 20px;
+  width: 50%;
+  float: right;
+  margin-left: auto;
+}
+.credit__table-total table {
+  border-spacing: 0;
+  width: 100%;
+  font-size: 12px;
+}
+.credit__table-total table tbody tr td {
+  padding: 8px 10px 8px 0;
+  border-top: 1px solid #d5d5d5;
+}
+.credit__table-total table tbody tr td:last-child {
+  width: 140px;
+  text-align: right;
+}
+.credit__table-total table tbody tr:first-child td {
+  border-top: 0;
+}
+.credit__table-total table tbody tr.payment-amount td:last-child {
+  color: red;
+}
+.credit__table-total table tbody tr.blanace-due td {
+  border-top: 3px double #666;
+  font-weight: bold;
+}
+.credit__footer {
+  font-size: 12px;
+}
+.credit__conditions h3, .credit__notes h3 {
+  color: #666;
+  font-size: 12px;
+  margin-top: 0;
+  margin-bottom: 10px;
+}
+.credit__conditions p, .credit__notes p {
+  margin: 0;
+}
+.credit__conditions + .credit__notes {
+  margin-top: 20px;
+}
\ No newline at end of file
diff --git a/packages/server/resources/css/modules/estimate-rtl.css b/packages/server/resources/css/modules/estimate-rtl.css
new file mode 100644
index 000000000..36890c739
--- /dev/null
+++ b/packages/server/resources/css/modules/estimate-rtl.css
@@ -0,0 +1,544 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+/* Document
+   ========================================================================== */
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+html {
+  line-height: 1.15;
+  /* 1 */
+  -webkit-text-size-adjust: 100%;
+  /* 2 */
+}
+
+/* Sections
+     ========================================================================== */
+/**
+   * Remove the margin in all browsers.
+   */
+body {
+  margin: 0;
+}
+
+/**
+   * Render the `main` element consistently in IE.
+   */
+main {
+  display: block;
+}
+
+/**
+   * Correct the font size and margin on `h1` elements within `section` and
+   * `article` contexts in Chrome, Firefox, and Safari.
+   */
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+/* Grouping content
+     ========================================================================== */
+/**
+   * 1. Add the correct box sizing in Firefox.
+   * 2. Show the overflow in Edge and IE.
+   */
+hr {
+  box-sizing: content-box;
+  /* 1 */
+  height: 0;
+  /* 1 */
+  overflow: visible;
+  /* 2 */
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+pre {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/* Text-level semantics
+     ========================================================================== */
+/**
+   * Remove the gray background on active links in IE 10.
+   */
+a {
+  background-color: transparent;
+}
+
+/**
+   * 1. Remove the bottom border in Chrome 57-
+   * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+   */
+abbr[title] {
+  border-bottom: none;
+  /* 1 */
+  text-decoration: underline;
+  /* 2 */
+  text-decoration: underline dotted;
+  /* 2 */
+}
+
+/**
+   * Add the correct font weight in Chrome, Edge, and Safari.
+   */
+b,
+strong {
+  font-weight: bolder;
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+code,
+kbd,
+samp {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/**
+   * Add the correct font size in all browsers.
+   */
+small {
+  font-size: 80%;
+}
+
+/**
+   * Prevent `sub` and `sup` elements from affecting the line height in
+   * all browsers.
+   */
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/* Embedded content
+     ========================================================================== */
+/**
+   * Remove the border on images inside links in IE 10.
+   */
+img {
+  border-style: none;
+}
+
+/* Forms
+     ========================================================================== */
+/**
+   * 1. Change the font styles in all browsers.
+   * 2. Remove the margin in Firefox and Safari.
+   */
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+  /* 1 */
+  font-size: 100%;
+  /* 1 */
+  line-height: 1.15;
+  /* 1 */
+  margin: 0;
+  /* 2 */
+}
+
+/**
+   * Show the overflow in IE.
+   * 1. Show the overflow in Edge.
+   */
+button,
+input {
+  /* 1 */
+  overflow: visible;
+}
+
+/**
+   * Remove the inheritance of text transform in Edge, Firefox, and IE.
+   * 1. Remove the inheritance of text transform in Firefox.
+   */
+button,
+select {
+  /* 1 */
+  text-transform: none;
+}
+
+/**
+   * Correct the inability to style clickable types in iOS and Safari.
+   */
+button,
+[type=button],
+[type=reset],
+[type=submit] {
+  -webkit-appearance: button;
+}
+
+/**
+   * Remove the inner border and padding in Firefox.
+   */
+button::-moz-focus-inner,
+[type=button]::-moz-focus-inner,
+[type=reset]::-moz-focus-inner,
+[type=submit]::-moz-focus-inner {
+  border-style: none;
+  padding: 0;
+}
+
+/**
+   * Restore the focus styles unset by the previous rule.
+   */
+button:-moz-focusring,
+[type=button]:-moz-focusring,
+[type=reset]:-moz-focusring,
+[type=submit]:-moz-focusring {
+  outline: 1px dotted ButtonText;
+}
+
+/**
+   * Correct the padding in Firefox.
+   */
+fieldset {
+  padding: 0.35em 0.75em 0.625em;
+}
+
+/**
+   * 1. Correct the text wrapping in Edge and IE.
+   * 2. Correct the color inheritance from `fieldset` elements in IE.
+   * 3. Remove the padding so developers are not caught out when they zero out
+   *    `fieldset` elements in all browsers.
+   */
+legend {
+  box-sizing: border-box;
+  /* 1 */
+  color: inherit;
+  /* 2 */
+  display: table;
+  /* 1 */
+  max-width: 100%;
+  /* 1 */
+  padding: 0;
+  /* 3 */
+  white-space: normal;
+  /* 1 */
+}
+
+/**
+   * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+   */
+progress {
+  vertical-align: baseline;
+}
+
+/**
+   * Remove the default vertical scrollbar in IE 10+.
+   */
+textarea {
+  overflow: auto;
+}
+
+/**
+   * 1. Add the correct box sizing in IE 10.
+   * 2. Remove the padding in IE 10.
+   */
+[type=checkbox],
+[type=radio] {
+  box-sizing: border-box;
+  /* 1 */
+  padding: 0;
+  /* 2 */
+}
+
+/**
+   * Correct the cursor style of increment and decrement buttons in Chrome.
+   */
+[type=number]::-webkit-inner-spin-button,
+[type=number]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/**
+   * 1. Correct the odd appearance in Chrome and Safari.
+   * 2. Correct the outline style in Safari.
+   */
+[type=search] {
+  -webkit-appearance: textfield;
+  /* 1 */
+  outline-offset: -2px;
+  /* 2 */
+}
+
+/**
+   * Remove the inner padding in Chrome and Safari on macOS.
+   */
+[type=search]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/**
+   * 1. Correct the inability to style clickable types in iOS and Safari.
+   * 2. Change font properties to `inherit` in Safari.
+   */
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  /* 1 */
+  font: inherit;
+  /* 2 */
+}
+
+/* Interactive
+     ========================================================================== */
+/*
+   * Add the correct display in Edge, IE 10+, and Firefox.
+   */
+details {
+  display: block;
+}
+
+/*
+   * Add the correct display in all browsers.
+   */
+summary {
+  display: list-item;
+}
+
+/* Misc
+     ========================================================================== */
+/**
+   * Add the correct display in IE 10+.
+   */
+template {
+  display: none;
+}
+
+/**
+   * Add the correct display in IE 10.
+   */
+[hidden] {
+  display: none;
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+th {
+  text-align: inherit;
+  text-align: -webkit-match-parent;
+}
+
+thead,
+tbody,
+tfoot,
+tr,
+td,
+th {
+  border-color: inherit;
+  border-style: solid;
+  border-width: 0;
+}
+
+body {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  background-color: #fff;
+  direction: rtl;
+  -webkit-text-size-adjust: 100%;
+  -webkit-tap-highlight-color: transparent;
+}
+
+@font-face {
+  font-family: "Noto Sans";
+  src: local("Noto Sans"), url(data:font/woff2;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Segoe UI";
+  src: local("Segoe UI"), url(data:application/x-font-woff;charset=utf-8;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+body {
+  background: #f8f9fa;
+  text-align: right;
+  -webkit-print-color-adjust: exact;
+}
+html[lang^=ar] body {
+  font-family: "Segoe UI";
+}
+html[lang^=en] body {
+  font-family: "Noto Sans";
+}
+@media print {
+  body {
+    background: #fff;
+  }
+}
+
+.estimate {
+  text-align: right;
+  padding: 45px;
+}
+.estimate__header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  margin: 0 0 30px;
+}
+.estimate__header .organization .title {
+  margin: 0 0 4px;
+}
+.estimate__header .paper .title {
+  font-weight: 400;
+  text-transform: uppercase;
+  margin: 0 0 2px;
+  font-size: 32px;
+  line-height: 1;
+}
+.estimate__estimate-amount {
+  margin-bottom: 18px;
+}
+.estimate__estimate-amount .label {
+  font-size: 12px;
+}
+.estimate__estimate-amount .amount {
+  font-size: 18px;
+  font-weight: 800;
+}
+.estimate__meta {
+  display: flex;
+  flex-direction: column;
+  margin-bottom: 20px;
+  font-size: 13px;
+}
+.estimate__meta-item {
+  padding-left: 10px;
+  margin-bottom: 10px;
+  display: flex;
+  flex-direction: row;
+}
+.estimate__meta-item .value {
+  color: #000;
+}
+.estimate__meta-item .label {
+  color: #444;
+  margin-bottom: 2px;
+  width: 180px;
+}
+.estimate__table {
+  display: flex;
+  flex-direction: column;
+}
+.estimate__table table {
+  font-size: 12px;
+  color: #000;
+  text-align: right;
+  border-spacing: 0;
+}
+.estimate__table table thead th,
+.estimate__table table tbody tr td {
+  margin-bottom: 15px;
+  background: transparent;
+}
+.estimate__table table thead th {
+  font-weight: 400;
+  border-bottom: none;
+  padding: 8px;
+  color: #fff;
+  background-color: #333;
+}
+.estimate__table table tbody tr td {
+  padding: 8px;
+  border-bottom: 1px solid #cecbcb;
+}
+.estimate__table table thead tr th.item,
+.estimate__table table tbody tr td.item {
+  width: 45%;
+}
+.estimate__table table thead tr th.rate,
+.estimate__table table tbody tr td.rate {
+  width: 18%;
+  text-align: left;
+}
+.estimate__table table thead tr th.quantity,
+.estimate__table table tbody tr td.quantity {
+  width: 16%;
+  text-align: left;
+}
+.estimate__table table thead tr th.total,
+.estimate__table table tbody tr td.total {
+  width: 21%;
+  text-align: left;
+}
+.estimate__table table thead tr th .description,
+.estimate__table table tbody tr td .description {
+  color: #666;
+}
+.estimate__table-after {
+  display: flex;
+}
+.estimate__table-total {
+  margin-bottom: 20px;
+  width: 50%;
+  float: left;
+  margin-right: auto;
+}
+.estimate__table-total table {
+  border-spacing: 0;
+  width: 100%;
+  font-size: 12px;
+}
+.estimate__table-total table tbody tr td {
+  padding: 8px 0 8px 10px;
+  border-top: 1px solid #d5d5d5;
+}
+.estimate__table-total table tbody tr td:last-child {
+  width: 140px;
+  text-align: left;
+}
+.estimate__table-total table tbody tr:first-child td {
+  border-top: 0;
+}
+.estimate__table-total table tbody tr.total td {
+  border-top: 3px double #666;
+  font-weight: bold;
+}
+.estimate__footer {
+  font-size: 12px;
+}
+.estimate__conditions h3, .estimate__notes h3 {
+  color: #666;
+  font-size: 12px;
+  margin-top: 0;
+  margin-bottom: 10px;
+}
+.estimate__conditions p, .estimate__notes p {
+  margin: 0 0 20px;
+}
\ No newline at end of file
diff --git a/packages/server/resources/css/modules/estimate.css b/packages/server/resources/css/modules/estimate.css
new file mode 100644
index 000000000..0ba2587c7
--- /dev/null
+++ b/packages/server/resources/css/modules/estimate.css
@@ -0,0 +1,544 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+/* Document
+   ========================================================================== */
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+html {
+  line-height: 1.15;
+  /* 1 */
+  -webkit-text-size-adjust: 100%;
+  /* 2 */
+}
+
+/* Sections
+     ========================================================================== */
+/**
+   * Remove the margin in all browsers.
+   */
+body {
+  margin: 0;
+}
+
+/**
+   * Render the `main` element consistently in IE.
+   */
+main {
+  display: block;
+}
+
+/**
+   * Correct the font size and margin on `h1` elements within `section` and
+   * `article` contexts in Chrome, Firefox, and Safari.
+   */
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+/* Grouping content
+     ========================================================================== */
+/**
+   * 1. Add the correct box sizing in Firefox.
+   * 2. Show the overflow in Edge and IE.
+   */
+hr {
+  box-sizing: content-box;
+  /* 1 */
+  height: 0;
+  /* 1 */
+  overflow: visible;
+  /* 2 */
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+pre {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/* Text-level semantics
+     ========================================================================== */
+/**
+   * Remove the gray background on active links in IE 10.
+   */
+a {
+  background-color: transparent;
+}
+
+/**
+   * 1. Remove the bottom border in Chrome 57-
+   * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+   */
+abbr[title] {
+  border-bottom: none;
+  /* 1 */
+  text-decoration: underline;
+  /* 2 */
+  text-decoration: underline dotted;
+  /* 2 */
+}
+
+/**
+   * Add the correct font weight in Chrome, Edge, and Safari.
+   */
+b,
+strong {
+  font-weight: bolder;
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+code,
+kbd,
+samp {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/**
+   * Add the correct font size in all browsers.
+   */
+small {
+  font-size: 80%;
+}
+
+/**
+   * Prevent `sub` and `sup` elements from affecting the line height in
+   * all browsers.
+   */
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/* Embedded content
+     ========================================================================== */
+/**
+   * Remove the border on images inside links in IE 10.
+   */
+img {
+  border-style: none;
+}
+
+/* Forms
+     ========================================================================== */
+/**
+   * 1. Change the font styles in all browsers.
+   * 2. Remove the margin in Firefox and Safari.
+   */
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+  /* 1 */
+  font-size: 100%;
+  /* 1 */
+  line-height: 1.15;
+  /* 1 */
+  margin: 0;
+  /* 2 */
+}
+
+/**
+   * Show the overflow in IE.
+   * 1. Show the overflow in Edge.
+   */
+button,
+input {
+  /* 1 */
+  overflow: visible;
+}
+
+/**
+   * Remove the inheritance of text transform in Edge, Firefox, and IE.
+   * 1. Remove the inheritance of text transform in Firefox.
+   */
+button,
+select {
+  /* 1 */
+  text-transform: none;
+}
+
+/**
+   * Correct the inability to style clickable types in iOS and Safari.
+   */
+button,
+[type=button],
+[type=reset],
+[type=submit] {
+  -webkit-appearance: button;
+}
+
+/**
+   * Remove the inner border and padding in Firefox.
+   */
+button::-moz-focus-inner,
+[type=button]::-moz-focus-inner,
+[type=reset]::-moz-focus-inner,
+[type=submit]::-moz-focus-inner {
+  border-style: none;
+  padding: 0;
+}
+
+/**
+   * Restore the focus styles unset by the previous rule.
+   */
+button:-moz-focusring,
+[type=button]:-moz-focusring,
+[type=reset]:-moz-focusring,
+[type=submit]:-moz-focusring {
+  outline: 1px dotted ButtonText;
+}
+
+/**
+   * Correct the padding in Firefox.
+   */
+fieldset {
+  padding: 0.35em 0.75em 0.625em;
+}
+
+/**
+   * 1. Correct the text wrapping in Edge and IE.
+   * 2. Correct the color inheritance from `fieldset` elements in IE.
+   * 3. Remove the padding so developers are not caught out when they zero out
+   *    `fieldset` elements in all browsers.
+   */
+legend {
+  box-sizing: border-box;
+  /* 1 */
+  color: inherit;
+  /* 2 */
+  display: table;
+  /* 1 */
+  max-width: 100%;
+  /* 1 */
+  padding: 0;
+  /* 3 */
+  white-space: normal;
+  /* 1 */
+}
+
+/**
+   * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+   */
+progress {
+  vertical-align: baseline;
+}
+
+/**
+   * Remove the default vertical scrollbar in IE 10+.
+   */
+textarea {
+  overflow: auto;
+}
+
+/**
+   * 1. Add the correct box sizing in IE 10.
+   * 2. Remove the padding in IE 10.
+   */
+[type=checkbox],
+[type=radio] {
+  box-sizing: border-box;
+  /* 1 */
+  padding: 0;
+  /* 2 */
+}
+
+/**
+   * Correct the cursor style of increment and decrement buttons in Chrome.
+   */
+[type=number]::-webkit-inner-spin-button,
+[type=number]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/**
+   * 1. Correct the odd appearance in Chrome and Safari.
+   * 2. Correct the outline style in Safari.
+   */
+[type=search] {
+  -webkit-appearance: textfield;
+  /* 1 */
+  outline-offset: -2px;
+  /* 2 */
+}
+
+/**
+   * Remove the inner padding in Chrome and Safari on macOS.
+   */
+[type=search]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/**
+   * 1. Correct the inability to style clickable types in iOS and Safari.
+   * 2. Change font properties to `inherit` in Safari.
+   */
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  /* 1 */
+  font: inherit;
+  /* 2 */
+}
+
+/* Interactive
+     ========================================================================== */
+/*
+   * Add the correct display in Edge, IE 10+, and Firefox.
+   */
+details {
+  display: block;
+}
+
+/*
+   * Add the correct display in all browsers.
+   */
+summary {
+  display: list-item;
+}
+
+/* Misc
+     ========================================================================== */
+/**
+   * Add the correct display in IE 10+.
+   */
+template {
+  display: none;
+}
+
+/**
+   * Add the correct display in IE 10.
+   */
+[hidden] {
+  display: none;
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+th {
+  text-align: inherit;
+  text-align: -webkit-match-parent;
+}
+
+thead,
+tbody,
+tfoot,
+tr,
+td,
+th {
+  border-color: inherit;
+  border-style: solid;
+  border-width: 0;
+}
+
+body {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  background-color: #fff;
+  direction: ltr;
+  -webkit-text-size-adjust: 100%;
+  -webkit-tap-highlight-color: transparent;
+}
+
+@font-face {
+  font-family: "Noto Sans";
+  src: local("Noto Sans"), url(data:font/woff2;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Segoe UI";
+  src: local("Segoe UI"), url(data:application/x-font-woff;charset=utf-8;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+body {
+  background: #f8f9fa;
+  text-align: left;
+  -webkit-print-color-adjust: exact;
+}
+html[lang^=ar] body {
+  font-family: "Segoe UI";
+}
+html[lang^=en] body {
+  font-family: "Noto Sans";
+}
+@media print {
+  body {
+    background: #fff;
+  }
+}
+
+.estimate {
+  text-align: left;
+  padding: 45px;
+}
+.estimate__header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  margin: 0 0 30px;
+}
+.estimate__header .organization .title {
+  margin: 0 0 4px;
+}
+.estimate__header .paper .title {
+  font-weight: 400;
+  text-transform: uppercase;
+  margin: 0 0 2px;
+  font-size: 32px;
+  line-height: 1;
+}
+.estimate__estimate-amount {
+  margin-bottom: 18px;
+}
+.estimate__estimate-amount .label {
+  font-size: 12px;
+}
+.estimate__estimate-amount .amount {
+  font-size: 18px;
+  font-weight: 800;
+}
+.estimate__meta {
+  display: flex;
+  flex-direction: column;
+  margin-bottom: 20px;
+  font-size: 13px;
+}
+.estimate__meta-item {
+  padding-right: 10px;
+  margin-bottom: 10px;
+  display: flex;
+  flex-direction: row;
+}
+.estimate__meta-item .value {
+  color: #000;
+}
+.estimate__meta-item .label {
+  color: #444;
+  margin-bottom: 2px;
+  width: 180px;
+}
+.estimate__table {
+  display: flex;
+  flex-direction: column;
+}
+.estimate__table table {
+  font-size: 12px;
+  color: #000;
+  text-align: left;
+  border-spacing: 0;
+}
+.estimate__table table thead th,
+.estimate__table table tbody tr td {
+  margin-bottom: 15px;
+  background: transparent;
+}
+.estimate__table table thead th {
+  font-weight: 400;
+  border-bottom: none;
+  padding: 8px;
+  color: #fff;
+  background-color: #333;
+}
+.estimate__table table tbody tr td {
+  padding: 8px;
+  border-bottom: 1px solid #cecbcb;
+}
+.estimate__table table thead tr th.item,
+.estimate__table table tbody tr td.item {
+  width: 45%;
+}
+.estimate__table table thead tr th.rate,
+.estimate__table table tbody tr td.rate {
+  width: 18%;
+  text-align: right;
+}
+.estimate__table table thead tr th.quantity,
+.estimate__table table tbody tr td.quantity {
+  width: 16%;
+  text-align: right;
+}
+.estimate__table table thead tr th.total,
+.estimate__table table tbody tr td.total {
+  width: 21%;
+  text-align: right;
+}
+.estimate__table table thead tr th .description,
+.estimate__table table tbody tr td .description {
+  color: #666;
+}
+.estimate__table-after {
+  display: flex;
+}
+.estimate__table-total {
+  margin-bottom: 20px;
+  width: 50%;
+  float: right;
+  margin-left: auto;
+}
+.estimate__table-total table {
+  border-spacing: 0;
+  width: 100%;
+  font-size: 12px;
+}
+.estimate__table-total table tbody tr td {
+  padding: 8px 10px 8px 0;
+  border-top: 1px solid #d5d5d5;
+}
+.estimate__table-total table tbody tr td:last-child {
+  width: 140px;
+  text-align: right;
+}
+.estimate__table-total table tbody tr:first-child td {
+  border-top: 0;
+}
+.estimate__table-total table tbody tr.total td {
+  border-top: 3px double #666;
+  font-weight: bold;
+}
+.estimate__footer {
+  font-size: 12px;
+}
+.estimate__conditions h3, .estimate__notes h3 {
+  color: #666;
+  font-size: 12px;
+  margin-top: 0;
+  margin-bottom: 10px;
+}
+.estimate__conditions p, .estimate__notes p {
+  margin: 0 0 20px;
+}
\ No newline at end of file
diff --git a/packages/server/resources/css/modules/invoice-rtl.css b/packages/server/resources/css/modules/invoice-rtl.css
new file mode 100644
index 000000000..ef0c7baff
--- /dev/null
+++ b/packages/server/resources/css/modules/invoice-rtl.css
@@ -0,0 +1,553 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+/* Document
+   ========================================================================== */
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+html {
+  line-height: 1.15;
+  /* 1 */
+  -webkit-text-size-adjust: 100%;
+  /* 2 */
+}
+
+/* Sections
+     ========================================================================== */
+/**
+   * Remove the margin in all browsers.
+   */
+body {
+  margin: 0;
+}
+
+/**
+   * Render the `main` element consistently in IE.
+   */
+main {
+  display: block;
+}
+
+/**
+   * Correct the font size and margin on `h1` elements within `section` and
+   * `article` contexts in Chrome, Firefox, and Safari.
+   */
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+/* Grouping content
+     ========================================================================== */
+/**
+   * 1. Add the correct box sizing in Firefox.
+   * 2. Show the overflow in Edge and IE.
+   */
+hr {
+  box-sizing: content-box;
+  /* 1 */
+  height: 0;
+  /* 1 */
+  overflow: visible;
+  /* 2 */
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+pre {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/* Text-level semantics
+     ========================================================================== */
+/**
+   * Remove the gray background on active links in IE 10.
+   */
+a {
+  background-color: transparent;
+}
+
+/**
+   * 1. Remove the bottom border in Chrome 57-
+   * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+   */
+abbr[title] {
+  border-bottom: none;
+  /* 1 */
+  text-decoration: underline;
+  /* 2 */
+  text-decoration: underline dotted;
+  /* 2 */
+}
+
+/**
+   * Add the correct font weight in Chrome, Edge, and Safari.
+   */
+b,
+strong {
+  font-weight: bolder;
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+code,
+kbd,
+samp {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/**
+   * Add the correct font size in all browsers.
+   */
+small {
+  font-size: 80%;
+}
+
+/**
+   * Prevent `sub` and `sup` elements from affecting the line height in
+   * all browsers.
+   */
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/* Embedded content
+     ========================================================================== */
+/**
+   * Remove the border on images inside links in IE 10.
+   */
+img {
+  border-style: none;
+}
+
+/* Forms
+     ========================================================================== */
+/**
+   * 1. Change the font styles in all browsers.
+   * 2. Remove the margin in Firefox and Safari.
+   */
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+  /* 1 */
+  font-size: 100%;
+  /* 1 */
+  line-height: 1.15;
+  /* 1 */
+  margin: 0;
+  /* 2 */
+}
+
+/**
+   * Show the overflow in IE.
+   * 1. Show the overflow in Edge.
+   */
+button,
+input {
+  /* 1 */
+  overflow: visible;
+}
+
+/**
+   * Remove the inheritance of text transform in Edge, Firefox, and IE.
+   * 1. Remove the inheritance of text transform in Firefox.
+   */
+button,
+select {
+  /* 1 */
+  text-transform: none;
+}
+
+/**
+   * Correct the inability to style clickable types in iOS and Safari.
+   */
+button,
+[type=button],
+[type=reset],
+[type=submit] {
+  -webkit-appearance: button;
+}
+
+/**
+   * Remove the inner border and padding in Firefox.
+   */
+button::-moz-focus-inner,
+[type=button]::-moz-focus-inner,
+[type=reset]::-moz-focus-inner,
+[type=submit]::-moz-focus-inner {
+  border-style: none;
+  padding: 0;
+}
+
+/**
+   * Restore the focus styles unset by the previous rule.
+   */
+button:-moz-focusring,
+[type=button]:-moz-focusring,
+[type=reset]:-moz-focusring,
+[type=submit]:-moz-focusring {
+  outline: 1px dotted ButtonText;
+}
+
+/**
+   * Correct the padding in Firefox.
+   */
+fieldset {
+  padding: 0.35em 0.75em 0.625em;
+}
+
+/**
+   * 1. Correct the text wrapping in Edge and IE.
+   * 2. Correct the color inheritance from `fieldset` elements in IE.
+   * 3. Remove the padding so developers are not caught out when they zero out
+   *    `fieldset` elements in all browsers.
+   */
+legend {
+  box-sizing: border-box;
+  /* 1 */
+  color: inherit;
+  /* 2 */
+  display: table;
+  /* 1 */
+  max-width: 100%;
+  /* 1 */
+  padding: 0;
+  /* 3 */
+  white-space: normal;
+  /* 1 */
+}
+
+/**
+   * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+   */
+progress {
+  vertical-align: baseline;
+}
+
+/**
+   * Remove the default vertical scrollbar in IE 10+.
+   */
+textarea {
+  overflow: auto;
+}
+
+/**
+   * 1. Add the correct box sizing in IE 10.
+   * 2. Remove the padding in IE 10.
+   */
+[type=checkbox],
+[type=radio] {
+  box-sizing: border-box;
+  /* 1 */
+  padding: 0;
+  /* 2 */
+}
+
+/**
+   * Correct the cursor style of increment and decrement buttons in Chrome.
+   */
+[type=number]::-webkit-inner-spin-button,
+[type=number]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/**
+   * 1. Correct the odd appearance in Chrome and Safari.
+   * 2. Correct the outline style in Safari.
+   */
+[type=search] {
+  -webkit-appearance: textfield;
+  /* 1 */
+  outline-offset: -2px;
+  /* 2 */
+}
+
+/**
+   * Remove the inner padding in Chrome and Safari on macOS.
+   */
+[type=search]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/**
+   * 1. Correct the inability to style clickable types in iOS and Safari.
+   * 2. Change font properties to `inherit` in Safari.
+   */
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  /* 1 */
+  font: inherit;
+  /* 2 */
+}
+
+/* Interactive
+     ========================================================================== */
+/*
+   * Add the correct display in Edge, IE 10+, and Firefox.
+   */
+details {
+  display: block;
+}
+
+/*
+   * Add the correct display in all browsers.
+   */
+summary {
+  display: list-item;
+}
+
+/* Misc
+     ========================================================================== */
+/**
+   * Add the correct display in IE 10+.
+   */
+template {
+  display: none;
+}
+
+/**
+   * Add the correct display in IE 10.
+   */
+[hidden] {
+  display: none;
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+th {
+  text-align: inherit;
+  text-align: -webkit-match-parent;
+}
+
+thead,
+tbody,
+tfoot,
+tr,
+td,
+th {
+  border-color: inherit;
+  border-style: solid;
+  border-width: 0;
+}
+
+body {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  background-color: #fff;
+  direction: rtl;
+  -webkit-text-size-adjust: 100%;
+  -webkit-tap-highlight-color: transparent;
+}
+
+@font-face {
+  font-family: "Noto Sans";
+  src: local("Noto Sans"), url(data:font/woff2;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Segoe UI";
+  src: local("Segoe UI"), url(data:application/x-font-woff;charset=utf-8;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+body {
+  background: #f8f9fa;
+  text-align: right;
+  -webkit-print-color-adjust: exact;
+}
+html[lang^=ar] body {
+  font-family: "Segoe UI";
+}
+html[lang^=en] body {
+  font-family: "Noto Sans";
+}
+@media print {
+  body {
+    background: #fff;
+  }
+}
+
+.invoice {
+  text-align: right;
+  padding: 45px 40px;
+}
+.invoice__header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  margin: 0 0 30px;
+}
+.invoice__header .organization .title {
+  margin: 0 0 4px;
+}
+.invoice__header .organization .invoiceNo {
+  font-size: 12px;
+}
+.invoice__header .paper .title {
+  font-weight: 400;
+  text-transform: uppercase;
+  margin: 0 0 2px;
+  font-size: 32px;
+  line-height: 1;
+}
+.invoice__meta {
+  display: flex;
+  flex-direction: column;
+  margin-bottom: 20px;
+  font-size: 13px;
+}
+.invoice__meta-item {
+  padding-left: 10px;
+  font-weight: 400;
+  margin-bottom: 10px;
+  display: flex;
+  flex-direction: row;
+}
+.invoice__meta-item .value {
+  color: #000;
+}
+.invoice__meta-item .label {
+  color: #444;
+  margin-bottom: 2px;
+  width: 180px;
+}
+.invoice__table {
+  display: flex;
+  flex-direction: column;
+}
+.invoice__table table {
+  font-size: 12px;
+  color: #000;
+  text-align: right;
+  border-spacing: 0;
+}
+.invoice__table table thead th,
+.invoice__table table tbody tr td {
+  margin-bottom: 15px;
+  background: transparent;
+}
+.invoice__table table thead th {
+  font-weight: 400;
+  border-bottom: none;
+  padding: 8px;
+  color: #fff;
+  background-color: #333;
+}
+.invoice__table table tbody tr td {
+  padding: 8px;
+  border-bottom: 1px solid #cecbcb;
+}
+.invoice__table table thead tr th.item,
+.invoice__table table tbody tr td.item {
+  width: 45%;
+}
+.invoice__table table thead tr th.rate,
+.invoice__table table tbody tr td.rate {
+  width: 18%;
+  text-align: left;
+}
+.invoice__table table thead tr th.quantity,
+.invoice__table table tbody tr td.quantity {
+  width: 16%;
+  text-align: left;
+}
+.invoice__table table thead tr th.total,
+.invoice__table table tbody tr td.total {
+  width: 21%;
+  text-align: left;
+}
+.invoice__table table .description {
+  color: #666;
+}
+.invoice__table-after {
+  display: flex;
+}
+.invoice__table-total {
+  margin-bottom: 20px;
+  width: 50%;
+  float: left;
+  margin-right: auto;
+}
+.invoice__table-total table {
+  border-spacing: 0;
+  width: 100%;
+  font-size: 12px;
+}
+.invoice__table-total table tbody tr td {
+  padding: 8px 0 8px 10px;
+  border-top: 1px solid #d5d5d5;
+}
+.invoice__table-total table tbody tr td:last-child {
+  width: 140px;
+  text-align: left;
+}
+.invoice__table-total table tbody tr:first-child td {
+  border-top: 0;
+}
+.invoice__table-total table tbody tr.payment-amount td:last-child {
+  color: red;
+}
+.invoice__table-total table tbody tr.blanace-due td {
+  border-top: 3px double #666;
+  font-weight: bold;
+}
+.invoice__due-amount {
+  margin-bottom: 18px;
+}
+.invoice__due-amount .label {
+  font-size: 12px;
+}
+.invoice__due-amount .amount {
+  font-size: 18px;
+  font-weight: 800;
+}
+.invoice__footer {
+  font-size: 12px;
+}
+.invoice__conditions h3, .invoice__notes h3 {
+  color: #666;
+  font-size: 12px;
+  margin-top: 0;
+  margin-bottom: 10px;
+}
+.invoice__conditions p, .invoice__notes p {
+  margin: 0;
+}
+.invoice__conditions + .invoice__notes {
+  margin-top: 20px;
+}
\ No newline at end of file
diff --git a/packages/server/resources/css/modules/invoice.css b/packages/server/resources/css/modules/invoice.css
new file mode 100644
index 000000000..a928b39c3
--- /dev/null
+++ b/packages/server/resources/css/modules/invoice.css
@@ -0,0 +1,553 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+/* Document
+   ========================================================================== */
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+html {
+  line-height: 1.15;
+  /* 1 */
+  -webkit-text-size-adjust: 100%;
+  /* 2 */
+}
+
+/* Sections
+     ========================================================================== */
+/**
+   * Remove the margin in all browsers.
+   */
+body {
+  margin: 0;
+}
+
+/**
+   * Render the `main` element consistently in IE.
+   */
+main {
+  display: block;
+}
+
+/**
+   * Correct the font size and margin on `h1` elements within `section` and
+   * `article` contexts in Chrome, Firefox, and Safari.
+   */
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+/* Grouping content
+     ========================================================================== */
+/**
+   * 1. Add the correct box sizing in Firefox.
+   * 2. Show the overflow in Edge and IE.
+   */
+hr {
+  box-sizing: content-box;
+  /* 1 */
+  height: 0;
+  /* 1 */
+  overflow: visible;
+  /* 2 */
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+pre {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/* Text-level semantics
+     ========================================================================== */
+/**
+   * Remove the gray background on active links in IE 10.
+   */
+a {
+  background-color: transparent;
+}
+
+/**
+   * 1. Remove the bottom border in Chrome 57-
+   * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+   */
+abbr[title] {
+  border-bottom: none;
+  /* 1 */
+  text-decoration: underline;
+  /* 2 */
+  text-decoration: underline dotted;
+  /* 2 */
+}
+
+/**
+   * Add the correct font weight in Chrome, Edge, and Safari.
+   */
+b,
+strong {
+  font-weight: bolder;
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+code,
+kbd,
+samp {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/**
+   * Add the correct font size in all browsers.
+   */
+small {
+  font-size: 80%;
+}
+
+/**
+   * Prevent `sub` and `sup` elements from affecting the line height in
+   * all browsers.
+   */
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/* Embedded content
+     ========================================================================== */
+/**
+   * Remove the border on images inside links in IE 10.
+   */
+img {
+  border-style: none;
+}
+
+/* Forms
+     ========================================================================== */
+/**
+   * 1. Change the font styles in all browsers.
+   * 2. Remove the margin in Firefox and Safari.
+   */
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+  /* 1 */
+  font-size: 100%;
+  /* 1 */
+  line-height: 1.15;
+  /* 1 */
+  margin: 0;
+  /* 2 */
+}
+
+/**
+   * Show the overflow in IE.
+   * 1. Show the overflow in Edge.
+   */
+button,
+input {
+  /* 1 */
+  overflow: visible;
+}
+
+/**
+   * Remove the inheritance of text transform in Edge, Firefox, and IE.
+   * 1. Remove the inheritance of text transform in Firefox.
+   */
+button,
+select {
+  /* 1 */
+  text-transform: none;
+}
+
+/**
+   * Correct the inability to style clickable types in iOS and Safari.
+   */
+button,
+[type=button],
+[type=reset],
+[type=submit] {
+  -webkit-appearance: button;
+}
+
+/**
+   * Remove the inner border and padding in Firefox.
+   */
+button::-moz-focus-inner,
+[type=button]::-moz-focus-inner,
+[type=reset]::-moz-focus-inner,
+[type=submit]::-moz-focus-inner {
+  border-style: none;
+  padding: 0;
+}
+
+/**
+   * Restore the focus styles unset by the previous rule.
+   */
+button:-moz-focusring,
+[type=button]:-moz-focusring,
+[type=reset]:-moz-focusring,
+[type=submit]:-moz-focusring {
+  outline: 1px dotted ButtonText;
+}
+
+/**
+   * Correct the padding in Firefox.
+   */
+fieldset {
+  padding: 0.35em 0.75em 0.625em;
+}
+
+/**
+   * 1. Correct the text wrapping in Edge and IE.
+   * 2. Correct the color inheritance from `fieldset` elements in IE.
+   * 3. Remove the padding so developers are not caught out when they zero out
+   *    `fieldset` elements in all browsers.
+   */
+legend {
+  box-sizing: border-box;
+  /* 1 */
+  color: inherit;
+  /* 2 */
+  display: table;
+  /* 1 */
+  max-width: 100%;
+  /* 1 */
+  padding: 0;
+  /* 3 */
+  white-space: normal;
+  /* 1 */
+}
+
+/**
+   * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+   */
+progress {
+  vertical-align: baseline;
+}
+
+/**
+   * Remove the default vertical scrollbar in IE 10+.
+   */
+textarea {
+  overflow: auto;
+}
+
+/**
+   * 1. Add the correct box sizing in IE 10.
+   * 2. Remove the padding in IE 10.
+   */
+[type=checkbox],
+[type=radio] {
+  box-sizing: border-box;
+  /* 1 */
+  padding: 0;
+  /* 2 */
+}
+
+/**
+   * Correct the cursor style of increment and decrement buttons in Chrome.
+   */
+[type=number]::-webkit-inner-spin-button,
+[type=number]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/**
+   * 1. Correct the odd appearance in Chrome and Safari.
+   * 2. Correct the outline style in Safari.
+   */
+[type=search] {
+  -webkit-appearance: textfield;
+  /* 1 */
+  outline-offset: -2px;
+  /* 2 */
+}
+
+/**
+   * Remove the inner padding in Chrome and Safari on macOS.
+   */
+[type=search]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/**
+   * 1. Correct the inability to style clickable types in iOS and Safari.
+   * 2. Change font properties to `inherit` in Safari.
+   */
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  /* 1 */
+  font: inherit;
+  /* 2 */
+}
+
+/* Interactive
+     ========================================================================== */
+/*
+   * Add the correct display in Edge, IE 10+, and Firefox.
+   */
+details {
+  display: block;
+}
+
+/*
+   * Add the correct display in all browsers.
+   */
+summary {
+  display: list-item;
+}
+
+/* Misc
+     ========================================================================== */
+/**
+   * Add the correct display in IE 10+.
+   */
+template {
+  display: none;
+}
+
+/**
+   * Add the correct display in IE 10.
+   */
+[hidden] {
+  display: none;
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+th {
+  text-align: inherit;
+  text-align: -webkit-match-parent;
+}
+
+thead,
+tbody,
+tfoot,
+tr,
+td,
+th {
+  border-color: inherit;
+  border-style: solid;
+  border-width: 0;
+}
+
+body {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  background-color: #fff;
+  direction: ltr;
+  -webkit-text-size-adjust: 100%;
+  -webkit-tap-highlight-color: transparent;
+}
+
+@font-face {
+  font-family: "Noto Sans";
+  src: local("Noto Sans"), url(data:font/woff2;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Segoe UI";
+  src: local("Segoe UI"), url(data:application/x-font-woff;charset=utf-8;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+body {
+  background: #f8f9fa;
+  text-align: left;
+  -webkit-print-color-adjust: exact;
+}
+html[lang^=ar] body {
+  font-family: "Segoe UI";
+}
+html[lang^=en] body {
+  font-family: "Noto Sans";
+}
+@media print {
+  body {
+    background: #fff;
+  }
+}
+
+.invoice {
+  text-align: left;
+  padding: 45px 40px;
+}
+.invoice__header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  margin: 0 0 30px;
+}
+.invoice__header .organization .title {
+  margin: 0 0 4px;
+}
+.invoice__header .organization .invoiceNo {
+  font-size: 12px;
+}
+.invoice__header .paper .title {
+  font-weight: 400;
+  text-transform: uppercase;
+  margin: 0 0 2px;
+  font-size: 32px;
+  line-height: 1;
+}
+.invoice__meta {
+  display: flex;
+  flex-direction: column;
+  margin-bottom: 20px;
+  font-size: 13px;
+}
+.invoice__meta-item {
+  padding-right: 10px;
+  font-weight: 400;
+  margin-bottom: 10px;
+  display: flex;
+  flex-direction: row;
+}
+.invoice__meta-item .value {
+  color: #000;
+}
+.invoice__meta-item .label {
+  color: #444;
+  margin-bottom: 2px;
+  width: 180px;
+}
+.invoice__table {
+  display: flex;
+  flex-direction: column;
+}
+.invoice__table table {
+  font-size: 12px;
+  color: #000;
+  text-align: left;
+  border-spacing: 0;
+}
+.invoice__table table thead th,
+.invoice__table table tbody tr td {
+  margin-bottom: 15px;
+  background: transparent;
+}
+.invoice__table table thead th {
+  font-weight: 400;
+  border-bottom: none;
+  padding: 8px;
+  color: #fff;
+  background-color: #333;
+}
+.invoice__table table tbody tr td {
+  padding: 8px;
+  border-bottom: 1px solid #cecbcb;
+}
+.invoice__table table thead tr th.item,
+.invoice__table table tbody tr td.item {
+  width: 45%;
+}
+.invoice__table table thead tr th.rate,
+.invoice__table table tbody tr td.rate {
+  width: 18%;
+  text-align: right;
+}
+.invoice__table table thead tr th.quantity,
+.invoice__table table tbody tr td.quantity {
+  width: 16%;
+  text-align: right;
+}
+.invoice__table table thead tr th.total,
+.invoice__table table tbody tr td.total {
+  width: 21%;
+  text-align: right;
+}
+.invoice__table table .description {
+  color: #666;
+}
+.invoice__table-after {
+  display: flex;
+}
+.invoice__table-total {
+  margin-bottom: 20px;
+  width: 50%;
+  float: right;
+  margin-left: auto;
+}
+.invoice__table-total table {
+  border-spacing: 0;
+  width: 100%;
+  font-size: 12px;
+}
+.invoice__table-total table tbody tr td {
+  padding: 8px 10px 8px 0;
+  border-top: 1px solid #d5d5d5;
+}
+.invoice__table-total table tbody tr td:last-child {
+  width: 140px;
+  text-align: right;
+}
+.invoice__table-total table tbody tr:first-child td {
+  border-top: 0;
+}
+.invoice__table-total table tbody tr.payment-amount td:last-child {
+  color: red;
+}
+.invoice__table-total table tbody tr.blanace-due td {
+  border-top: 3px double #666;
+  font-weight: bold;
+}
+.invoice__due-amount {
+  margin-bottom: 18px;
+}
+.invoice__due-amount .label {
+  font-size: 12px;
+}
+.invoice__due-amount .amount {
+  font-size: 18px;
+  font-weight: 800;
+}
+.invoice__footer {
+  font-size: 12px;
+}
+.invoice__conditions h3, .invoice__notes h3 {
+  color: #666;
+  font-size: 12px;
+  margin-top: 0;
+  margin-bottom: 10px;
+}
+.invoice__conditions p, .invoice__notes p {
+  margin: 0;
+}
+.invoice__conditions + .invoice__notes {
+  margin-top: 20px;
+}
\ No newline at end of file
diff --git a/packages/server/resources/css/modules/payment-rtl.css b/packages/server/resources/css/modules/payment-rtl.css
new file mode 100644
index 000000000..43e5bc945
--- /dev/null
+++ b/packages/server/resources/css/modules/payment-rtl.css
@@ -0,0 +1,553 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+/* Document
+   ========================================================================== */
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+html {
+  line-height: 1.15;
+  /* 1 */
+  -webkit-text-size-adjust: 100%;
+  /* 2 */
+}
+
+/* Sections
+     ========================================================================== */
+/**
+   * Remove the margin in all browsers.
+   */
+body {
+  margin: 0;
+}
+
+/**
+   * Render the `main` element consistently in IE.
+   */
+main {
+  display: block;
+}
+
+/**
+   * Correct the font size and margin on `h1` elements within `section` and
+   * `article` contexts in Chrome, Firefox, and Safari.
+   */
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+/* Grouping content
+     ========================================================================== */
+/**
+   * 1. Add the correct box sizing in Firefox.
+   * 2. Show the overflow in Edge and IE.
+   */
+hr {
+  box-sizing: content-box;
+  /* 1 */
+  height: 0;
+  /* 1 */
+  overflow: visible;
+  /* 2 */
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+pre {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/* Text-level semantics
+     ========================================================================== */
+/**
+   * Remove the gray background on active links in IE 10.
+   */
+a {
+  background-color: transparent;
+}
+
+/**
+   * 1. Remove the bottom border in Chrome 57-
+   * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+   */
+abbr[title] {
+  border-bottom: none;
+  /* 1 */
+  text-decoration: underline;
+  /* 2 */
+  text-decoration: underline dotted;
+  /* 2 */
+}
+
+/**
+   * Add the correct font weight in Chrome, Edge, and Safari.
+   */
+b,
+strong {
+  font-weight: bolder;
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+code,
+kbd,
+samp {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/**
+   * Add the correct font size in all browsers.
+   */
+small {
+  font-size: 80%;
+}
+
+/**
+   * Prevent `sub` and `sup` elements from affecting the line height in
+   * all browsers.
+   */
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/* Embedded content
+     ========================================================================== */
+/**
+   * Remove the border on images inside links in IE 10.
+   */
+img {
+  border-style: none;
+}
+
+/* Forms
+     ========================================================================== */
+/**
+   * 1. Change the font styles in all browsers.
+   * 2. Remove the margin in Firefox and Safari.
+   */
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+  /* 1 */
+  font-size: 100%;
+  /* 1 */
+  line-height: 1.15;
+  /* 1 */
+  margin: 0;
+  /* 2 */
+}
+
+/**
+   * Show the overflow in IE.
+   * 1. Show the overflow in Edge.
+   */
+button,
+input {
+  /* 1 */
+  overflow: visible;
+}
+
+/**
+   * Remove the inheritance of text transform in Edge, Firefox, and IE.
+   * 1. Remove the inheritance of text transform in Firefox.
+   */
+button,
+select {
+  /* 1 */
+  text-transform: none;
+}
+
+/**
+   * Correct the inability to style clickable types in iOS and Safari.
+   */
+button,
+[type=button],
+[type=reset],
+[type=submit] {
+  -webkit-appearance: button;
+}
+
+/**
+   * Remove the inner border and padding in Firefox.
+   */
+button::-moz-focus-inner,
+[type=button]::-moz-focus-inner,
+[type=reset]::-moz-focus-inner,
+[type=submit]::-moz-focus-inner {
+  border-style: none;
+  padding: 0;
+}
+
+/**
+   * Restore the focus styles unset by the previous rule.
+   */
+button:-moz-focusring,
+[type=button]:-moz-focusring,
+[type=reset]:-moz-focusring,
+[type=submit]:-moz-focusring {
+  outline: 1px dotted ButtonText;
+}
+
+/**
+   * Correct the padding in Firefox.
+   */
+fieldset {
+  padding: 0.35em 0.75em 0.625em;
+}
+
+/**
+   * 1. Correct the text wrapping in Edge and IE.
+   * 2. Correct the color inheritance from `fieldset` elements in IE.
+   * 3. Remove the padding so developers are not caught out when they zero out
+   *    `fieldset` elements in all browsers.
+   */
+legend {
+  box-sizing: border-box;
+  /* 1 */
+  color: inherit;
+  /* 2 */
+  display: table;
+  /* 1 */
+  max-width: 100%;
+  /* 1 */
+  padding: 0;
+  /* 3 */
+  white-space: normal;
+  /* 1 */
+}
+
+/**
+   * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+   */
+progress {
+  vertical-align: baseline;
+}
+
+/**
+   * Remove the default vertical scrollbar in IE 10+.
+   */
+textarea {
+  overflow: auto;
+}
+
+/**
+   * 1. Add the correct box sizing in IE 10.
+   * 2. Remove the padding in IE 10.
+   */
+[type=checkbox],
+[type=radio] {
+  box-sizing: border-box;
+  /* 1 */
+  padding: 0;
+  /* 2 */
+}
+
+/**
+   * Correct the cursor style of increment and decrement buttons in Chrome.
+   */
+[type=number]::-webkit-inner-spin-button,
+[type=number]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/**
+   * 1. Correct the odd appearance in Chrome and Safari.
+   * 2. Correct the outline style in Safari.
+   */
+[type=search] {
+  -webkit-appearance: textfield;
+  /* 1 */
+  outline-offset: -2px;
+  /* 2 */
+}
+
+/**
+   * Remove the inner padding in Chrome and Safari on macOS.
+   */
+[type=search]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/**
+   * 1. Correct the inability to style clickable types in iOS and Safari.
+   * 2. Change font properties to `inherit` in Safari.
+   */
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  /* 1 */
+  font: inherit;
+  /* 2 */
+}
+
+/* Interactive
+     ========================================================================== */
+/*
+   * Add the correct display in Edge, IE 10+, and Firefox.
+   */
+details {
+  display: block;
+}
+
+/*
+   * Add the correct display in all browsers.
+   */
+summary {
+  display: list-item;
+}
+
+/* Misc
+     ========================================================================== */
+/**
+   * Add the correct display in IE 10+.
+   */
+template {
+  display: none;
+}
+
+/**
+   * Add the correct display in IE 10.
+   */
+[hidden] {
+  display: none;
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+th {
+  text-align: inherit;
+  text-align: -webkit-match-parent;
+}
+
+thead,
+tbody,
+tfoot,
+tr,
+td,
+th {
+  border-color: inherit;
+  border-style: solid;
+  border-width: 0;
+}
+
+body {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  background-color: #fff;
+  direction: rtl;
+  -webkit-text-size-adjust: 100%;
+  -webkit-tap-highlight-color: transparent;
+}
+
+@font-face {
+  font-family: "Noto Sans";
+  src: local("Noto Sans"), url(data:font/woff2;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Segoe UI";
+  src: local("Segoe UI"), url(data:application/x-font-woff;charset=utf-8;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+body {
+  background: #f8f9fa;
+  text-align: right;
+  -webkit-print-color-adjust: exact;
+}
+html[lang^=ar] body {
+  font-family: "Segoe UI";
+}
+html[lang^=en] body {
+  font-family: "Noto Sans";
+}
+@media print {
+  body {
+    background: #fff;
+  }
+}
+
+.payment {
+  text-align: right;
+  padding: 45px 40px;
+}
+.payment__header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  margin: 0 0 30px;
+}
+.payment__header .organization .title {
+  margin: 0 0 4px;
+}
+.payment__header .organization .paymentNumber {
+  font-size: 12px;
+}
+.payment__header .paper .title {
+  font-weight: 400;
+  text-transform: uppercase;
+  margin: 0 0 2px;
+  font-size: 32px;
+  line-height: 1;
+}
+.payment__meta {
+  display: flex;
+  flex-direction: column;
+  margin-bottom: 20px;
+  font-size: 13px;
+}
+.payment__meta-item {
+  padding-left: 10px;
+  font-weight: 400;
+  margin-bottom: 10px;
+  display: flex;
+  flex-direction: row;
+}
+.payment__meta-item .value {
+  color: #000;
+}
+.payment__meta-item .label {
+  color: #444;
+  margin-bottom: 2px;
+  width: 180px;
+}
+.payment__table {
+  display: flex;
+  flex-direction: column;
+}
+.payment__table table {
+  font-size: 12px;
+  color: #000;
+  text-align: right;
+  border-spacing: 0;
+}
+.payment__table table thead th,
+.payment__table table tbody tr td {
+  margin-bottom: 15px;
+  background: transparent;
+}
+.payment__table table thead th {
+  font-weight: 400;
+  border-bottom: none;
+  padding: 8px;
+  color: #fff;
+  background-color: #333;
+}
+.payment__table table tbody tr td {
+  padding: 8px;
+  border-bottom: 1px solid #cecbcb;
+}
+.payment__table table thead tr th.item,
+.payment__table table tbody tr td.item {
+  width: 34%;
+}
+.payment__table table thead tr th.date,
+.payment__table table tbody tr td.date {
+  width: 22%;
+  text-align: left;
+}
+.payment__table table thead tr th.invoiceAmount,
+.payment__table table tbody tr td.invoiceAmount {
+  width: 22%;
+  text-align: left;
+}
+.payment__table table thead tr th.paymentAmount,
+.payment__table table tbody tr td.paymentAmount {
+  width: 22%;
+  text-align: left;
+}
+.payment__table table .description {
+  color: #666;
+}
+.payment__table-after {
+  display: flex;
+}
+.payment__table-total {
+  margin-bottom: 20px;
+  width: 50%;
+  float: left;
+  margin-right: auto;
+}
+.payment__table-total table {
+  border-spacing: 0;
+  width: 100%;
+  font-size: 12px;
+}
+.payment__table-total table tbody tr td {
+  padding: 8px 0 8px 10px;
+  border-top: 1px solid #d5d5d5;
+}
+.payment__table-total table tbody tr td:last-child {
+  width: 140px;
+  text-align: left;
+}
+.payment__table-total table tbody tr:first-child td {
+  border-top: 0;
+}
+.payment__table-total table tbody tr.payment-amount td:last-child {
+  color: red;
+}
+.payment__table-total table tbody tr.blanace-due td {
+  border-top: 3px double #666;
+  font-weight: bold;
+}
+.payment__received-amount {
+  margin-bottom: 18px;
+}
+.payment__received-amount .label {
+  font-size: 12px;
+}
+.payment__received-amount .amount {
+  font-size: 18px;
+  font-weight: 800;
+}
+.payment__footer {
+  font-size: 12px;
+}
+.payment__conditions h3, .payment__notes h3 {
+  color: #666;
+  font-size: 12px;
+  margin-top: 0;
+  margin-bottom: 10px;
+}
+.payment__conditions p, .payment__notes p {
+  margin: 0;
+}
+.payment__conditions + .payment__notes {
+  margin-top: 20px;
+}
\ No newline at end of file
diff --git a/packages/server/resources/css/modules/payment.css b/packages/server/resources/css/modules/payment.css
new file mode 100644
index 000000000..ce62246ae
--- /dev/null
+++ b/packages/server/resources/css/modules/payment.css
@@ -0,0 +1,553 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+/* Document
+   ========================================================================== */
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+html {
+  line-height: 1.15;
+  /* 1 */
+  -webkit-text-size-adjust: 100%;
+  /* 2 */
+}
+
+/* Sections
+     ========================================================================== */
+/**
+   * Remove the margin in all browsers.
+   */
+body {
+  margin: 0;
+}
+
+/**
+   * Render the `main` element consistently in IE.
+   */
+main {
+  display: block;
+}
+
+/**
+   * Correct the font size and margin on `h1` elements within `section` and
+   * `article` contexts in Chrome, Firefox, and Safari.
+   */
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+/* Grouping content
+     ========================================================================== */
+/**
+   * 1. Add the correct box sizing in Firefox.
+   * 2. Show the overflow in Edge and IE.
+   */
+hr {
+  box-sizing: content-box;
+  /* 1 */
+  height: 0;
+  /* 1 */
+  overflow: visible;
+  /* 2 */
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+pre {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/* Text-level semantics
+     ========================================================================== */
+/**
+   * Remove the gray background on active links in IE 10.
+   */
+a {
+  background-color: transparent;
+}
+
+/**
+   * 1. Remove the bottom border in Chrome 57-
+   * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+   */
+abbr[title] {
+  border-bottom: none;
+  /* 1 */
+  text-decoration: underline;
+  /* 2 */
+  text-decoration: underline dotted;
+  /* 2 */
+}
+
+/**
+   * Add the correct font weight in Chrome, Edge, and Safari.
+   */
+b,
+strong {
+  font-weight: bolder;
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+code,
+kbd,
+samp {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/**
+   * Add the correct font size in all browsers.
+   */
+small {
+  font-size: 80%;
+}
+
+/**
+   * Prevent `sub` and `sup` elements from affecting the line height in
+   * all browsers.
+   */
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/* Embedded content
+     ========================================================================== */
+/**
+   * Remove the border on images inside links in IE 10.
+   */
+img {
+  border-style: none;
+}
+
+/* Forms
+     ========================================================================== */
+/**
+   * 1. Change the font styles in all browsers.
+   * 2. Remove the margin in Firefox and Safari.
+   */
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+  /* 1 */
+  font-size: 100%;
+  /* 1 */
+  line-height: 1.15;
+  /* 1 */
+  margin: 0;
+  /* 2 */
+}
+
+/**
+   * Show the overflow in IE.
+   * 1. Show the overflow in Edge.
+   */
+button,
+input {
+  /* 1 */
+  overflow: visible;
+}
+
+/**
+   * Remove the inheritance of text transform in Edge, Firefox, and IE.
+   * 1. Remove the inheritance of text transform in Firefox.
+   */
+button,
+select {
+  /* 1 */
+  text-transform: none;
+}
+
+/**
+   * Correct the inability to style clickable types in iOS and Safari.
+   */
+button,
+[type=button],
+[type=reset],
+[type=submit] {
+  -webkit-appearance: button;
+}
+
+/**
+   * Remove the inner border and padding in Firefox.
+   */
+button::-moz-focus-inner,
+[type=button]::-moz-focus-inner,
+[type=reset]::-moz-focus-inner,
+[type=submit]::-moz-focus-inner {
+  border-style: none;
+  padding: 0;
+}
+
+/**
+   * Restore the focus styles unset by the previous rule.
+   */
+button:-moz-focusring,
+[type=button]:-moz-focusring,
+[type=reset]:-moz-focusring,
+[type=submit]:-moz-focusring {
+  outline: 1px dotted ButtonText;
+}
+
+/**
+   * Correct the padding in Firefox.
+   */
+fieldset {
+  padding: 0.35em 0.75em 0.625em;
+}
+
+/**
+   * 1. Correct the text wrapping in Edge and IE.
+   * 2. Correct the color inheritance from `fieldset` elements in IE.
+   * 3. Remove the padding so developers are not caught out when they zero out
+   *    `fieldset` elements in all browsers.
+   */
+legend {
+  box-sizing: border-box;
+  /* 1 */
+  color: inherit;
+  /* 2 */
+  display: table;
+  /* 1 */
+  max-width: 100%;
+  /* 1 */
+  padding: 0;
+  /* 3 */
+  white-space: normal;
+  /* 1 */
+}
+
+/**
+   * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+   */
+progress {
+  vertical-align: baseline;
+}
+
+/**
+   * Remove the default vertical scrollbar in IE 10+.
+   */
+textarea {
+  overflow: auto;
+}
+
+/**
+   * 1. Add the correct box sizing in IE 10.
+   * 2. Remove the padding in IE 10.
+   */
+[type=checkbox],
+[type=radio] {
+  box-sizing: border-box;
+  /* 1 */
+  padding: 0;
+  /* 2 */
+}
+
+/**
+   * Correct the cursor style of increment and decrement buttons in Chrome.
+   */
+[type=number]::-webkit-inner-spin-button,
+[type=number]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/**
+   * 1. Correct the odd appearance in Chrome and Safari.
+   * 2. Correct the outline style in Safari.
+   */
+[type=search] {
+  -webkit-appearance: textfield;
+  /* 1 */
+  outline-offset: -2px;
+  /* 2 */
+}
+
+/**
+   * Remove the inner padding in Chrome and Safari on macOS.
+   */
+[type=search]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/**
+   * 1. Correct the inability to style clickable types in iOS and Safari.
+   * 2. Change font properties to `inherit` in Safari.
+   */
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  /* 1 */
+  font: inherit;
+  /* 2 */
+}
+
+/* Interactive
+     ========================================================================== */
+/*
+   * Add the correct display in Edge, IE 10+, and Firefox.
+   */
+details {
+  display: block;
+}
+
+/*
+   * Add the correct display in all browsers.
+   */
+summary {
+  display: list-item;
+}
+
+/* Misc
+     ========================================================================== */
+/**
+   * Add the correct display in IE 10+.
+   */
+template {
+  display: none;
+}
+
+/**
+   * Add the correct display in IE 10.
+   */
+[hidden] {
+  display: none;
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+th {
+  text-align: inherit;
+  text-align: -webkit-match-parent;
+}
+
+thead,
+tbody,
+tfoot,
+tr,
+td,
+th {
+  border-color: inherit;
+  border-style: solid;
+  border-width: 0;
+}
+
+body {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  background-color: #fff;
+  direction: ltr;
+  -webkit-text-size-adjust: 100%;
+  -webkit-tap-highlight-color: transparent;
+}
+
+@font-face {
+  font-family: "Noto Sans";
+  src: local("Noto Sans"), url(data:font/woff2;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Segoe UI";
+  src: local("Segoe UI"), url(data:application/x-font-woff;charset=utf-8;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+body {
+  background: #f8f9fa;
+  text-align: left;
+  -webkit-print-color-adjust: exact;
+}
+html[lang^=ar] body {
+  font-family: "Segoe UI";
+}
+html[lang^=en] body {
+  font-family: "Noto Sans";
+}
+@media print {
+  body {
+    background: #fff;
+  }
+}
+
+.payment {
+  text-align: left;
+  padding: 45px 40px;
+}
+.payment__header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  margin: 0 0 30px;
+}
+.payment__header .organization .title {
+  margin: 0 0 4px;
+}
+.payment__header .organization .paymentNumber {
+  font-size: 12px;
+}
+.payment__header .paper .title {
+  font-weight: 400;
+  text-transform: uppercase;
+  margin: 0 0 2px;
+  font-size: 32px;
+  line-height: 1;
+}
+.payment__meta {
+  display: flex;
+  flex-direction: column;
+  margin-bottom: 20px;
+  font-size: 13px;
+}
+.payment__meta-item {
+  padding-right: 10px;
+  font-weight: 400;
+  margin-bottom: 10px;
+  display: flex;
+  flex-direction: row;
+}
+.payment__meta-item .value {
+  color: #000;
+}
+.payment__meta-item .label {
+  color: #444;
+  margin-bottom: 2px;
+  width: 180px;
+}
+.payment__table {
+  display: flex;
+  flex-direction: column;
+}
+.payment__table table {
+  font-size: 12px;
+  color: #000;
+  text-align: left;
+  border-spacing: 0;
+}
+.payment__table table thead th,
+.payment__table table tbody tr td {
+  margin-bottom: 15px;
+  background: transparent;
+}
+.payment__table table thead th {
+  font-weight: 400;
+  border-bottom: none;
+  padding: 8px;
+  color: #fff;
+  background-color: #333;
+}
+.payment__table table tbody tr td {
+  padding: 8px;
+  border-bottom: 1px solid #cecbcb;
+}
+.payment__table table thead tr th.item,
+.payment__table table tbody tr td.item {
+  width: 34%;
+}
+.payment__table table thead tr th.date,
+.payment__table table tbody tr td.date {
+  width: 22%;
+  text-align: right;
+}
+.payment__table table thead tr th.invoiceAmount,
+.payment__table table tbody tr td.invoiceAmount {
+  width: 22%;
+  text-align: right;
+}
+.payment__table table thead tr th.paymentAmount,
+.payment__table table tbody tr td.paymentAmount {
+  width: 22%;
+  text-align: right;
+}
+.payment__table table .description {
+  color: #666;
+}
+.payment__table-after {
+  display: flex;
+}
+.payment__table-total {
+  margin-bottom: 20px;
+  width: 50%;
+  float: right;
+  margin-left: auto;
+}
+.payment__table-total table {
+  border-spacing: 0;
+  width: 100%;
+  font-size: 12px;
+}
+.payment__table-total table tbody tr td {
+  padding: 8px 10px 8px 0;
+  border-top: 1px solid #d5d5d5;
+}
+.payment__table-total table tbody tr td:last-child {
+  width: 140px;
+  text-align: right;
+}
+.payment__table-total table tbody tr:first-child td {
+  border-top: 0;
+}
+.payment__table-total table tbody tr.payment-amount td:last-child {
+  color: red;
+}
+.payment__table-total table tbody tr.blanace-due td {
+  border-top: 3px double #666;
+  font-weight: bold;
+}
+.payment__received-amount {
+  margin-bottom: 18px;
+}
+.payment__received-amount .label {
+  font-size: 12px;
+}
+.payment__received-amount .amount {
+  font-size: 18px;
+  font-weight: 800;
+}
+.payment__footer {
+  font-size: 12px;
+}
+.payment__conditions h3, .payment__notes h3 {
+  color: #666;
+  font-size: 12px;
+  margin-top: 0;
+  margin-bottom: 10px;
+}
+.payment__conditions p, .payment__notes p {
+  margin: 0;
+}
+.payment__conditions + .payment__notes {
+  margin-top: 20px;
+}
\ No newline at end of file
diff --git a/packages/server/resources/css/modules/receipt-rtl.css b/packages/server/resources/css/modules/receipt-rtl.css
new file mode 100644
index 000000000..95b84b8b4
--- /dev/null
+++ b/packages/server/resources/css/modules/receipt-rtl.css
@@ -0,0 +1,546 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+/* Document
+   ========================================================================== */
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+html {
+  line-height: 1.15;
+  /* 1 */
+  -webkit-text-size-adjust: 100%;
+  /* 2 */
+}
+
+/* Sections
+     ========================================================================== */
+/**
+   * Remove the margin in all browsers.
+   */
+body {
+  margin: 0;
+}
+
+/**
+   * Render the `main` element consistently in IE.
+   */
+main {
+  display: block;
+}
+
+/**
+   * Correct the font size and margin on `h1` elements within `section` and
+   * `article` contexts in Chrome, Firefox, and Safari.
+   */
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+/* Grouping content
+     ========================================================================== */
+/**
+   * 1. Add the correct box sizing in Firefox.
+   * 2. Show the overflow in Edge and IE.
+   */
+hr {
+  box-sizing: content-box;
+  /* 1 */
+  height: 0;
+  /* 1 */
+  overflow: visible;
+  /* 2 */
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+pre {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/* Text-level semantics
+     ========================================================================== */
+/**
+   * Remove the gray background on active links in IE 10.
+   */
+a {
+  background-color: transparent;
+}
+
+/**
+   * 1. Remove the bottom border in Chrome 57-
+   * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+   */
+abbr[title] {
+  border-bottom: none;
+  /* 1 */
+  text-decoration: underline;
+  /* 2 */
+  text-decoration: underline dotted;
+  /* 2 */
+}
+
+/**
+   * Add the correct font weight in Chrome, Edge, and Safari.
+   */
+b,
+strong {
+  font-weight: bolder;
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+code,
+kbd,
+samp {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/**
+   * Add the correct font size in all browsers.
+   */
+small {
+  font-size: 80%;
+}
+
+/**
+   * Prevent `sub` and `sup` elements from affecting the line height in
+   * all browsers.
+   */
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/* Embedded content
+     ========================================================================== */
+/**
+   * Remove the border on images inside links in IE 10.
+   */
+img {
+  border-style: none;
+}
+
+/* Forms
+     ========================================================================== */
+/**
+   * 1. Change the font styles in all browsers.
+   * 2. Remove the margin in Firefox and Safari.
+   */
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+  /* 1 */
+  font-size: 100%;
+  /* 1 */
+  line-height: 1.15;
+  /* 1 */
+  margin: 0;
+  /* 2 */
+}
+
+/**
+   * Show the overflow in IE.
+   * 1. Show the overflow in Edge.
+   */
+button,
+input {
+  /* 1 */
+  overflow: visible;
+}
+
+/**
+   * Remove the inheritance of text transform in Edge, Firefox, and IE.
+   * 1. Remove the inheritance of text transform in Firefox.
+   */
+button,
+select {
+  /* 1 */
+  text-transform: none;
+}
+
+/**
+   * Correct the inability to style clickable types in iOS and Safari.
+   */
+button,
+[type=button],
+[type=reset],
+[type=submit] {
+  -webkit-appearance: button;
+}
+
+/**
+   * Remove the inner border and padding in Firefox.
+   */
+button::-moz-focus-inner,
+[type=button]::-moz-focus-inner,
+[type=reset]::-moz-focus-inner,
+[type=submit]::-moz-focus-inner {
+  border-style: none;
+  padding: 0;
+}
+
+/**
+   * Restore the focus styles unset by the previous rule.
+   */
+button:-moz-focusring,
+[type=button]:-moz-focusring,
+[type=reset]:-moz-focusring,
+[type=submit]:-moz-focusring {
+  outline: 1px dotted ButtonText;
+}
+
+/**
+   * Correct the padding in Firefox.
+   */
+fieldset {
+  padding: 0.35em 0.75em 0.625em;
+}
+
+/**
+   * 1. Correct the text wrapping in Edge and IE.
+   * 2. Correct the color inheritance from `fieldset` elements in IE.
+   * 3. Remove the padding so developers are not caught out when they zero out
+   *    `fieldset` elements in all browsers.
+   */
+legend {
+  box-sizing: border-box;
+  /* 1 */
+  color: inherit;
+  /* 2 */
+  display: table;
+  /* 1 */
+  max-width: 100%;
+  /* 1 */
+  padding: 0;
+  /* 3 */
+  white-space: normal;
+  /* 1 */
+}
+
+/**
+   * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+   */
+progress {
+  vertical-align: baseline;
+}
+
+/**
+   * Remove the default vertical scrollbar in IE 10+.
+   */
+textarea {
+  overflow: auto;
+}
+
+/**
+   * 1. Add the correct box sizing in IE 10.
+   * 2. Remove the padding in IE 10.
+   */
+[type=checkbox],
+[type=radio] {
+  box-sizing: border-box;
+  /* 1 */
+  padding: 0;
+  /* 2 */
+}
+
+/**
+   * Correct the cursor style of increment and decrement buttons in Chrome.
+   */
+[type=number]::-webkit-inner-spin-button,
+[type=number]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/**
+   * 1. Correct the odd appearance in Chrome and Safari.
+   * 2. Correct the outline style in Safari.
+   */
+[type=search] {
+  -webkit-appearance: textfield;
+  /* 1 */
+  outline-offset: -2px;
+  /* 2 */
+}
+
+/**
+   * Remove the inner padding in Chrome and Safari on macOS.
+   */
+[type=search]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/**
+   * 1. Correct the inability to style clickable types in iOS and Safari.
+   * 2. Change font properties to `inherit` in Safari.
+   */
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  /* 1 */
+  font: inherit;
+  /* 2 */
+}
+
+/* Interactive
+     ========================================================================== */
+/*
+   * Add the correct display in Edge, IE 10+, and Firefox.
+   */
+details {
+  display: block;
+}
+
+/*
+   * Add the correct display in all browsers.
+   */
+summary {
+  display: list-item;
+}
+
+/* Misc
+     ========================================================================== */
+/**
+   * Add the correct display in IE 10+.
+   */
+template {
+  display: none;
+}
+
+/**
+   * Add the correct display in IE 10.
+   */
+[hidden] {
+  display: none;
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+th {
+  text-align: inherit;
+  text-align: -webkit-match-parent;
+}
+
+thead,
+tbody,
+tfoot,
+tr,
+td,
+th {
+  border-color: inherit;
+  border-style: solid;
+  border-width: 0;
+}
+
+body {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  background-color: #fff;
+  direction: rtl;
+  -webkit-text-size-adjust: 100%;
+  -webkit-tap-highlight-color: transparent;
+}
+
+@font-face {
+  font-family: "Noto Sans";
+  src: local("Noto Sans"), url(data:font/woff2;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Segoe UI";
+  src: local("Segoe UI"), url(data:application/x-font-woff;charset=utf-8;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+body {
+  background: #f8f9fa;
+  text-align: right;
+  -webkit-print-color-adjust: exact;
+}
+html[lang^=ar] body {
+  font-family: "Segoe UI";
+}
+html[lang^=en] body {
+  font-family: "Noto Sans";
+}
+@media print {
+  body {
+    background: #fff;
+  }
+}
+
+.receipt {
+  text-align: right;
+  padding: 45px;
+}
+.receipt__header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  margin: 0 0 30px;
+}
+.receipt__header .organization .title {
+  margin: 0 0 4px;
+}
+.receipt__header .organization .receiptNumber {
+  margin: 0 0 12px;
+}
+.receipt__header .paper .title {
+  font-weight: 400;
+  text-transform: uppercase;
+  margin: 0 0 2px;
+  font-size: 32px;
+  line-height: 1;
+}
+.receipt__receipt-amount {
+  margin-bottom: 18px;
+}
+.receipt__receipt-amount .label {
+  font-size: 12px;
+}
+.receipt__receipt-amount .amount {
+  font-size: 18px;
+  font-weight: 800;
+}
+.receipt__meta {
+  display: flex;
+  flex-direction: column;
+  margin-bottom: 20px;
+  font-size: 13px;
+}
+.receipt__meta-item {
+  padding-left: 10px;
+  margin-bottom: 10px;
+  display: flex;
+  flex-direction: row;
+}
+.receipt__meta-item .value {
+  color: #000;
+}
+.receipt__meta-item .label {
+  color: #444;
+  margin-bottom: 2px;
+  width: 180px;
+}
+.receipt__table {
+  display: flex;
+  flex-direction: column;
+}
+.receipt__table table {
+  font-size: 12px;
+  color: #000;
+  text-align: right;
+  border-spacing: 0;
+}
+.receipt__table table thead th,
+.receipt__table table tbody tr td {
+  margin-bottom: 15px;
+  background: transparent;
+}
+.receipt__table table thead th {
+  font-weight: 400;
+  border-bottom: none;
+  padding: 8px;
+  color: #fff;
+  background-color: #333;
+}
+.receipt__table table tbody tr td {
+  padding: 10px;
+  border-bottom: 1px solid #cecbcb;
+}
+.receipt__table table thead tr th.item,
+.receipt__table table tbody tr td.item {
+  width: 45%;
+}
+.receipt__table table thead tr th.rate,
+.receipt__table table tbody tr td.rate {
+  width: 18%;
+  text-align: left;
+}
+.receipt__table table thead tr th.quantity,
+.receipt__table table tbody tr td.quantity {
+  width: 16%;
+  text-align: left;
+}
+.receipt__table table thead tr th.total,
+.receipt__table table tbody tr td.total {
+  width: 21%;
+  text-align: left;
+}
+.receipt__table-after {
+  display: flex;
+}
+.receipt__table-total {
+  margin-bottom: 20px;
+  width: 50%;
+  float: left;
+  margin-right: auto;
+}
+.receipt__table-total table {
+  border-spacing: 0;
+  width: 100%;
+  font-size: 12px;
+}
+.receipt__table-total table tbody tr td {
+  padding: 8px 0 8px 10px;
+  border-top: 1px solid #d5d5d5;
+}
+.receipt__table-total table tbody tr td:last-child {
+  width: 140px;
+  text-align: left;
+}
+.receipt__table-total table tbody tr:first-child td {
+  border-top: 0;
+}
+.receipt__table-total table tbody tr.payment-amount td:last-child {
+  color: red;
+}
+.receipt__table-total table tbody tr.blanace-due td {
+  border-top: 3px double #666;
+  font-weight: bold;
+}
+.receipt__footer {
+  font-size: 12px;
+}
+.receipt__conditions h3, .receipt__notes h3 {
+  color: #666;
+  font-size: 12px;
+  margin-top: 0;
+  margin-bottom: 10px;
+}
+.receipt__conditions p, .receipt__notes p {
+  margin: 0 0 20px;
+}
\ No newline at end of file
diff --git a/packages/server/resources/css/modules/receipt.css b/packages/server/resources/css/modules/receipt.css
new file mode 100644
index 000000000..544a8e358
--- /dev/null
+++ b/packages/server/resources/css/modules/receipt.css
@@ -0,0 +1,546 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+/* Document
+   ========================================================================== */
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+html {
+  line-height: 1.15;
+  /* 1 */
+  -webkit-text-size-adjust: 100%;
+  /* 2 */
+}
+
+/* Sections
+     ========================================================================== */
+/**
+   * Remove the margin in all browsers.
+   */
+body {
+  margin: 0;
+}
+
+/**
+   * Render the `main` element consistently in IE.
+   */
+main {
+  display: block;
+}
+
+/**
+   * Correct the font size and margin on `h1` elements within `section` and
+   * `article` contexts in Chrome, Firefox, and Safari.
+   */
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+/* Grouping content
+     ========================================================================== */
+/**
+   * 1. Add the correct box sizing in Firefox.
+   * 2. Show the overflow in Edge and IE.
+   */
+hr {
+  box-sizing: content-box;
+  /* 1 */
+  height: 0;
+  /* 1 */
+  overflow: visible;
+  /* 2 */
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+pre {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/* Text-level semantics
+     ========================================================================== */
+/**
+   * Remove the gray background on active links in IE 10.
+   */
+a {
+  background-color: transparent;
+}
+
+/**
+   * 1. Remove the bottom border in Chrome 57-
+   * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+   */
+abbr[title] {
+  border-bottom: none;
+  /* 1 */
+  text-decoration: underline;
+  /* 2 */
+  text-decoration: underline dotted;
+  /* 2 */
+}
+
+/**
+   * Add the correct font weight in Chrome, Edge, and Safari.
+   */
+b,
+strong {
+  font-weight: bolder;
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+code,
+kbd,
+samp {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/**
+   * Add the correct font size in all browsers.
+   */
+small {
+  font-size: 80%;
+}
+
+/**
+   * Prevent `sub` and `sup` elements from affecting the line height in
+   * all browsers.
+   */
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/* Embedded content
+     ========================================================================== */
+/**
+   * Remove the border on images inside links in IE 10.
+   */
+img {
+  border-style: none;
+}
+
+/* Forms
+     ========================================================================== */
+/**
+   * 1. Change the font styles in all browsers.
+   * 2. Remove the margin in Firefox and Safari.
+   */
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+  /* 1 */
+  font-size: 100%;
+  /* 1 */
+  line-height: 1.15;
+  /* 1 */
+  margin: 0;
+  /* 2 */
+}
+
+/**
+   * Show the overflow in IE.
+   * 1. Show the overflow in Edge.
+   */
+button,
+input {
+  /* 1 */
+  overflow: visible;
+}
+
+/**
+   * Remove the inheritance of text transform in Edge, Firefox, and IE.
+   * 1. Remove the inheritance of text transform in Firefox.
+   */
+button,
+select {
+  /* 1 */
+  text-transform: none;
+}
+
+/**
+   * Correct the inability to style clickable types in iOS and Safari.
+   */
+button,
+[type=button],
+[type=reset],
+[type=submit] {
+  -webkit-appearance: button;
+}
+
+/**
+   * Remove the inner border and padding in Firefox.
+   */
+button::-moz-focus-inner,
+[type=button]::-moz-focus-inner,
+[type=reset]::-moz-focus-inner,
+[type=submit]::-moz-focus-inner {
+  border-style: none;
+  padding: 0;
+}
+
+/**
+   * Restore the focus styles unset by the previous rule.
+   */
+button:-moz-focusring,
+[type=button]:-moz-focusring,
+[type=reset]:-moz-focusring,
+[type=submit]:-moz-focusring {
+  outline: 1px dotted ButtonText;
+}
+
+/**
+   * Correct the padding in Firefox.
+   */
+fieldset {
+  padding: 0.35em 0.75em 0.625em;
+}
+
+/**
+   * 1. Correct the text wrapping in Edge and IE.
+   * 2. Correct the color inheritance from `fieldset` elements in IE.
+   * 3. Remove the padding so developers are not caught out when they zero out
+   *    `fieldset` elements in all browsers.
+   */
+legend {
+  box-sizing: border-box;
+  /* 1 */
+  color: inherit;
+  /* 2 */
+  display: table;
+  /* 1 */
+  max-width: 100%;
+  /* 1 */
+  padding: 0;
+  /* 3 */
+  white-space: normal;
+  /* 1 */
+}
+
+/**
+   * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+   */
+progress {
+  vertical-align: baseline;
+}
+
+/**
+   * Remove the default vertical scrollbar in IE 10+.
+   */
+textarea {
+  overflow: auto;
+}
+
+/**
+   * 1. Add the correct box sizing in IE 10.
+   * 2. Remove the padding in IE 10.
+   */
+[type=checkbox],
+[type=radio] {
+  box-sizing: border-box;
+  /* 1 */
+  padding: 0;
+  /* 2 */
+}
+
+/**
+   * Correct the cursor style of increment and decrement buttons in Chrome.
+   */
+[type=number]::-webkit-inner-spin-button,
+[type=number]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/**
+   * 1. Correct the odd appearance in Chrome and Safari.
+   * 2. Correct the outline style in Safari.
+   */
+[type=search] {
+  -webkit-appearance: textfield;
+  /* 1 */
+  outline-offset: -2px;
+  /* 2 */
+}
+
+/**
+   * Remove the inner padding in Chrome and Safari on macOS.
+   */
+[type=search]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/**
+   * 1. Correct the inability to style clickable types in iOS and Safari.
+   * 2. Change font properties to `inherit` in Safari.
+   */
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  /* 1 */
+  font: inherit;
+  /* 2 */
+}
+
+/* Interactive
+     ========================================================================== */
+/*
+   * Add the correct display in Edge, IE 10+, and Firefox.
+   */
+details {
+  display: block;
+}
+
+/*
+   * Add the correct display in all browsers.
+   */
+summary {
+  display: list-item;
+}
+
+/* Misc
+     ========================================================================== */
+/**
+   * Add the correct display in IE 10+.
+   */
+template {
+  display: none;
+}
+
+/**
+   * Add the correct display in IE 10.
+   */
+[hidden] {
+  display: none;
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+th {
+  text-align: inherit;
+  text-align: -webkit-match-parent;
+}
+
+thead,
+tbody,
+tfoot,
+tr,
+td,
+th {
+  border-color: inherit;
+  border-style: solid;
+  border-width: 0;
+}
+
+body {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  background-color: #fff;
+  direction: ltr;
+  -webkit-text-size-adjust: 100%;
+  -webkit-tap-highlight-color: transparent;
+}
+
+@font-face {
+  font-family: "Noto Sans";
+  src: local("Noto Sans"), url(data:font/woff2;base64,d09GMgABAAAAACg0AA4AAAAATnQAACfcAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGmobjkQcMgZgAIMSERAK92zeaQuDVgABNgIkA4coBCAFgxgHIBskP7OifrReWouiJJBKFJWbfPJ/SGAj7gpbeYKdoc5ORrDie7ZO0WqWKEI0WzXf80+GFv6qhGs84DSE215aubwxNkdo7JNcHkL/4v8kmdy7j/gQWqiyXdRgC1UuiR7anf3223Y7xPz4kUy2EWFYyYRC6DxeH9JEM41WGYJtdubQnjGdiVGYGAlKKaEYOSZhISaYNbAaxZ6KMaO2KU7378y1a+ciwvV/3+fWVxUwVkXDsOcSRReEQPONMTvxASppZrM/K+GJhSaSAXP77tDuv8mdswepEjsj+CD2barmunMHsP2eJIsnwH/PfcsTzSihtAQCDWQB/d9a+LVsl1qGB/+ZFpqWrcEDvjGaljNZGsUL4w05BeBfe6ebOikiC2Njx3d7Wb/E/p/Osp2xD7S+kO642024y6aorkxSKdCm6Ud/LEszkhbQWnpe+ciH8obWQespsBQgrhBMRwxdiIsuHWCZl6JokNvwPPzhKx8KTcAH+FEj9PIyb/bWlzEpONvtE6xAxWJBrWbL1CsRyMWYdq2CTFQ6/V22Wcloj9f2DiEsIhIkSLC9v90fG1/6o68tesR0IAN9d1oFmO+UvkoADfLxVzGkw9yjsIQub2KY9OJEoCiCxLlQcSVMXOsT1YB4Niu+zYkfJ5ccgbkGqCROvTojBaidOcBMBtDz6rPYwIokeBr1p39c+SeDzj09gw3UaBNQNem+EUS7Lu6Vt/cOatyJUZwNRUXRrhfHMg+TW6Wxa9XmXN1bHdVyhkPYCJXirI0NGaj9JD+gUl2vueo0V32C4a41MWqADYcWM3ivaODiAXFZsvHuL6ee7xZpgajVfTmejquwGFdlO6jGgSN1zl2DO+TCXZoEOlLRzXEU4G65Kk7qMeimUTN3/EGkTt089f4LTWgIhoxwBlpBxxAlWkwRpgztHyDvRBk0adHtepn0baDohuniEA6kSZchU1ay48mBXHnJX9H7GxTZnHZ4RI1JlszmMVcWLAs8YR+HnmOcJM62uKS4xX09HoSA7J5paEAPA6JEi3m14xRFenGWSkSpMkdwCy+nylWoVKVRk2YtWvFLW6KdQMdhZ8bg6ZPZeP/mRjaNfCZlpUmrmGQwY84ilgLOPg4SR8uJc1zArdPS0IkhSrSYxM3DgTTpMmTKKkUZipUoVeYILp5yFSpVadSkWYtW/NKWqZ1Ah97FvhSh4pPyQ77e2UKv7MUY2vht9P/De/P5sUqnuS7v3Gwuzd+q4j4ud6f000D564ap9CVfW0o+Kf9YvF7ZVIfKZPtxWblo8GjuJyO86iFPvnRhmiFprwMppZRSioq4Bz8th90kYSbMWcQSHZ7OHnHw4mg5cS4uadwWPV8+RET0NXpAAQAAAAAAAM75sj+cQ5BbIMiZEAEATaFb+TnpF9BiPvSr4iFfiMlAvFABwFQQEQAAEEL4YSg5Jp/RQ3rsSA2DntacY1+g6ORPahXUadItHi7NpAT7M90BKOuV42qfiq8gWOu8XqPHlituAjYDnAsYLPT+B/oHABSQ08nl6Rgwub8eWh/EXvzGAhD7dJEUSQ5U0I+EaMsdO/sRUKTkAQt4vBzGUKDEgBmzbtv1E37B/+VQCam/1bP1Xn2w/izoHOg86HKoFlQPagg1hTpA3aG4bUPbnhsYGrQY8A1VDNX/+z+nmYB1uiYzKJGiFG54EM/hO/iPEwbX04csg2pCdU6OPdQt07wxwOO5UpDYbxYcyCHbHFDKft7y2exkE5j6/279u/lk0jPJJ5cB4Ntb/DKIjck19d/jmm9L6SdvPzraOyeIARzidDy7OwU7c7VwrztlyTIpX9LeFj31jNBzLwzNJFtQWFwg/5QY/24pXxDtLCw6SFj1udCWltcJcA2WjN4wYqMT2kN0Nt6ryUUrFF5QHSVVZJDUzj9J9uyj5wnKEEDZMuEhgr1r9Urg/iI0kNmWWEyKqXuhj2GwrSRYNyIMx3wdtsUUWBfrbuokwoRND8sGGbz4xZPssC0FILR1v62UcQ18U6iaGCcxMC3IYpU7mWLDaKfQ5SljSvM82Nht0JEtxmBhg70r31JZ3x3GQ9lwkkqKxWrBMfAmj82bZhpVq1jK0UhiukvjSJdJXV7z3FdsYPQQLH6uWRd0DSNiyGtqISdBNYRnHufQZsWcpZgIHBBZIHmqKlyuqB5CMYhiGae3h/9c7g/XS9/IzRuZk9qoAhTr4iEGUijrFZcGvrFDjUJMLvQKhpGOgiqfppccEsT60u95ckqpr+MSgwwIGyOw1ty2TlJWIkOvhXOMkWVpVop1GDEvWBWqe/hgiTopMbaX84SANSzpjXTYkfYOQjYr4f9MU4orpDTO+p2gAhgrE/Q7KMAQ4QkYmT9LKsxSpn3YFRZLQkWnOLuj3GJlAjdSVqmtzsjKYy8h4Xx9HFcsEXU5AwGweg+n6evpe3D1cJx/muZ5ftYuOCbpgIoMEnjYqF1+0fMVM1oou1hchC5fXd5XASyxfPAcX9G/2CHahqNKBEyixUNsV6gVm2ESdvwW+x7qXow+hN0oOb+KdUxnT84NrqSR8COmt/w0j9P7EHhUQ5tE5cxm1CklZUJVj4YMHK2O+MWQBPsJOLDSHnZ3wV2L+smGlL4y6UVwSNTVIY75WcrOZzN3/pBMdScnRqekxe3qVrSWxGfPqQDZuXhR4owQwYDxW6alEBevg0XSNv6ESfAHqhQJ4Tw0xYMUzkioaETFMiqmld/X4HXUsaTNmlcbXm43nDnUKvi6PlEeBuAGihpzFrnWZwJS1HWvJlc5i+lhgTPO5Rbm2WnUPpi1fQqlWEeKLcP4wOP1ACaSsu5zDOTVoit3dPfJGQpRlJnzi4YszimmSpg2S8GQajQA8FAByozPO0fmN0a5beoQ6v+3itANQD2mY1S9poq6adTcNSNDEKHibwnqDmi0LRjalBX1+LiccTQFZpJyupw4/DbQ0lscf6fWC56uaB5aJNwOlamT1kWzqgXyWR69Vx1upWUwr86EZZdPNSYk8VYVXORK6JSYoDtq+BZFHJINGKjoar2mWMbcksebNie73Emo9hfC3wJJVluqRLD6j8HQv4XbWe/d273wFOnMdkKtGRS4jtHKsT3IuUvZMWFXBZ/VnJ978EAOOLuuJhPC7JQmwrWg9L5DCp+9olvNerYi2Tdrni14uaL5lETaes0eSXoFDP9aK3WQjcgf5g84J5+VKqYrToRkGY21UM2oBntNwrAtBW4FmpEAVhBLjJDt0taWMtZRrMTkhzUYxmO7BLW6kVqCSCaMbnjJ4MLutMh2USEL8ZqF22TpUlPpA3igpg2MEiroJg1cliz99xwVqnLC0Vj+tGy8LVZHgv3xFeqG6C67OTIBGD995siG0gSZUpWLGLlSxQqGzIFa9tH+fApbY3Okh/MctYtoOgvnk9szikN2H0d55wM2MsiO6Jgs6qi9tgjAgjG6EStWqRqDzRkGMOqhbkOV12M10q7PlKSIJJIaKFCTwiovS31vJcMPeJsWuzwDJZ2KALJBI5Z1/vhCfflv4Bdv/qP2OH4wO1RoDutNe7hWKd/4zmIStaoL4LTTeDHXs+HvfEsbs9oOM3rgNqLr2YkhIXnUXs6p35l/jRuxrqccQ23KtWeUZ69SW1e0UC3qbeTYgNzqb9zCr4yvzgapCF0iSFESGZPIakeRt+PSNBdk3Y+BL2deDONzFa/Tq/87BNsGwKc8EoUu9d7uUHmxUaPO+R/ArhXXFj+QeJWodllheE3VEqbWKEdZRVLJyW8yYhjrQ7mu/b1eUFYWIoiqAXVyIq7hm9Cw6S/FcgjVMnV3oWeYE14rObMT1OFy6Xd4ikoSljXn/qweOkD2mhhcEPKMpqW31RAG9kmsyQHWHKgtuitLK7Z95AQKu3ZyG6WJNNlvvpMR1a02ktbBJrdgGRX6e4+D9MnIRUfl4BnbzJqwZCRyqUyBdzdsXgxunWEYEooVhHwnSsP/R2srhE0ntQh9oGdSiixq8dmAHbI1nQoBoYsbdtjFUj7PQsmzIt9m6MzAbuZUFl8BEgRI0jAKwSc0ok2PHSQoXCmdvMNyy0NsfQ/SE5tyZ5QuqOCsfPfrk475w483YF5/f0/58efbC6kWlkiiwBV+8quAUJ243TgphWxUIabAhxHrDdKJZqOSzo63CzDvxwJnQ6J0UEb+xpRcoe/DLsGpMWHYmeZb4yMyOtgoIp0UXOsgaElzSSbR8Cg8TuKTsR4dh+mGkXSLna5QTMJ8VANUkOoH2Ck7SXNxAtBQ2CmqDboMEXSLNjdPpNUsRQd66dY3kGNfGC846JPWwzrfNPHN70NTODA6BV/+0mEyeN1ujdovDxwBPV2+zq7IIttD4Ta7tvVz0f3Xr5+vWooVBc/rn8Yv/pKs/W8ZdsUDH7zkdVurCia1D1KzGz46gVub8fszC25TbTRHzAEFY/H5MMlp+eU//3HvZdW1v27bcJETrj4YbHUDpvSVrxf09qSADu1jq9uDH2TuXNI7k/QwWqC49XpuZXvzp1tXZkG7qdBZpUCBx58oJEqZWbyTp57EHDJZwLjire931/VoX/8Hfx85L8Pj7HdFAeVcpLnkVMyOWiRnJVS5K2k+6GjjWS/zPlk+Mm9+6GNgWgJZpaG2txbQOAd8gt9fg2WIA6YYXwj44v9AqhB7+9Mcx8p0cKge0851AqJUmz783P56RzLNtoYb0UWRSLb2/OXL5mJotrW147ZwYWGhsy9dvWrJRRM8e/Y2nSG2HyQxxApBQaFWqsoc5NJ2Y9BIepVwC3RUcX0rpZH2Q8vuEnOmh99Ojo9gcipJvBCqnXZkdnKdMD6dNzV2V6KJGalpHinhzJFXFxGBFFOyWPmv8oFahchcKT2VuZn98RMJ0GJrNRdPnj7wgnc/XeyaIVZvjGR4xz5GbOoyanympvzC+JTKPO/E75ITPi713Yh22dF+p14GsWAhlkALzTDLvaav+g8xjJJokk1TiqYArbgmtM+RAP9CHLM4yI8ZGURJoMm0BT7vaRnvrQmOqqKmd1WGfeFWbMyz/MJRcUZJHm1bkydHfjvWllq90BNZW0hNtr8jwunUdcMMvx+fTGd+pfB3v18H/osNBN0a2BsAycL79Yfe9/MSwzJjFPxlTYPb6XGd0xdPVCTdOJdV5j2nidE4cPPAXCkl9fr0yVYFxeaZBz6i6eCnNkic7a3nEXXnQvZS+I1xErcFdY/EdgMXRGTU4OG/1rb3O8r9f3m5/xH+cUCd3cRNby4bLfw2ajTy2whraNn7nm4uNGZkGchniwZNJWdOcxvGqjRlx3SOzrZsyt3fE5fjERSnelKP5E0kLn1NVjGbG6+q5Z0smgcO7RYfFDxUtKXsv/auuw1QDSY107DU6oRnoyGei3feTIYRe2YCQJjwbVJtSXoHkBKthxXmrEVqqOgd2Cs8Fwz+gPs54cL886EDobL5oPTU2AaSDh4MBo5Gkn9uZxp/Njnqn1oX+3IhLHz+7bsLYd79qyGnpEw8VAwPWivw6wxPoEFwIDg18WlCQ+RU0qckWzhGOWnStHXSPAmZL7Qp2FdO7+7xUSXHxeZlAKmZJSDVf3ZzB3y/K73UxnWRznC9uBbivYspAucmxgukVEqHgZ+eiThEsf997oSfqKzjOAPRmZ9R7GdYxBMovILoVQDAnoBdu+8rEMlAuYVKuOiG3bHyefzyv3qIhpwpxm0KUO0fMmJavLBRtQlMejXeM7qRgI42/GH74f03S1OTL+bvP/2wAj7fIU/gnw6MucGZAM/k8yP+vY363oaFurVlLW8E9Yfpl7xpyRAtooGpCZT8un9iqK62dqRk+fppqsafN3xlySvXjIzjmht3oyMBCl11RvX+T8kG3BzV7IF11PBIMZvoQasPanS4SJw+3z8JLty4vxjk2neaLOS2cpgEV3oJuQou9OhP820FgiUgpXZBSBCeBUE/RCf+staVlzGC/j2zNH9yZWN1YX1t8QQAc0VravwJz+M69ZrF2E21zNEN6IhoCdCUwfL+myueO7IkpQynk/uxp5Y1nUSrig7F1jMaU+pDLuvKRhkryjfzHaa0TyjVON9UNCpcBWPXuQXVBRsv/zx7epuJSECsbywC7KuiK2f1MktdlmxNxqoLAPezzs646t3wheFfEQ0A/343n+RxYgWvvquPzha9BKGGPZCgeCGhSLg43uOvqLQkjS5OzsmN6HbA6jtXBltuwKPOrc2ufvhR1DElFMQOSv8mPZWYEZ4QCSzjqHffw+SVP5vvcKYDnP0V9XKDjwBptfmCdJk0WfbQ2bbRptNPIE9bV4+1Nd/ZvtZyFTBVP+4zVFaThf0K7IVaOLfXOsSM9l27eq7vRk9LnddAujuwV7393kxJ4YP17sOcQQUjmTx10TyQVmvRaoVkjG61DQtOXDZ42bk+XNfxYPuy4DooU/2lCZOGSLk+vvpD9kXqnuTyybWRQ316iVZHD5v268sMPT7SPqLAtxXrqukHMN6K+sr8ymroGaTX+ZlzosRkY9t6qq5PZEQuF68OAkpGBSfOWj7oODdeK7h36XLrzuUsqUoIe/jlzidzRZk9+PXHeSNyGi1N1A+fPv6z1+092h/2o1441AK6VypzuKXHupduu8yj8AU5f7hf3i7gJCX9/IWVG5dAzDxpfs0csWUNe4nweA2zPges3tP/aMGpYv0JoRHf5z8N9w6JRzBWLRzDEUH2DqFn3Dh9617W3aL/i87jnwDSaies9x0HMW6IrmY7sCH5uKvp+CL95AY35UhWZ/3SLbd5UotWu6xNwAQlSZy8KOsYIWJkLZ86c/MS0IHjncs3V/6vzD5w8RDn4sbG1UvAh2umoGS91/6ytlBiSl4O9vWNsp3Ddemrwtv9fUO3r14dvtbvBRZUH+YclXfdR0ZuzANp5zaNdogX5VgA+/YHc0WFj9ZKIfeHmhfFNo0e88+O1nY/Pn+h+xYIKhvkz0pcNHnesTnS0P7w8oW2W+y2W28t5eQ/2ew8zRqHaLU3AWnn+R12j3zGKIC9oBML1Ue23SPaGCFjLNI8qU31PMQzZZIDXFpsu1+OXbtbihuejxirLowgoXMoHW7dHsWh7ol+Vfd7Vk8LiYjGUe/KtEwfT0Ssv8i72p4bgUwFOiVGNIW82toENWdMSGlPeC8e/zb5H2Q9soBxmAnUy0kbFTllxeNdp68jFkhtB5tl7PxPhuWePf/79atgQEuStPamEreuwoBYlYmw228rV7XUSMD2dOJBP/gOxGJdP3qTdVnlFmmZ1ZYyIhMOeajXqENZT9r8Lan1gL+qnxIBIQPx9fqzi3hKVY0EjtsVaG5r9Wn0XSrQbLLbhi3YLFwCYBdp7UMa6ZIyHVLudZH6iL2u2/YMt/B7X70vUblJ2yc8l24S49oCMo1yjZ/jLeu/VBmHuIaCW0O5Eo4HHyr+IGBR3p6eKBwOgyV4eGDxALG3l+ZaL3m25vIlvTW1P/9pQE7VDXdIZTs6tjc6Mo/1Xb2107/WR6k0fAtgWxdWpkK8mkbJZdn5eVU6g9WDO1GoapKV6rB05wWbL7ub1Zu2C0+2weKNbHxyZW1sVCU31oebz/Kp5sZE8arx7CwuPqasisGo5sbjCsqjfSq50YzyKnxyTQ6ns5PD6e5Iy+ju4rC7ugH+feqF33v+/6+dxpx4TpA5iDPPecyZ95fg/xXQE6gJ5AVvBQoCAOFbRIRV+hoRzYI4oYVX6zepAu0kC+fqKNMqbVJmijvSNTOk23kBI+hMme+MFAS0NL7vvnGjCtMdbvq7FbmshohHJvr3ITYJje1d5Q5OpDxvIZLrywmqS1lwQ+0PigGq6plOJeZmR52cWszM08scnUpMR7YR03Tgcks/t3Kiqy/rWBUj14a3HH0AvXbj8/3rD3+tcPORHkWJTs7XcefP0WgXLp6nnbtAu7i1RqFdvXaVdmWdkrI1NWkBm2qWxeTUMenfeQcGmbqaYbSY+ui0WBarL3FYKkPCGkn2wMUlOvY55XtUykpJLVg//nsMe+uEbbQEWyLaFQSZR/SUEfVoevQyUkR3mxa1p+Tj098SErUbYPja6i08+1Zw++/4oEMBaGIQ6nDcdEVIWB5R52P93OXo0pje0n1j3VzMfgTg5btvvqlqcZ5XIVos5y0ulHNPnSioCMhICwhKTfcPTE0LCkznAAtVg87WzlH+qPk2GeMbzl9o2WgBGUQM+/3LkgKfNG80Ce3pGWuLx9PK03rL27gcG01/h8DgyC/Pm4FZ1uuODtfjliOliw0TnZluRxq8y7Z7G55mp2ez6GS0hx8ak1BAJtKIzk3WQdW9eUDT8Ssja86MfFf9zNLak1wQXS75c7xz+QZintSq3SqbMvqwlRIJkSFOoLiJsJAPWjIHSI9ef+nnOlwPvXPxz78l7/77Bg5ab6BRRIQnhoRCYUlIDzQRHNeJFSR3oklpbgRfP1MHyrJGxGyuY8pxE6DOFAlSWp2w+zLe7xyh+sQCK8fUoamljpbJU8Mjx+a72icW/h+KReTEx1Fy8vMpmXFxlEyAUFGkdpeQ9Oh6tBIitadDizKxDik9gDLklE1sjw0pZ3unhkaVpOT2T0R4Nm9FX1i/vzxONEsLYubGx1MQ7EMGZ2xqSj09fTBEAtrRGTmB8224t0eMmcFO+pkr6tszWEgieMQSYnKzWPHF2aDc/KraTD32nDMKYQ+XFeDs3Ovq8A9oVwZ/boH7myuWTNFDIfq81oCWLNrX4OzSRO4JdIlY1Ueyq3idA538+bDCvDWKprqu6rOfqQOpL5eCr2gZ37QyomuLAhM7Tm5xrlgr53J/JL2yMITVsnpxPRHCareQEKaTj73/ZonYbyoR1WJ+sycF33d+O8Y3xWdWn3RHkX/iTv23dXD/jc9y/IerDX3NC5VbIoC5tVfXyPFHogiG5l7oLN/qyNjeuMHNyVOnU3HCX0etcTfn8IEsjk82KaEowgubgHckOqMiHfzLw0r3P5yan1p4/vvTG6/7Ac3O/5vSorR3QVp2Vt2xEJdKH7OLTqyy4WAY1Sl0nJq29UbhIWdlX4nToS4oDXY0wrRDP96o6FVQ4VZS9fDixHIHlRUWXi8UCmI7peekhYkeXFhu1YBs5z+dRYPAh+ugJWP186m64rOX4tKPntJyeO4763OynX6cF9wwt2h7QkEPgUl6X01OvZglqBupXdBomhkRjPZPnRw5duLoeM9Wk83YkYYJysgOiCzh9oBWu/w7sogBGXlkallZt8O1n6N2jPV0gkOKF7e/0yZ2PQNnk9I3dBscwIowh0f9knY+wuQvkZ1HuUfXZ4hnfmkeQMD8RR8pMlJ5sO2E2JZZ8x1mMnatcfvS8e0HOFAgx1SN8qbXJLIOVaKTKAc0hH7nTQZMZP0Q8zVff1lDDX7Z7WWHGVJDoYBSpmZY+swz7Vp69TN5h32y+2AfuZfSkWyPlDOZJdufIS9S7+4rwh3u0mNZHaWademRMR7XWnaGBlqvbd9uuy4cbLqBvbZT2HhUrvNAR9kAUMbtFVXElxaccoi7dEmjlOJYzuWWRrgUAvsf88yi7HhWblYcgRGzaVqUMwoBt6csmtpRPgC48X3LIGN/GMHYEK51P0EuP7Mu2jrUmAzDG0PtZN+z5HIyG4F4yNqCOiVaziWvAv2v8U/Q/PGV7VKpcSVG3OgrOPPx9sipKlB/Gv/tsTSN1VospIkSC/S9L8jkcthZ3IKCHF6Kbau81t4QmCsc2njzHyKXHVEX911gN2LpSqr8XiGu4am9WTFvOH12ZayzEz3Qgpr4YChrDYYr2g7CxMhtFUKzfWY6b7cH6b6tgyEg48WR2KtsA/b1kJhNGESqZKrw+toZ2FnY8nWeUKoacgUGLIcUize7NpuT+Zh2h+IDZ5KlYtMpdUOfgdcrNfeNibRtjbsPjXvO/W1rb4lC2cUHEYoPVS13jQQsufhYBB3vDzjsddfWyY6EdwrBunNIHloqXj54HwyB4InCE7AEHB7ohgxg3coQhPYSfKPxRnaNMCDDp3sYDmCDWNcy5JKGhIx1rKu+s3PbNM+myD6/qua+Dk+Lp16YtXxPEg5e9+VLOGo+VpLCmzoqP9LW+qTsaGriuP+zlvbj/Y5A5+WOvVLxO/JFRdxRapkgM83cnZWrLHEJzT4Jut4JDeiE/6vWI50VKk2w0c2YaH1cdAM2vFilHdpFz8NZFyjz+/K8c/279va6/L1zV3PDDWuJjHS4PzEV7sswrg2PMKgh0Dl2ZBLHzo9uUtPflued49/1WeFIOWfyIgyqHWn2AUS2vU1pUh0RYViDp3HgZF+WkGgyFqXnOHjoXwPwrL/g8rtAl03diSbD/YT/2b/7sUZxKcmfiRJG8tUaLYqND8b8Etl7BGlDNddb0cdN7M9AgB98EUgXBMX85Wq99QNWXc8+uJqv/d37OGOW2cdcZHzxztHWWa1kw6qJf0nCwRsCT8ArF5Sbj0auQBznABI/vtoxzbcptC+oqv2gw9PiqhdlgVi5sb2xxo+glY18Trhg3KDjnwmDxX8mZ4BOD4r78Li9RtracWZpzgwzY81V47g37+zVOWZJ7mxc5qqbxofjAt3H6LYkEpmcTMTx9Z50CPQeW9ITiSQR0fz5f9Dg3FyLJYgWjxI/JCbWdewemp/HKCiBCcBecy+tiBSYXRFcalnm52FA+RSm78To9MN5MHMyIz0TrbO10FHdTslx7s2RYY5d1LaydlKgJgxyHCDUoojWucERma4+ctJz6ovzLVGofl7mBa/a1FWDUKuJcOuLcBq1wiycaJ6MxTlGRXvW61IqOiqCis1CiZZMpKNRENo1Utc1WYghOkUW0alOqeZFGj4pQqfUKJdygP1C2CHMEYb6LTJ3f7u2UxHnKl4gkSXJFJOJRZX1zXYzgKHqkdgJ55JkfH9iBnahongTU+YQI3NYJUhXYkr6kFG0Row8LKDQOIxsnR3UNCsY037xuhpLcXWePTGqZir8kaAA0tIS1a46rkQONeRt4SpUr78YleyxjJCzPFwNiyVjki24qnzxAHmHRl8r+kEPRpd7crr7cFIGciGzZAgbHzdDLu0nfrnng4gxxweblkT4QNlocowFBsu2IZNgDDuscTkhMRUDDho5KX8dnWoxXDABRmHboW2WaRFo3iGsWbJ3OANXeJTtG053zCZSMW15rDGXePaEU1YcooXqa5Xry2ARexTDCJ4U4xRMBIabHtFmKZ912En/ENaTZUjwSTLEo4wiXR1NQwh4ptenh8Uepd37Y0OTihKZboZBj8PtzX6EOniijUKcmcWJJkUAhfVJVLvm+HvkcENu0AW3FiR7rd5u1TSNOQDbkcxRcCj2tWYEnO8pyigZDjCnfV+lZviQY+FSHzIpFQ1m8rqkxcxHD9HHnmYmDg/lUIIFFQVyNZQ/iDtR0D63tbF4jvPpwKPkR2ijm78B6ViN9t52N9It6BXkxGLARD5GP04eeI3Fv/61UP07DVT0mbgpRpoGoP0O/oHFwHBq/k52uv7VoXquIe0O3gaezYEWp92jaW32LIZLbQRWK8GJEhBCR6AxdAW0lcqyTYlOMjG4Aez7u6HpDZB++EY2bKVM45VeHTNY/GuMFeypyUmmbrwG0g9eNzWCfX81Qn6SK8k68TDWOdkbr/2tdzDwEfURcHyKC64PBn8Z2/Y8xcoP8H1BKZSKc0wm32GWhRR0FpSFMO/6jciYnM2yL2gdwMo/7bHdZaXmJarKJaqm5iQoPSeaTqX78xgf7PuLv+8VeShA3MLGcwkRLelVlJQ9j7VrW/cUJ9/cSgJlNlL63XXQ9/6bporsLCy9Be6Qj1wGJQF+M27e62yVvfUl4ZKUQLCfHMC8XH5A58RAYbUwNrlNVy0Fo/nc7/Yh65A8YUxye4bCMyDowBh17M2zPz98s1fBGL31OZCLfbKzY5pvXehQUFXzQYd3kKtemIU/KAnvSldlxFNrhzDeMR9d7RBu+ZZxb8a9GsbGM8cxhsK5/avqYgvSMyEBgUQjWfEolKcXk4lGINzj41VjRwCTIOgVoCBGeh/r63Iavf/qbWSg91/fKs2GT1ui6YrZUKmFRcwB8UEQ2Mx4rQFsKvw/YHRvFtNF7NLJz/d9r2mj4+dssyDOdEibTYnngKxRLtcluCEVdVJlJj2S78Hc/PIFqyoJTEVbPApBKjBSzXcPpuhXkbrZklSyLdXZnz0466aGO3+3X/P6Ti6kUhSlal56dLQHu+nXkzoYqdiRqtIerNM0FPtdsMmogXsI1AfKDhL65YHH9yX458BhaphF3K34YQs0tHgNB8pBEvpPgOeaPdFWBVkARgMKWk6iB8/eMuzd+Rb7HardJ7WEHHOgzpc4/hHgNXxuEu7tA+VyCV0e4A18SAlZJfBbbAAUfus/+S/op55SLZb78d+/Jh7/+jxw6tv56/gPKTsVU7Phgf5DF7Gx+HMEjRu26ReA+81Za8xEZ4fxWSieLY+r/ZJzQPs74g05GkMA9RRhwYLuyssveomusesEnUvTDxgdFGf0DXizSqKFU1jfGzIKAHEnot+NtjsYYP/+1NxF8xrps+WNH3QQlIZ21JsS+m4iUC6S/GNA3as0C+BTcaVtCcFMNPbrTzVaAi4AhyArEwLjvFlGgfhseahRyF7TijZaCF2EvLqSf7CtFf+4WT5QH8TqiKvy9bD4ixhQ5u6yvKxfhbEU8QeEJwAfb/mNgsTI9/b/35NtncTAnJOQugL+siiZ+3pA+GsZmu7T0N9j2xpisRyoXI5tbxXBV9rvSy3bKipf8AiX23WBvpNzXdG27zoXmRsz8/BN9ClNFQmuttmK7zMELxkxkjeojfBSHLsl+qsx4iSsLz+1ftep2AbGix2MOZC4E4hH+cdw4UUxenww03algyjiResa/dr51UxVNgA7e+EDAmEshDUjNHxGKjT/hLYjoT5nMJ8/YSgDwz40woNJqBFv7wisZvjBt0yMwfnxupFQ3oZ2nzhc4MOYuHpfRBXBPD4OaEdbqsKWtQ1O3ch3yn/MdKT0aoJflOnOav2auD4WOATDE9sMg7Z8DnF6wR7n5y9iGq9KFDqCa0T5rQf1XUjyvAJcAMAc7C7vCU8Whrc08jZ4aKzKuQc+xgrwKmY1bi8CuACAuUBJ5zW+VMVjC06sFMl4oaRiwuLlDAcrgN1aKO0mTrMHWWyshYJpBxbZ2XxmzHawZVS3qQUA5RlgAg7T2wFwMYG0Asgypfm5wWjbXyxD0r+78Rn6Zdde7+st9dtZ8+I+QSSI72/XU+Lm19g4wn0Wo/gEjsLBWAPzcDo+7EvqVyPN8kgbFU2Ntda7HlrJlrERj2ik/LS7V4cFFWoTb/P4nrEAcMiE0VpqzK/1f20csdGBg6+4gdqGHueF8HsJFqqcHCNJAxUoHzVfEgI2CRdIwJhTfwJQH4bS6IcZcZvDSF9JSys7zKdIdJhf0pX5jVt6BIsjTb4MiVgSZIGyZwduLCh8gHFmYgrmUYnYYtkwtItTioOVembDYsqklSGnsLiw5Y8zx5xYiGjsArIYS7YUz8pAVp1N9fnS+rDUqcWSmBnLY9b0MMLhLMPqiRa1UPB/3YodxaEduMuWJY07W7Zyz8xmztLIYmthJhscGVhWikRfZ2phlERbfoiwvDMLMbXW7DuVSziF8wwXLwAAAAA=) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Segoe UI";
+  src: local("Segoe UI"), url(data:application/x-font-woff;charset=utf-8;base64,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) format("woff");
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+body {
+  background: #f8f9fa;
+  text-align: left;
+  -webkit-print-color-adjust: exact;
+}
+html[lang^=ar] body {
+  font-family: "Segoe UI";
+}
+html[lang^=en] body {
+  font-family: "Noto Sans";
+}
+@media print {
+  body {
+    background: #fff;
+  }
+}
+
+.receipt {
+  text-align: left;
+  padding: 45px;
+}
+.receipt__header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  margin: 0 0 30px;
+}
+.receipt__header .organization .title {
+  margin: 0 0 4px;
+}
+.receipt__header .organization .receiptNumber {
+  margin: 0 0 12px;
+}
+.receipt__header .paper .title {
+  font-weight: 400;
+  text-transform: uppercase;
+  margin: 0 0 2px;
+  font-size: 32px;
+  line-height: 1;
+}
+.receipt__receipt-amount {
+  margin-bottom: 18px;
+}
+.receipt__receipt-amount .label {
+  font-size: 12px;
+}
+.receipt__receipt-amount .amount {
+  font-size: 18px;
+  font-weight: 800;
+}
+.receipt__meta {
+  display: flex;
+  flex-direction: column;
+  margin-bottom: 20px;
+  font-size: 13px;
+}
+.receipt__meta-item {
+  padding-right: 10px;
+  margin-bottom: 10px;
+  display: flex;
+  flex-direction: row;
+}
+.receipt__meta-item .value {
+  color: #000;
+}
+.receipt__meta-item .label {
+  color: #444;
+  margin-bottom: 2px;
+  width: 180px;
+}
+.receipt__table {
+  display: flex;
+  flex-direction: column;
+}
+.receipt__table table {
+  font-size: 12px;
+  color: #000;
+  text-align: left;
+  border-spacing: 0;
+}
+.receipt__table table thead th,
+.receipt__table table tbody tr td {
+  margin-bottom: 15px;
+  background: transparent;
+}
+.receipt__table table thead th {
+  font-weight: 400;
+  border-bottom: none;
+  padding: 8px;
+  color: #fff;
+  background-color: #333;
+}
+.receipt__table table tbody tr td {
+  padding: 10px;
+  border-bottom: 1px solid #cecbcb;
+}
+.receipt__table table thead tr th.item,
+.receipt__table table tbody tr td.item {
+  width: 45%;
+}
+.receipt__table table thead tr th.rate,
+.receipt__table table tbody tr td.rate {
+  width: 18%;
+  text-align: right;
+}
+.receipt__table table thead tr th.quantity,
+.receipt__table table tbody tr td.quantity {
+  width: 16%;
+  text-align: right;
+}
+.receipt__table table thead tr th.total,
+.receipt__table table tbody tr td.total {
+  width: 21%;
+  text-align: right;
+}
+.receipt__table-after {
+  display: flex;
+}
+.receipt__table-total {
+  margin-bottom: 20px;
+  width: 50%;
+  float: right;
+  margin-left: auto;
+}
+.receipt__table-total table {
+  border-spacing: 0;
+  width: 100%;
+  font-size: 12px;
+}
+.receipt__table-total table tbody tr td {
+  padding: 8px 10px 8px 0;
+  border-top: 1px solid #d5d5d5;
+}
+.receipt__table-total table tbody tr td:last-child {
+  width: 140px;
+  text-align: right;
+}
+.receipt__table-total table tbody tr:first-child td {
+  border-top: 0;
+}
+.receipt__table-total table tbody tr.payment-amount td:last-child {
+  color: red;
+}
+.receipt__table-total table tbody tr.blanace-due td {
+  border-top: 3px double #666;
+  font-weight: bold;
+}
+.receipt__footer {
+  font-size: 12px;
+}
+.receipt__conditions h3, .receipt__notes h3 {
+  color: #666;
+  font-size: 12px;
+  margin-top: 0;
+  margin-bottom: 10px;
+}
+.receipt__conditions p, .receipt__notes p {
+  margin: 0 0 20px;
+}
\ No newline at end of file
diff --git a/packages/server/resources/locales/ar.json b/packages/server/resources/locales/ar.json
new file mode 100644
index 000000000..f7bed4726
--- /dev/null
+++ b/packages/server/resources/locales/ar.json
@@ -0,0 +1,640 @@
+{
+  "Petty Cash": "العهدة",
+  "Cash": "النقدية",
+  "Bank": "المصرف",
+  "Other Income": "إيرادات اخري",
+  "Interest Income": "إيرادات الفوائد",
+  "Depreciation Expense": "مصاريف الاهلاك",
+  "Interest Expense": "مصروفات الفوائد",
+  "Sales of Product Income": "مبيعات دخل المنتجات",
+  "Inventory Asset": "المخزون",
+  "Cost of Goods Sold (COGS)": "تكلفة البضائع المباعة (COGS)",
+  "Cost of Goods Sold": "تكلفة البضاعة المباعة",
+  "Accounts Payable": "الذمم الدائنة",
+  "Other Expense": "مصاريف أخرى",
+  "Payroll Expenses": "مصاريف المرتبات",
+  "Fixed Asset": "أصول ثابتة",
+  "Credit Card": "بطاقة إئتمان",
+  "Non-Current Asset": "أصول غير متداولة",
+  "Current Asset": "أصول متداولة",
+  "Other Asset": "أصول اخري",
+  "Long Term Liability": "التزامات طويلة الاجل",
+  "Current Liability": "التزامات قصيرة الاجل",
+  "Other Liability": "التزمات اخري",
+  "Equity": "حقوق الملكية",
+  "Expense": "مصروف",
+  "Income": "إيراد",
+  "Accounts Receivable (A/R)": "الذمم المدينة",
+  "Accounts Receivable": "الذمم المدينة",
+  "Accounts Payable (A/P)": "الذمم الدائنة",
+  "Inactive": "غير نشط",
+  "Other Current Asset": "أصول متداولة اخرى",
+  "Tax Payable": "الضريبة المستحقة",
+  "Other Current Liability": "التزامات قصيرة الأجر اخرى",
+  "Non-Current Liability": "التزامات طويلة الأجر",
+  "Assets": "أصول",
+  "Liabilities": "الالتزمات",
+  "Account name": "أسم الحساب",
+  "Account type": "نوع الحساب",
+  "Account normal": "حساب عادي",
+  "Description": "وصف",
+  "Account code": "رمز الحساب",
+  "Currency": "عملة",
+  "Balance": "توازن",
+  "Active": "نشيط",
+  "Created at": "أنشئت في",
+  "fixed_asset": "أصل ثابت",
+  "Journal": "قيد",
+  "Reconciliation": "تسوية",
+  "Credit": "دائن",
+  "Debit": "مدين",
+  "Interest": "فائدة",
+  "Depreciation": "اهلاك",
+  "Payroll": "كشف رواتب",
+  "Type": "نوع",
+  "Name": "الأسم",
+  "Sellable": "قابل للبيع",
+  "Purchasable": "قابل للشراء",
+  "Sell price": "سعر البيع",
+  "Cost price": "سعر الكلفة",
+  "User": "المستخدم",
+  "Category": "تصنيف",
+  "Note": "ملحوظة",
+  "Quantity on hand": "كمية في اليد",
+  "Purchase description": "وصف الشراء",
+  "Sell description": "وصف البيع",
+  "Sell account": "حساب البيع",
+  "Cost account": "حساب التكلفة",
+  "Inventory account": "حساب المخزون",
+  "Payment date": "تاريخ الدفع",
+  "Payment account": "حساب الدفع",
+  "Amount": "كمية",
+  "Reference No.": "رقم المرجع.",
+  "Published": "نشرت",
+  "Journal number": "رقم القيد",
+  "Status": "حالة",
+  "Journal type": "نوع القيد",
+  "Date": "تاريخ",
+  "Asset": "أصل",
+  "Liability": "التزام",
+  "First-in first-out (FIFO)": "الوارد أولاً يصرف أولاً (FIFO)",
+  "Last-in first-out (LIFO)": "الوارد أخيرًا يصرف أولاً (LIFO)",
+  "Average rate": "المعدل المتوسط",
+  "Total": "الإجمالي",
+  "Transaction type": "نوع المعاملة",
+  "Transaction #": "عملية #",
+  "Running Value": "القيمة الجارية",
+  "Running quantity": "الكمية الجارية",
+  "Profit Margin": "هامش الربح",
+  "Value": "القيمة",
+  "Rate": "السعر",
+  "OPERATING ACTIVITIES": "الأنشطة التشغيلية",
+  "FINANCIAL ACTIVITIES": "الأنشطة التمويلية",
+  "INVESTMENT ACTIVITIES": "الانشطة الاستثمارية",
+  "Net income": "صافي الدخل",
+  "Adjustments net income by operating activities.": "تسويات صافي الدخل من الأنشطة التشغيلية.",
+  "Net cash provided by operating activities": "صافي التدفقات النقدية من أنشطة التشغيل",
+  "Net cash provided by investing activities": "صافي التدفقات النقدية من أنشطة الاستثمار",
+  "Net cash provided by financing activities": "صافي التدفقات النقدية من أنشطة التمويلية",
+  "Cash at beginning of period": "التدفقات النقدية في بداية الفترة",
+  "NET CASH INCREASE FOR PERIOD": "زيادة التدفقات النقدية للفترة",
+  "CASH AT END OF PERIOD": "صافي التدفقات النقدية في نهاية الفترة",
+  "Expenses": "مصاريف",
+  "Services": "خدمات",
+  "Inventory": "المخزون",
+  "Non Inventory": "غير المخزون",
+  "Draft": "مسودة",
+  "Delivered": "تم التوصيل",
+  "Overdue": "متأخر",
+  "Partially paid": "المدفوعة جزئيا",
+  "Paid": "مدفوع",
+  "Opened": "افتتح",
+  "Unpaid": "غير مدفوعة",
+  "Approved": "وافق",
+  "Rejected": "مرفوض",
+  "Invoiced": "مفوترة",
+  "Expired": "منتهي الصلاحية",
+  "Closed": "مغلق",
+  "Manual journal": "قيد اليدوي",
+  "Owner contribution": "زيادة رأس المال",
+  "Transfer to account": "تحويل إلى الحساب",
+  "Transfer from account": "تحويل من الحساب",
+  "Other income": "إيراد اخر",
+  "Other expense": "مصاريف أخرى",
+  "Owner drawing": "سحب رأس المال",
+  "Inventory adjustment": "تسوية المخزون",
+  "Customer opening balance": "الرصيد الافتتاحي للزبون",
+  "Vendor opening balance": "رصيد افتتاحي للمورد",
+  "Payment made": "سند الزبون",
+  "Bill": "فاتورة الشراء",
+  "Payment receive": "استلام الدفع",
+  "Sale receipt": "إيصال البيع",
+  "Sale invoice": "فاتورة البيع",
+  "Quantity": "الكمية",
+  "Bank Account": "حساب البنك",
+  "Saving Bank Account": "حساب التوفير البنكي",
+  "Undeposited Funds": "الأموال غير المودعة",
+  "Computer Equipment": "معدات كمبيوتر",
+  "Office Equipment": "معدات مكتبية",
+  "Uncategorized Income": "الدخل غير مصنف",
+  "Sales of Service Income": "دخل مبيعات الخدمات",
+  "Bank Fees and Charges": "رسوم المصرفية",
+  "Exchange Gain or Loss": "ربح أو خسارة فروقات الصرف",
+  "Rent": "إيجار",
+  "Office expenses": "مصاريف المكتب",
+  "Other Expenses": "مصاريف اخري",
+  "Drawings": "السحوبات",
+  "Owner's Equity": "حقوق الملكية",
+  "Opening Balance Equity": "الارصدة الافتتاحية ",
+  "Retained Earnings": "الأرباح المحتجزة",
+  "Sales Tax Payable": "ضريبة المبيعات المستحقة",
+  "Revenue Received in Advance": "الإيرادات المقبوضة مقدما",
+  "Opening Balance Liabilities": "رصيد الالتزامات الافتتاحي",
+  "Loan": "اقراض",
+  "Owner A Drawings": "مسحوبات المالك",
+  "An account that holds valuation of products or goods that availiable for sale.": "حساب يحمل قيم مخزون البضاعة أو السلع المتاحة للبيع.",
+  "Tracks the gain and losses of the exchange differences.": "يسجل مكاسب وخسائر فروق الصرف.",
+  "Any bank fees levied is recorded into the bank fees and charges account. A bank account maintenance fee, transaction charges, a late payment fee are some examples.": "يتم تسجيل أي رسوم مصرفية يتم فرضها في حساب الرسوم والمصروفات البنكية. ومن الأمثلة على ذلك رسوم صيانة الحساب المصرفي ورسوم المعاملات ورسوم الدفع المتأخر.",
+  "The income activities are not associated to the core business.": "لا ترتبط انشطة الدخل إلى الأعمال الأساسية.",
+  "Cash and cash equivalents": "النقد والنقد المكافئ",
+  "Inventories": "مخزون البضاعة",
+  "Other current assets": "الأصول متداولة الأخرى",
+  "Non-Current Assets": "أصول غير المتداولة",
+  "Current Liabilties": "التزامات متداولة",
+  "Long-Term Liabilities": "التزامات طويلة الاجل",
+  "Non-Current Liabilities": "التزامات غير متداولة",
+  "Liabilities and Equity": "التزامات وحقوق الملكية",
+  "Closing balance": "الرصيد الختامي",
+  "Opening balance": "الرصيد الفتاحي",
+  "Total {{accountName}}": "إجمالي {{accountName}}",
+
+  "invoice.paper.invoice": "فاتورة",
+  "invoice.paper.due_amount": "القيمة المستحقة",
+  "invoice.paper.billed_to": "فاتورة إلي",
+  "invoice.paper.invoice_date": "تاريخ الفاتورة",
+  "invoice.paper.invoice_number": "رقم الفاتورة",
+  "invoice.paper.due_date": "تاريخ الاستحقاق",
+  "invoice.paper.conditions_title": "الشروط والأحكام",
+  "invoice.paper.notes_title": "ملاحظات",
+  "invoice.paper.total": "المجموع",
+  "invoice.paper.balance_due": "مبلغ المستحق",
+  "invoice.paper.payment_amount": "مبلغ المدفوع",
+  "invoice.paper.invoice_amount": "قيمة الفاتورة",
+
+  "item_entry.paper.item_name": "اسم الصنف",
+  "item_entry.paper.rate": "السعر",
+  "item_entry.paper.quantity": "الكمية",
+  "item_entry.paper.total": "إجمالي",
+
+  "estimate.paper.estimate": "عرض أسعار",
+  "estimate.paper.billed_to": "عرض أسعار إلي",
+  "estimate.paper.estimate_date": "تاريخ العرض",
+  "estimate.paper.estimate_number": "رقم العرض",
+  "estimate.paper.expiration_date": "تاريخ انتهاء الصلاحية",
+  "estimate.paper.conditions_title": "الشروط والأحكام",
+  "estimate.paper.notes_title": "ملاحظات",
+  "estimate.paper.amount": "قيمة العرض",
+  "estimate.paper.subtotal": "المجموع",
+  "estimate.paper.total": "إجمالي",
+  "estimate.paper.estimate_amount": "قيمة العرض",
+
+  "receipt.paper.receipt": "إيصال",
+  "receipt.paper.billed_to": "الإيصال إلي",
+  "receipt.paper.receipt_date": "تاريخ الإيصال",
+  "receipt.paper.receipt_number": "رقم الإيصال",
+  "receipt.paper.conditions_title": "الشروط والأحكام",
+  "receipt.paper.notes_title": "ملاحظات",
+  "receipt.paper.receipt_amount": "قيمة الإيصال",
+  "receipt.paper.total": "إجمالي",
+  "receipt.paper.payment_amount": "مبلغ المدفوع",
+  "receipt.paper.balance_due": "مبلغ المستحق",
+  "receipt.paper.statement": "البيان",
+  "receipt.paper.notes": "ملاحظات",
+
+  "payment.paper.payment_receipt": "إيصال قبض",
+  "payment.paper.amount_received": "القيمة المستلمه",
+  "payment.paper.billed_to": "إيصال إلي",
+  "payment.paper.payment_date": "تاريخ الدفع",
+  "payment.paper.invoice_number": "رقم الفاتورة",
+  "payment.paper.invoice_date": "تاريخ الفاتورة",
+  "payment.paper.invoice_amount": "قيمة الفاتورة",
+  "payment.paper.payment_amount": "قيمة الدفع",
+  "payment.paper.balance_due": "المبلغ المستحق",
+  "payment.paper.statement": "البيان",
+
+  "credit.paper.credit_note": "اشعار دائن",
+  "credit.paper.amount": "قيمة الاشعار",
+  "credit.paper.remaining": "رصيد المتبقي",
+  "credit.paper.billed_to": "إيصال إلي",
+  "credit.paper.credit_date": "تاريخ الاشعار",
+  "credit.paper.terms_conditions": "الشروط والاحكام",
+  "credit.paper.notes": "ملاحظات",
+  "credit.paper.total": "إجمالي",
+  "credit.paper.credits_used": "قيمة المستخدمه",
+  "credit.paper.credits_remaining": "قيمة المتبقية",
+
+  "account.field.name": "إسم الحساب",
+  "account.field.description": "الوصف",
+  "account.field.slug": "Account slug",
+  "account.field.code": "رقم الحساب",
+  "account.field.root_type": "جذر الحساب",
+  "account.field.normal": "طبيعة الحساب",
+  "account.field.normal.credit": "دائن",
+  "account.field.normal.debit": "مدين",
+  "account.field.type": "نوع الحساب",
+  "account.field.active": "Activity",
+  "account.field.balance": "الرصيد",
+  "account.field.created_at": "أنشئت في",
+  "item.field.type": "نوع الصنف",
+  "item.field.type.inventory": "مخزون",
+  "item.field.type.service": "خدمة",
+  "item.field.type.non-inventory": "غير مخزون",
+  "item.field.name": "اسم الصنف",
+  "item.field.code": "رمز الصنف",
+  "item.field.sellable": "قابل للبيع",
+  "item.field.purchasable": "قابل للشراء",
+  "item.field.cost_price": "سعر التكلفة",
+  "item.field.cost_account": "حساب التكلفة",
+  "item.field.sell_account": "حساب البيع",
+  "item.field.sell_description": "وصف البيع",
+  "item.field.inventory_account": "حساب المخزون",
+  "item.field.purchase_description": "وصف الشراء",
+  "item.field.quantity_on_hand": "الكمية",
+  "item.field.note": "ملاحظة",
+  "item.field.category": "التصنيف",
+  "item.field.active": "Active",
+  "item.field.created_at": "أنشئت في",
+  "item_category.field.name": "الاسم",
+  "item_category.field.description": "الوصف",
+  "item_category.field.count": "العدد",
+  "item_category.field.created_at": "أنشئت في",
+  "invoice.field.customer": "الزبون",
+  "invoice.field.invoice_date": "تاريخ الفاتورة",
+  "invoice.field.due_date": "تاريخ الاستحقاق",
+  "invoice.field.invoice_no": "رقم الفاتورة",
+  "invoice.field.reference_no": "رقم الإشاري",
+  "invoice.field.invoice_message": "رسالة الفاتورة",
+  "invoice.field.terms_conditions": "الشروط والأحكام",
+  "invoice.field.amount": "القيمة",
+  "invoice.field.payment_amount": "القيمة المدفوعة",
+  "invoice.field.due_amount": "القيمة المستحقة",
+  "invoice.field.status": "الحالة",
+  "invoice.field.status.paid": "مدفوعة",
+  "invoice.field.status.partially-paid": "المدفوعة جزئيا",
+  "invoice.field.status.overdue": "متأخرة",
+  "invoice.field.status.unpaid": "غير مدفوعة",
+  "invoice.field.status.delivered": "تم تسليمها",
+  "invoice.field.status.draft": "مسودة",
+  "invoice.field.created_at": "أنشئت في",
+  "estimate.field.amount": "القيمة",
+  "estimate.field.estimate_number": "رقم العرض",
+  "estimate.field.customer": "الزبون",
+  "estimate.field.estimate_date": "تاريخ العرض",
+  "estimate.field.expiration_date": "تاريخ انتهاء الصلاحية",
+  "estimate.field.reference_no": "رقم الإشاري",
+  "estimate.field.note": "ملاحظة",
+  "estimate.field.terms_conditions": "الشروط والأحكام",
+  "estimate.field.status": "الحالة",
+  "estimate.field.status.delivered": "تم تسليمها",
+  "estimate.field.status.rejected": "مرفوضة",
+  "estimate.field.status.approved": "تم الموافقة",
+  "estimate.field.status.draft": "مسودة",
+  "estimate.field.created_at": "أنشئت في",
+  "payment_receive.field.customer": "الزبون",
+  "payment_receive.field.payment_date": "تاريخ الدفع",
+  "payment_receive.field.amount": "القيمة",
+  "payment_receive.field.reference_no": "رقم الإشاري",
+  "payment_receive.field.deposit_account": "حساب الإيداع",
+  "payment_receive.field.payment_receive_no": "رقم عملية الدفع",
+  "payment_receive.field.statement": "البيان",
+  "payment_receive.field.created_at": "أنشئت في",
+  "bill_payment.field.vendor": "المورد",
+  "bill_payment.field.amount": "القيمة",
+  "bill_payment.field.due_amount": "قيمة المستحقة",
+  "bill_payment.field.payment_account": "حساب الدفع",
+  "bill_payment.field.payment_number": "قيمة الدفع",
+  "bill_payment.field.payment_date": "تاريخ الدفع",
+  "bill_payment.field.reference_no": "رقم الإشاري",
+  "bill_payment.field.description": "الوصف",
+  "bill_payment.field.created_at": "أنشئت في",
+  "bill.field.vendor": "المورد",
+  "bill.field.bill_number": "رقم الفاتورة",
+  "bill.field.bill_date": "تاريخ الفاتورة",
+  "bill.field.due_date": "تاريخ الاستحقاق",
+  "bill.field.reference_no": "رقم الإشاري",
+  "bill.field.status": "الحالة",
+  "bill.field.status.paid": "مدفوعة",
+  "bill.field.status.partially-paid": "مدفوعة جزئيا",
+  "bill.field.status.unpaid": "غير مدفوعة",
+  "bill.field.status.opened": "مفتوحة",
+  "bill.field.status.draft": "مسودة",
+  "bill.field.status.overdue": "متأخرة",
+  "bill.field.amount": "القيمة",
+  "bill.field.payment_amount": "قيم الدفع",
+  "bill.field.note": "ملاحظة",
+  "bill.field.created_at": "أنشئت في",
+  "inventory_adjustment.field.date": "التاريخ",
+  "inventory_adjustment.field.type": "النوع",
+  "inventory_adjustment.field.type.increment": "زيادة",
+  "inventory_adjustment.field.type.decrement": "نقصان",
+  "inventory_adjustment.field.adjustment_account": "حساب التسوية",
+  "inventory_adjustment.field.reason": "السبب",
+  "inventory_adjustment.field.reference_no": "رقم الإشاري",
+  "inventory_adjustment.field.description": "الوصف",
+  "inventory_adjustment.field.published_at": "نشرت في",
+  "inventory_adjustment.field.created_at": "أنشئت في",
+  "expense.field.payment_date": "تاريخ الدفع",
+  "expense.field.payment_account": "حساب الدفع",
+  "expense.field.amount": "القيمة",
+  "expense.field.reference_no": "رقم الإشاري",
+  "expense.field.description": "الوصف",
+  "expense.field.published": "Published",
+  "expense.field.status": "الحالة",
+  "expense.field.status.draft": "مسودة",
+  "expense.field.status.published": "نشرت",
+  "expense.field.created_at": "أنشئت في",
+  "manual_journal.field.date": "التاريخ",
+  "manual_journal.field.journal_number": "رقم القيد",
+  "manual_journal.field.reference": "رقم الإشاري",
+  "manual_journal.field.journal_type": "نوع القيد",
+  "manual_journal.field.amount": "القيمة",
+  "manual_journal.field.description": "الوصف",
+  "manual_journal.field.status": "الحالة",
+  "manual_journal.field.created_at": "أنشئت في",
+  "receipt.field.amount": "القيمة",
+  "receipt.field.deposit_account": "حساب الإيداع",
+  "receipt.field.customer": "الزبون",
+  "receipt.field.receipt_date": "تاريخ الإيصال",
+  "receipt.field.receipt_number": "رقم الإيصال",
+  "receipt.field.reference_no": "رقم الإشاري",
+  "receipt.field.receipt_message": "رسالة الإيصال",
+  "receipt.field.statement": "البيان",
+  "receipt.field.created_at": "أنشئت في",
+  "receipt.field.status": "الحالة",
+  "receipt.field.status.draft": "مسودة",
+  "receipt.field.status.closed": "مغلقة",
+  "customer.field.first_name": "الاسم الأول",
+  "customer.field.last_name": "الاسم الاخير",
+  "customer.field.display_name": "اسم العرض",
+  "customer.field.email": "بريد الالكتروني",
+  "customer.field.work_phone": "هاتف عمل",
+  "customer.field.personal_phone": "هاتف شخصي",
+  "customer.field.company_name": "اسم الشركة",
+  "customer.field.website": "موقع الكتروني",
+  "customer.field.opening_balance_at": "الرصيد الافتتاحي في",
+  "customer.field.opening_balance": "الرصيد الافتتاحي",
+  "customer.field.created_at": "أنشئت في",
+  "customer.field.balance": "الرصيد",
+  "customer.field.status": "الحالة",
+  "customer.field.currency": "العملة",
+  "customer.field.status.active": "مفعل",
+  "customer.field.status.inactive": "غير مفعل",
+  "customer.field.status.overdue": "متأخر",
+  "customer.field.status.unpaid": "غير دافع",
+  "vendor.field.first_name": "الاسم الأول",
+  "vendor.field.last_name": "الاسم الاخير",
+  "vendor.field.display_name": "اسم العرض",
+  "vendor.field.email": "بريد الالكتروني",
+  "vendor.field.work_phone": "هاتف عمل",
+  "vendor.field.personal_phone": "هاتف شخصي",
+  "vendor.field.company_name": "اسم الشركة",
+  "vendor.field.website": "موقع الكتروني",
+  "vendor.field.opening_balance_at": "الرصيد الافتتاحي في",
+  "vendor.field.opening_balance": "الرصيد الافتتاحي",
+  "vendor.field.created_at": "أنشئت في",
+  "vendor.field.balance": "الرصيد",
+  "vendor.field.status": "الحالة",
+  "vendor.field.currency": "العملة",
+  "vendor.field.status.active": "مفعل",
+  "vendor.field.status.inactive": "غير مفعل",
+  "vendor.field.status.overdue": "متأخر",
+  "vendor.field.status.unpaid": "غير دافع",
+  "Invoice write-off": "شطب فاتورة",
+  "transaction_type.credit_note": "اشعار دائن",
+  "transaction_type.refund_credit_note": "استرجاع اموال اشعار دائن",
+  "transaction_type.vendor_credit": "اشعار مدين",
+  "transaction_type.refund_vendor_credit": "استرجاع اموال اشعار مدين",
+  "transaction_type.landed_cost": "تحميل تكلفة",
+
+  "sms_notification.invoice_details.label": "تفاصيل فاتورة البيع ",
+  "sms_notification.invoice_reminder.label": "تذكير بفاتورة البيع ",
+  "sms_notification.receipt_details.label": "تفاصيل إيصال البيع ",
+  "sms_notification.sale_estimate_details.label": "تفاصيل فاتورة عرض اسعار ",
+  "sms_notification.payment_receive_details.label": "تفاصيل سند الزبون",
+  "sms_notification.customer_balance.label": "رصيد الزبون",
+
+  "sms_notification.invoice_details.description": "سيتم إرسال إشعار عبر الرسائل القصيرة إلى العميل بمجرد إنشاء الفاتورة ونشرها أو عند إشعار العميل عبر رسالة نصية قصيرة بالفاتورة. ",
+  "sms_notification.payment_receive.description": "سيتم إرسال إشعار رسالة شكر للدفع إلى العميل بمجرد إنشاء الدفعة ونشرها أو إشعار العميل بالدفع يدويًا. ",
+  "sms_notification.receipt_details.description": "سيتم إرسال إشعار عبر الرسائل القصيرة إلى العميل بمجرد إنشاء ونشر الإيصال أو عند إشعار العميل بالإيصال يدويًا.",
+  "sms_notification.customer_balance.description": "إرسال رسالة نصية قصيرة إشعار العملاء برصيدهم الحالي المستحق. ",
+  "sms_notification.estimate_details.description": "سيتم إرسال إشعار عبر الرسائل القصيرة إلى عميلك بمجرد نشر العرض أو إشعار العميل بالعرض يدويًا.",
+  "sms_notification.invoice_reminder.description": "سيتم ارسال إشعار SMS لتذكير الزبون بالدفع باكراً ، سواء ارسال بشكل تلقائي او يدوي.",
+
+  "sms_notification.customer_balance.default_message": "عزيزي {CustomerName} ، هذا تذكير بشأن رصيد الحالي المستحق {Balance} ، يُرجى الدفع في أقرب وقت ممكن. - {CompanyName}",
+  "sms_notification.payment_receive.default_message": "مرحبًا {CustomerName} ، تم القبض بقيمة {Amount} للفاتورة - {InvoiceNumber}. نحن نتطلع إلى خدمتك مرة أخرى. شكرا لك. - {CompanyName}",
+  "sms_notification.estimate.default_message": "مرحبًا , {CustomerName} ، تم أنشاء فاتورة عرض اسعار - {EstimateNumber} لك. يرجى إلقاء نظرة وقبوله للمضي قدما. بانتظار ردك. - {CompanyName}",
+
+  "sms_notification.invoice_details.default_message": "مرحبًا {CustomerName},  لديك مبلغ مستحق قدره {DueAmount}  للفاتورة {InvoiceNumber}. - {CompanyName}",
+  "sms_notification.receipt_details.default_message": "مرحبًا {CustomerName} ، لقد تم إنشاء إيصال - {ReceiptNumber} من أجلك. نتطلع إلى خدمتك مرة أخرى. شكرًا لك - {CompanyName}",
+  "sms_notification.invoice_reminder.default_message": "عزيزي {CustomerName} ، يرجي سداد فاتورة - {InvoiceNumber} المستحقة. يرجى الدفع قبل تاريخ {DueDate}. شكرا لك. - {CompanyName}",
+
+  "module.sale_invoices.label": "فواتير البيع",
+  "module.sale_receipts.label": "إيصالات البيع",
+  "module.sale_estimates.label": "فاتورة عرض اسعار ",
+  "module.payment_receives.label": "سندات الزبائن ",
+  "module.customers.label": "العملاء",
+
+  "sms_notification.invoice.var.invoice_number": "يشير  إلى رقم الفاتورة.",
+  "sms_notification.invoice.var.reference_number": "يشير  إلى رقم إشاري للفاتورة.",
+  "sms_notification.invoice.var.customer_name": "يشير  إلى اسم العميل الفاتورة",
+  "sms_notification.invoice.var.due_amount": "يشير  إلى مبلغ الفاتورة المستحق",
+  "sms_notification.invoice.var.amount": "يشير  إلى مبلغ الفاتورة.",
+  "sms_notification.invoice.var.company_name": "يشير إلي اسم الشركة.",
+  "sms_notification.invoice.var.due_date": "يشير إلي تاريخ استحقاق الفاتورة.",
+
+  "sms_notification.receipt.var.receipt_number": "يشير  إلى رقم الإيصال.",
+  "sms_notification.receipt.var.reference_number": "يشير  إلى رقم الإشاري للإيصال.",
+  "sms_notification.receipt.var.customer_name": "يشير  إلى اسم العميل الإيصال.",
+  "sms_notification.receipt.var.amount": "يشير  إلى مبلغ الإيصال. ",
+  "sms_notification.receipt.var.company_name": "يشير إلي اسم الشركة.",
+
+  "sms_notification.payment.var.payment_number": "يشير  إلى رقم معاملة الدفع.",
+  "sms_notification.payment.var.reference_number": "يشير  إلى رقم الإشاري لعملية الدفع ",
+  "sms_notification.payment.var.customer_name": "يشير  إلى اسم العميل الدفع",
+  "sms_notification.payment.var.amount": "يشير  إلى مبلغ معاملة الدفع.",
+  "sms_notification.payment.company_name": "يشير إلي اسم الشركة.",
+  "sms_notification.payment.var.invoice_number": "يشير إلي رقم فاتورة التي تم دفعها.",
+
+  "sms_notification.estimate.var.estimate_number": "يشير  إلى رقم فاتورة عرض اسعار.",
+  "sms_notification.estimate.var.reference_number": "يشير  إلى رقم الإشاري لفاتورة عرض اسعار.",
+  "sms_notification.estimate.var.customer_name": "يشير  إلى اسم العميل الفاتورة",
+  "sms_notification.estimate.var.amount": "يشير  إلى قيمة الفاتورة",
+  "sms_notification.estimate.var.company_name": "يشير إلي اسم الشركة.",
+  "sms_notification.estimate.var.expiration_date": "يشير إلي تاريخ الصلاحية الفاتورة.",
+  "sms_notification.estimate.var.estimate_date": "يشير إلي تاريخ الفاتورة.",
+
+  "sms_notification.customer.var.customer_name": "يشير إلي اسم الزبون",
+  "sms_notification.customer.var.balance": "يشير إلي رصيد زبون المستحق.",
+  "sms_notification.customer.var.company_name": "يشير إلي اسم الشركة.",
+
+  "ability.accounts": "شجرة الحسابات",
+  "ability.manual_journal": "القيود اليدوية",
+  "ability.cashflow": "التدفقات النقدية",
+  "ability.inventory_adjustment": "تسويات المخزون",
+  "ability.customers": "الزبائن",
+  "ability.vendors": "الموردين",
+  "ability.sale_estimates": "فواتير عرض الاسعار",
+  "ability.sale_invoices": "فواتير البيع",
+  "ability.sale_receipts": "إيصالات البيع",
+  "ability.expenses": "المصاريف",
+  "ability.payments_receive": "سندات الزبائن",
+  "ability.purchase_invoices": "فواتير الشراء",
+  "ability.all_reports": "كل التقارير",
+  "ability.payments_made": "سندات الموردين",
+  "ability.preferences": "التفضيلات",
+  "ability.mutate_system_preferences": "تعديل تفضيلات النظام.",
+
+  "ability.items": "الأصناف",
+  "ability.view": "عرض",
+  "ability.create": "إضافة",
+  "ability.edit": "تعديل",
+  "ability.delete": "حذف",
+  "ability.transactions_locking": "إمكانية اغلاق المعاملات.",
+
+  "ability.balance_sheet_report": "ميزانية العمومية",
+  "ability.profit_loss_sheet": "قائمة الدخل",
+  "ability.journal": "اليومية العامة",
+  "ability.general_ledger": "دفتر الأستاذ العام",
+  "ability.cashflow_report": "تقرير التدفقات النقدية",
+  "ability.AR_aging_summary_report": "ملخص اعمار الديون للذمم المدينة",
+  "ability.AP_aging_summary_report": "ملخص اعمار الديون للذمم الدائنة",
+  "ability.purchases_by_items": "المشتريات حسب المنتجات",
+  "ability.sales_by_items_report": "المبيعات حسب المنتجات",
+  "ability.customers_transactions_report": "معاملات الزبائن",
+  "ability.vendors_transactions_report": "معاملات الموردين",
+  "ability.customers_summary_balance_report": "ملخص أرصدة الزبائن",
+  "ability.vendors_summary_balance_report": "ملخص أرصدة الموردين",
+  "ability.inventory_valuation_summary": "ملخص تقييم المخزون",
+  "ability.inventory_items_details": "تفاصيل منتج المخزون",
+
+  "vendor_credit.field.vendor": "المورد",
+  "vendor_credit.field.amount": "القيمة",
+  "vendor_credit.field.currency_code": "العملة",
+  "vendor_credit.field.credit_date": "تاريخ الاشعار",
+  "vendor_credit.field.credit_number": "رقم الاشعار",
+  "vendor_credit.field.note": "ملاحظة",
+  "vendor_credit.field.created_at": "أنشئت في",
+  "vendor_credit.field.reference_no": "رقم الإشاري",
+
+  "vendor_credit.field.status": "الحالة",
+  "vendor_credit.field.status.draft": "مسودة",
+  "vendor_credit.field.status.published": "تم نشرها",
+  "vendor_credit.field.status.open": "مفتوحة",
+  "vendor_credit.field.status.closed": "مغلقة",
+
+  "credit_note.field.terms_conditions": "الشروط والاحكام",
+  "credit_note.field.note": "ملاحظة",
+  "credit_note.field.currency_code": "العملة",
+  "credit_note.field.created_at": "أنشئت في",
+  "credit_note.field.amount": "القيمة",
+  "credit_note.field.credit_note_number": "رقم الاشعار",
+  "credit_note.field.credit_note_date": "تاريخ الاشعار",
+  "credit_note.field.customer": "الزبون",
+  "credit_note.field.reference_no": "رقم الإشاري",
+
+  "credit_note.field.status": "الحالة",
+  "credit_note.field.status.draft": "مسودة",
+  "credit_note.field.status.published": "تم نشرها",
+  "credit_note.field.status.open": "مفتوحة",
+  "credit_note.field.status.closed": "مغلقة",
+
+  "transactions_locking.module.sales.label": "المبيعات",
+  "transactions_locking.module.purchases.label": "المشتريات",
+  "transactions_locking.module.financial.label": "المالية",
+  "transactions_locking.module.all_transactions": "كل المعاملات",
+
+  "transactions_locking.module.sales.desc": "فواتير البيع ، والإيصالات ، والإشعارات الدائنة ، واستلام مدفوعات الزبائن ، والأرصدة الافتتاحية للزبائن.",
+  "transactions_locking.module.purchases.desc": "فواتير الشراء ومدفوعات الموردين وإشعارات المدينة والأرصدة الافتتاحية للموردين.",
+  "transactions_locking.module.financial.desc": "القيود اليدوية والمصروفات وتسويات المخزون.",
+
+  "inventory_adjustment.type.increment": "زيادة",
+  "inventory_adjustment.type.decrement": "نقصان",
+
+  "customer.type.individual": "فرد",
+  "customer.type.business": "اعمال",
+
+  "credit_note.view.draft": "مسودة",
+  "credit_note.view.closed": "مغلقة",
+  "credit_note.view.open": "مفتوحة",
+  "credit_note.view.published": "نشرت",
+
+  "vendor_credit.view.draft": "مسودة",
+  "vendor_credit.view.closed": "مغلقة",
+  "vendor_credit.view.open": "مفتوحة",
+  "vendor_credit.view.published": "نشرت",
+
+  "allocation_method.value.label": "القيمة",
+  "allocation_method.quantity.label": "الكمية",
+
+  "balance_sheet.assets": "الأصول",
+  "balance_sheet.current_asset": "الأصول المتداولة",
+  "balance_sheet.cash_and_cash_equivalents": "النقدية وما يعادلها",
+  "balance_sheet.accounts_receivable": "الذمم المدينة",
+  "balance_sheet.inventory": "المخزون",
+  "balance_sheet.other_current_assets": "اصول متداولة اخرى",
+  "balance_sheet.fixed_asset": "الأصول الثابتة",
+  "balance_sheet.non_current_assets": "الاصول غير المتداولة",
+  "balance_sheet.liabilities_and_equity": "الالتزامات وحقوق الملكية",
+  "balance_sheet.liabilities": "الإلتزامات",
+  "balance_sheet.current_liabilties": "الالتزامات المتداولة",
+  "balance_sheet.long_term_liabilities": "الالتزامات طويلة الاجل",
+  "balance_sheet.non_current_liabilities": "الالتزامات غير المتداولة",
+  "balance_sheet.equity": "حقوق الملكية",
+
+  "balance_sheet.account_name": "اسم الحساب",
+  "balance_sheet.total": "إجمالي",
+  "balance_sheet.percentage_of_column": "٪ التغير العمودي",
+  "balance_sheet.percentage_of_row": "٪ التغير الأفقي",
+
+  "financial_sheet.previoud_period_date": "(ف.س) {{date}}",
+  "fianncial_sheet.previous_period_change": "التغيرات (ف.س)",
+  "financial_sheet.previous_period_percentage": "٪ التغير (ف.س)",
+
+  "financial_sheet.previous_year_date": "(س.س) {{date}}",
+  "financial_sheet.previous_year_change": "التغيرات (س.س)",
+  "financial_sheet.previous_year_percentage": "٪ التغير (س.س)",
+  "financial_sheet.total_row": "إجمالي {{value}}",
+
+  "profit_loss_sheet.income": "الإيرادات",
+  "profit_loss_sheet.cost_of_sales": "تكلفة المبيعات",
+  "profit_loss_sheet.gross_profit": "إجمالي الدخل",
+  "profit_loss_sheet.expenses": "المصروفات",
+  "profit_loss_sheet.net_operating_income": "صافي الدخل التشغيلي",
+  "profit_loss_sheet.other_income": "إيرادات اخري",
+  "profit_loss_sheet.other_expenses": "مصاريف اخري",
+  "profit_loss_sheet.net_income": "صافي الدخل",
+
+  "profit_loss_sheet.account_name": "اسم الحساب",
+  "profit_loss_sheet.total": "إجمالي",
+
+  "profit_loss_sheet.percentage_of_income": "٪ التغير في الإيرادات",
+  "profit_loss_sheet.percentage_of_expenses": "٪ التغير في المصاريف",
+  "profit_loss_sheet.percentage_of_column": "٪ التغير العمودي",
+  "profit_loss_sheet.percentage_of_row": "٪ التغير الأفقي",
+
+  "warehouses.primary_warehouse": "المستودع الرئيسي",
+  "branches.head_branch": "الفرع الرئيسي",
+
+  "account.accounts_payable.currency": "الذمم الدائنة - {{currency}}",
+  "account.accounts_receivable.currency": "الذمم المدينة - {{currency}}",
+
+  "role.admin.name": "الادارة",
+  "role.admin.desc": "وصول غير مقيد لجميع الوحدات.",
+
+  "role.staff.name": "العاملين",
+  "role.staff.desc": "الوصول إلى جميع الوحدات باستثناء التقارير والإعدادات والمحاسبة.",
+
+  "warehouse_transfer.view.draft.name": "مسودة",
+  "warehouse_transfer.view.in_transit.name": "في النقل",
+  "warehouse_transfer.view.transferred.name": "تم النقل"
+}
\ No newline at end of file
diff --git a/packages/server/resources/locales/en.json b/packages/server/resources/locales/en.json
new file mode 100644
index 000000000..811db19e7
--- /dev/null
+++ b/packages/server/resources/locales/en.json
@@ -0,0 +1,641 @@
+{
+  "Petty Cash": "Petty Cash",
+  "Cash": "Cash",
+  "Bank": "Bank",
+  "Other Income": "Other Income",
+  "Interest Income": "Interest Income",
+  "Depreciation Expense": "Depreciation Expense",
+  "Interest Expense": "Interest Expense",
+  "Sales of Product Income": "Sales of Product Income",
+  "Inventory Asset": "Inventory Asset",
+  "Cost of Goods Sold (COGS)": "Cost of Goods Sold (COGS)",
+  "Cost of Goods Sold": "Cost of Goods Sold",
+  "Accounts Payable": "Accounts Payable",
+  "Other Expense": "Other Expense",
+  "Payroll Expenses": "Payroll Expenses",
+  "Fixed Asset": "Fixed Asset",
+  "Credit Card": "Credit Card",
+  "Non-Current Asset": "Non-Current Asset",
+  "Current Asset": "Current Asset",
+  "Other Asset": "Other Asset",
+  "Long Term Liability": "Long Term Liability",
+  "Current Liability": "Current Liability",
+  "Other Liability": "Other Liability",
+  "Equity": "Equity",
+  "Expense": "Expense",
+  "Income": "Income",
+  "Accounts Receivable (A/R)": "Accounts Receivable (A/R)",
+  "Accounts Receivable": "Accounts Receivable",
+  "Accounts Payable (A/P)": "Accounts Payable (A/P)",
+  "Inactive": "Inactive",
+  "Other Current Asset": "Other Current Asset",
+  "Tax Payable": "Tax Payable",
+  "Other Current Liability": "Other Current Liability",
+  "Non-Current Liability": "Non-Current Liability",
+  "Assets": "Assets",
+  "Liabilities": "Liabilities",
+  "Account name": "Account name",
+  "Account type": "Account type",
+  "Account normal": "Account normal",
+  "Description": "Description",
+  "Account code": "Account code",
+  "Currency": "Currency",
+  "Balance": "Balance",
+  "Active": "Active",
+  "Created at": "Created at",
+  "fixed_asset": "Fixed asset",
+  "Journal": "Journal",
+  "Reconciliation": "Reconciliation",
+  "Credit": "Credit",
+  "Debit": "Debit",
+  "Interest": "Interest",
+  "Depreciation": "Depreciation",
+  "Payroll": "Payroll",
+  "Type": "Type",
+  "Name": "Name",
+  "Sellable": "Sellable",
+  "Purchasable": "Purchasable",
+  "Sell price": "Sell price",
+  "Cost price": "Cost price",
+  "User": "User",
+  "Category": "Category",
+  "Note": "Note",
+  "Quantity on hand": "Quantity on hand",
+  "Quantity": "Quantity",
+  "Purchase description": "Purchase description",
+  "Sell description": "Sell description",
+  "Sell account": "Sell account",
+  "Cost account": "Cost account",
+  "Inventory account": "Inventory account",
+  "Payment date": "Payment date",
+  "Payment account": "Payment account",
+  "Amount": "Amount",
+  "Reference No.": "Reference No.",
+  "Journal number": "Journal number",
+  "Status": "Status",
+  "Journal type": "Journal type",
+  "Date": "Date",
+  "Asset": "Asset",
+  "Liability": "Liability",
+  "First-in first-out (FIFO)": "First-in first-out (FIFO)",
+  "Last-in first-out (LIFO)": "Last-in first-out (LIFO)",
+  "Average rate": "Average rate",
+  "Total": "Total",
+  "Transaction type": "Transaction type",
+  "Transaction #": "Transaction #",
+  "Running Value": "Running Value",
+  "Running quantity": "Running quantity",
+  "Profit Margin": "Profit Margin",
+  "Value": "Value",
+  "Rate": "Rate",
+  "OPERATING ACTIVITIES": "OPERATING ACTIVITIES",
+  "FINANCIAL ACTIVITIES": "FINANCIAL ACTIVITIES",
+  "Net income": "Net income",
+  "Adjustments net income by operating activities.": "Adjustments net income by operating activities.",
+  "Net cash provided by operating activities": "Net cash provided by operating activities",
+  "Net cash provided by investing activities": "Net cash provided by investing activities",
+  "Net cash provided by financing activities": "Net cash provided by financing activities",
+  "Cash at beginning of period": "Cash at beginning of period",
+  "NET CASH INCREASE FOR PERIOD": "NET CASH INCREASE FOR PERIOD",
+  "CASH AT END OF PERIOD": "CASH AT END OF PERIOD",
+  "Expenses": "Expenses",
+  "Services": "Services",
+  "Inventory": "Inventory",
+  "Non Inventory": "Non Inventory",
+  "Draft": "Draft",
+  "Published": "Published",
+  "Delivered": "Delivered",
+  "Overdue": "Overdue",
+  "Partially paid": "Partially paid",
+  "Paid": "Paid",
+  "Opened": "Opened",
+  "Unpaid": "Unpaid",
+  "Approved": "Approved",
+  "Rejected": "Rejected",
+  "Invoiced": "Invoiced",
+  "Expired": "Expired",
+  "Closed": "Closed",
+  "Manual journal": "Manual journal",
+  "Owner contribution": "Owner contribution",
+  "Transfer to account": "Transfer to account",
+  "Transfer from account": "Transfer from account",
+  "Other income": "Other income",
+  "Other expense": "Other expense",
+  "Owner drawing": "Owner drawing",
+  "Inventory adjustment": "Inventory adjustment",
+  "Customer opening balance": "Customer opening balance",
+  "Vendor opening balance": "Vendor opening balance",
+  "Payment made": "Payment made",
+  "Bill": "Bill",
+  "Payment receive": "Payment receive",
+  "Sale receipt": "Sale receipt",
+  "Sale invoice": "Sale invoice",
+  "Bank Account": "Bank Account",
+  "Saving Bank Account": "Saving Bank Account",
+  "Undeposited Funds": "Undeposited Funds",
+  "Computer Equipment": "Computer Equipment",
+  "Office Equipment": "Office Equipment",
+  "Uncategorized Income": "Uncategorized Income",
+  "Sales of Service Income": "Sales of Service Income",
+  "Bank Fees and Charges": "Bank Fees and Charges",
+  "Exchange Gain or Loss": "Exchange Gain or Loss",
+  "Rent": "Rent",
+  "Office expenses": "Office expenses",
+  "Other Expenses": "Other Expenses",
+  "Drawings": "Drawings",
+  "Owner's Equity": "Owner's Equity",
+  "Opening Balance Equity": "Opening Balance Equity",
+  "Retained Earnings": "Retained Earnings",
+  "Sales Tax Payable": "Sales Tax Payable",
+  "Revenue Received in Advance": "Revenue Received in Advance",
+  "Opening Balance Liabilities": "Opening Balance Liabilities",
+  "Loan": "Loan",
+  "Owner A Drawings": "Owner A Drawings",
+  "An account that holds valuation of products or goods that availiable for sale.": "An account that holds valuation of products or goods that availiable for sale.",
+  "Tracks the gain and losses of the exchange differences.": "Tracks the gain and losses of the exchange differences.",
+  "Any bank fees levied is recorded into the bank fees and charges account. A bank account maintenance fee, transaction charges, a late payment fee are some examples.": "Any bank fees levied is recorded into the bank fees and charges account. A bank account maintenance fee, transaction charges, a late payment fee are some examples.",
+  "The income activities are not associated to the core business.": "The income activities are not associated to the core business.",
+  "Cash and cash equivalents": "Cash and cash equivalents",
+  "Inventories": "Inventories",
+  "Other current assets": "Other current assets",
+  "Non-Current Assets": "Non-Current Assets",
+  "Current Liabilties": "Current Liabilties",
+  "Long-Term Liabilities": "Long-Term Liabilities",
+  "Non-Current Liabilities": "Non-Current Liabilities",
+  "Liabilities and Equity": "Liabilities and Equity",
+  "Closing balance": "Closing balance",
+  "Opening Balance": "Opening balance",
+  "Total {{accountName}}": "Total {{accountName}}",
+  "invoice.paper.invoice": "Invoice",
+  "invoice.paper.invoice_amount": "Invoice amount",
+  "invoice.paper.due_amount": "Due amount",
+  "invoice.paper.billed_to": "Billed to",
+  "invoice.paper.invoice_date": "Invoice date",
+  "invoice.paper.invoice_number": "Invoice No.",
+  "invoice.paper.due_date": "Due date",
+  "invoice.paper.conditions_title": "Conditions & terms",
+  "invoice.paper.notes_title": "Notes",
+  "invoice.paper.total": "Total",
+  "invoice.paper.payment_amount": "Payment Amount",
+  "invoice.paper.balance_due": "Balance Due",
+
+  "item_entry.paper.item_name": "Item name",
+  "item_entry.paper.rate": "Rate",
+  "item_entry.paper.quantity": "Quantity",
+  "item_entry.paper.total": "Total",
+
+  "estimate.paper.estimate": "Estimate",
+  "estimate.paper.estimate_amount": "Estimate amount",
+  "estimate.paper.billed_to": "Billed to",
+  "estimate.paper.estimate_date": "Estimate date",
+  "estimate.paper.estimate_number": "Estimate number",
+  "estimate.paper.expiration_date": "Expiration date",
+  "estimate.paper.conditions_title": "Conditions & terms",
+  "estimate.paper.notes_title": "Notes",
+  "estimate.paper.amount": "Estimate amount",
+  "estimate.paper.subtotal": "Subtotal",
+  "estimate.paper.total": "Total",
+
+  "receipt.paper.receipt": "Receipt",
+  "receipt.paper.billed_to": "Billed to",
+  "receipt.paper.receipt_date": "Receipt date",
+  "receipt.paper.receipt_number": "Receipt number",
+  "receipt.paper.expiration_date": "Expiration date",
+  "receipt.paper.conditions_title": "Conditions & terms",
+  "receipt.paper.notes": "Notes",
+  "receipt.paper.statement": "Statement",
+  "receipt.paper.receipt_amount": "Receipt amount",
+  "receipt.paper.total": "Total",
+  "receipt.paper.balance_due": "Balance Due",
+  "receipt.paper.payment_amount": "Payment Amount",
+
+  "credit.paper.credit_note": "Credit Note",
+  "credit.paper.remaining": "Credit remaining",
+  "credit.paper.amount": "Credit amount",
+  "credit.paper.billed_to": "Bill to",
+  "credit.paper.credit_date": "Credit date",
+  "credit.paper.total": "Total",
+  "credit.paper.credits_used": "Credits used",
+  "credit.paper.credits_remaining": "Credits remaining",
+  "credit.paper.conditions_title": "Conditions & terms",
+  "credit.paper.notes": "Notes",
+
+  "payment.paper.payment_receipt": "Payment Receipt",
+  "payment.paper.amount_received": "Amount received",
+  "payment.paper.billed_to": "Billed to",
+  "payment.paper.payment_date": "Payment date",
+  "payment.paper.invoice_number": "Invoice number",
+  "payment.paper.invoice_date": "Invoice date",
+  "payment.paper.invoice_amount": "Invoice amount",
+  "payment.paper.payment_amount": "Payment amount",
+  "payment.paper.balance_due": "Balance Due",
+  "payment.paper.statement": "Statement",
+
+  "account.field.name": "Account name",
+  "account.field.description": "Description",
+  "account.field.slug": "Account slug",
+  "account.field.code": "Account code",
+  "account.field.root_type": "Root type",
+  "account.field.normal": "Account normal",
+  "account.field.normal.credit": "Credit",
+  "account.field.normal.debit": "Debit",
+  "account.field.type": "Type",
+  "account.field.active": "Activity",
+  "account.field.balance": "Balance",
+  "account.field.created_at": "Created at",
+  "item.field.type": "Item type",
+  "item.field.type.inventory": "Inventory",
+  "item.field.type.service": "Service",
+  "item.field.type.non-inventory": "Non inventory",
+  "item.field.name": "Name",
+  "item.field.code": "Code",
+  "item.field.sellable": "Sellable",
+  "item.field.purchasable": "Purchasable",
+  "item.field.cost_price": "Cost price",
+  "item.field.cost_account": "Cost account",
+  "item.field.sell_account": "Sell account",
+  "item.field.sell_description": "Sell description",
+  "item.field.inventory_account": "Inventory account",
+  "item.field.purchase_description": "Purchase description",
+  "item.field.quantity_on_hand": "Quantity on hand",
+  "item.field.note": "Note",
+  "item.field.category": "Category",
+  "item.field.active": "Active",
+  "item.field.created_at": "Created at",
+  "item_category.field.name": "Name",
+  "item_category.field.description": "Description",
+  "item_category.field.count": "Count",
+  "item_category.field.created_at": "Created at",
+  "invoice.field.customer": "Customer",
+  "invoice.field.invoice_date": "Invoice date",
+  "invoice.field.due_date": "Due date",
+  "invoice.field.invoice_no": "Invoice No.",
+  "invoice.field.reference_no": "Reference No.",
+  "invoice.field.invoice_message": "Invoice message",
+  "invoice.field.terms_conditions": "Terms & conditions",
+  "invoice.field.amount": "Amount",
+  "invoice.field.payment_amount": "Payment amount",
+  "invoice.field.due_amount": "Due amount",
+  "invoice.field.status": "Status",
+  "invoice.field.status.paid": "Paid",
+  "invoice.field.status.partially-paid": "Partially paid",
+  "invoice.field.status.overdue": "Overdue",
+  "invoice.field.status.unpaid": "Unpaid",
+  "invoice.field.status.delivered": "Delivered",
+  "invoice.field.status.draft": "Draft",
+  "invoice.field.created_at": "Created at",
+  "estimate.field.amount": "Amount",
+  "estimate.field.estimate_number": "Estimate number",
+  "estimate.field.customer": "Customer",
+  "estimate.field.estimate_date": "Estimate date",
+  "estimate.field.expiration_date": "Expiration date",
+  "estimate.field.reference_no": "Reference No.",
+  "estimate.field.note": "Note",
+  "estimate.field.terms_conditions": "Terms & conditions",
+  "estimate.field.status": "Status",
+  "estimate.field.status.delivered": "Delivered",
+  "estimate.field.status.rejected": "Rejected",
+  "estimate.field.status.approved": "Approved",
+  "estimate.field.status.draft": "Draft",
+  "estimate.field.created_at": "Created at",
+  "payment_receive.field.customer": "Customer",
+  "payment_receive.field.payment_date": "Payment date",
+  "payment_receive.field.amount": "Amount",
+  "payment_receive.field.reference_no": "Reference No.",
+  "payment_receive.field.deposit_account": "Deposit account",
+  "payment_receive.field.payment_receive_no": "Payment receive No.",
+  "payment_receive.field.statement": "Statement",
+  "payment_receive.field.created_at": "Created at",
+  "bill_payment.field.vendor": "Vendor",
+  "bill_payment.field.amount": "Amount",
+  "bill_payment.field.due_amount": "Due amount",
+  "bill_payment.field.payment_account": "Payment account",
+  "bill_payment.field.payment_number": "Payment number",
+  "bill_payment.field.payment_date": "Payment date",
+  "bill_payment.field.reference_no": "Reference No.",
+  "bill_payment.field.description": "Description",
+  "bill_payment.field.created_at": "Created at",
+  "bill.field.vendor": "Vendor",
+  "bill.field.bill_number": "Bill number",
+  "bill.field.bill_date": "Bill date",
+  "bill.field.due_date": "Due date",
+  "bill.field.reference_no": "Reference No.",
+  "bill.field.status": "Status",
+  "bill.field.status.paid": "Paid",
+  "bill.field.status.partially-paid": "Partially paid",
+  "bill.field.status.unpaid": "Unpaid",
+  "bill.field.status.opened": "Opened",
+  "bill.field.status.draft": "Draft",
+  "bill.field.status.overdue": "overdue",
+  "bill.field.amount": "Amount",
+  "bill.field.payment_amount": "Payment amount",
+  "bill.field.note": "Note",
+  "bill.field.created_at": "Created at",
+  "inventory_adjustment.field.date": "Date",
+  "inventory_adjustment.field.type": "Type",
+  "inventory_adjustment.field.type.increment": "Increment",
+  "inventory_adjustment.field.type.decrement": "Decrement",
+  "inventory_adjustment.field.adjustment_account": "Adjustment account",
+  "inventory_adjustment.field.reason": "Reason",
+  "inventory_adjustment.field.reference_no": "Reference No.",
+  "inventory_adjustment.field.description": "Description",
+  "inventory_adjustment.field.published_at": "Published at",
+  "inventory_adjustment.field.created_at": "Created at",
+  "expense.field.payment_date": "Payment date",
+  "expense.field.payment_account": "Payment account",
+  "expense.field.amount": "Amount",
+  "expense.field.reference_no": "Reference No.",
+  "expense.field.description": "Description",
+  "expense.field.published": "Published",
+  "expense.field.status": "Status",
+  "expense.field.status.draft": "Draft",
+  "expense.field.status.published": "Published",
+  "expense.field.created_at": "Created at",
+  "manual_journal.field.date": "Date",
+  "manual_journal.field.journal_number": "Journal number",
+  "manual_journal.field.reference": "Reference No.",
+  "manual_journal.field.journal_type": "Journal type",
+  "manual_journal.field.amount": "Amount",
+  "manual_journal.field.description": "Description",
+  "manual_journal.field.status": "Status",
+  "manual_journal.field.created_at": "Created at",
+  "receipt.field.amount": "Amount",
+  "receipt.field.deposit_account": "Deposit account",
+  "receipt.field.customer": "Customer",
+  "receipt.field.receipt_date": "Receipt date",
+  "receipt.field.receipt_number": "Receipt number",
+  "receipt.field.reference_no": "Reference No.",
+  "receipt.field.receipt_message": "Receipt message",
+  "receipt.field.statement": "Statement",
+  "receipt.field.created_at": "Created at",
+  "receipt.field.status": "Status",
+  "receipt.field.status.draft": "Draft",
+  "receipt.field.status.closed": "Closed",
+  "customer.field.first_name": "First name",
+  "customer.field.last_name": "Last name",
+  "customer.field.display_name": "Display name",
+  "customer.field.email": "Email",
+  "customer.field.work_phone": "Work phone",
+  "customer.field.personal_phone": "Personal phone",
+  "customer.field.company_name": "Company name",
+  "customer.field.website": "Website",
+  "customer.field.opening_balance_at": "Opening balance at",
+  "customer.field.opening_balance": "Opening balance",
+  "customer.field.created_at": "Created at",
+  "customer.field.balance": "Balance",
+  "customer.field.status": "Status",
+  "customer.field.currency": "Curreny",
+  "customer.field.status.active": "Active",
+  "customer.field.status.inactive": "Inactive",
+  "customer.field.status.overdue": "Overdue",
+  "customer.field.status.unpaid": "Unpaid",
+  "vendor.field.first_name": "First name",
+  "vendor.field.last_name": "Last name",
+  "vendor.field.display_name": "Display name",
+  "vendor.field.email": "Email",
+  "vendor.field.work_phone": "Work phone",
+  "vendor.field.personal_phone": "Personal phone",
+  "vendor.field.company_name": "Company name",
+  "vendor.field.website": "Website",
+  "vendor.field.opening_balance_at": "Opening balance at",
+  "vendor.field.opening_balance": "Opening balance",
+  "vendor.field.created_at": "Created at",
+  "vendor.field.balance": "Balance",
+  "vendor.field.status": "Status",
+  "vendor.field.currency": "Curreny",
+  "vendor.field.status.active": "Active",
+  "vendor.field.status.inactive": "Inactive",
+  "vendor.field.status.overdue": "Overdue",
+  "vendor.field.status.unpaid": "Unpaid",
+  "Invoice write-off": "Invoice write-off",
+
+  "transaction_type.credit_note": "Credit note",
+  "transaction_type.refund_credit_note": "Refund credit note",
+  "transaction_type.vendor_credit": "Vendor credit",
+  "transaction_type.refund_vendor_credit": "Refund vendor credit",
+  "transaction_type.landed_cost": "Landed cost",
+
+  "sms_notification.invoice_details.label": "Sale invoice details",
+  "sms_notification.invoice_reminder.label": "Sale invoice reminder",
+  "sms_notification.receipt_details.label": "Sale receipt details",
+  "sms_notification.sale_estimate_details.label": "Sale estimate details",
+  "sms_notification.payment_receive_details.label": "Payment receive details",
+  "sms_notification.customer_balance.label": "Customer balance",
+
+  "sms_notification.invoice_details.description": "SMS notification will be sent to your customer once invoice created and published or when notify customer via SMS about the invoice.",
+  "sms_notification.payment_receive.description": "Payment thank you message notification will be sent to customer once the payment created and published or notify customer about payment manually.",
+  "sms_notification.receipt_details.description": "SMS notification will be sent to your cusotmer once receipt created and published or when notify customer about the receipt manually.",
+  "sms_notification.customer_balance.description": "Send SMS to notify customers about their current outstanding balance.",
+  "sms_notification.estimate_details.description": "SMS notification will be sent to your customer once estimate publish or notify customer about estimate manually.",
+  "sms_notification.invoice_reminder.description": "SMS notification will be sent to remind the customer to pay earliest, either automatically or manually.",
+
+  "sms_notification.customer_balance.default_message": "Dear {CustomerName}, This is reminder about your current outstanding balance of {Balance}, Please pay at the earliest. - {CompanyName}",
+  "sms_notification.payment_receive.default_message": "'Hi, {CustomerName}, We have received your payment for the invoice - {InvoiceNumber}. We look forward to serving you again. Thank you. - {CompanyName}'",
+  "sms_notification.estimate.default_message": "Hi, {CustomerName}, We have created an estimate - {EstimateNumber} for you. Please take a look and accept it to proceed further. Looking forward to hearing from you. - {CompanyName}",
+
+  "sms_notification.invoice_details.default_message": "Hi, {CustomerName}, You have an outstanding amount of {DueAmount} for the invoice {InvoiceNumber}. - {CompanyName}",
+  "sms_notification.receipt_details.default_message": "Hi, {CustomerName}, We have created receipt - {ReceiptNumber} for you. we look forward to serveing you again. Thank your - {CompanyName}",
+  "sms_notification.invoice_reminder.default_message": "Dear {CustomerName}, The payment towards the invoice - {InvoiceNumber} is due. Please pay before {DueDate}. Thank you. - {CompanyName}",
+
+  "module.sale_invoices.label": "Sale invoices",
+  "module.sale_receipts.label": "Sale receipts",
+  "module.sale_estimates.label": "Sale estimates",
+  "module.payment_receives.label": "Payment receive",
+  "module.customers.label": "Customers",
+
+  "sms_notification.invoice.var.invoice_number": "References to invoice number.",
+  "sms_notification.invoice.var.reference_number": "References to invoice reference number.",
+  "sms_notification.invoice.var.customer_name": "References to invoice customer name.",
+  "sms_notification.invoice.var.due_amount": "References to invoice due amount.",
+  "sms_notification.invoice.var.amount": "References to invoice amount.",
+  "sms_notification.invoice.var.company_name": "References to company name.",
+  "sms_notification.invoice.var.due_date": "References to invoice due date.",
+
+  "sms_notification.receipt.var.receipt_number": "References to receipt number.",
+  "sms_notification.receipt.var.reference_number": "References to receipt reference number.",
+  "sms_notification.receipt.var.customer_name": "References to receipt customer name.",
+  "sms_notification.receipt.var.amount": "References to receipt amount.",
+  "sms_notification.receipt.var.company_name": "References to company name.",
+
+  "sms_notification.payment.var.payment_number": "References to payment transaction number.",
+  "sms_notification.payment.var.reference_number": "References to payment reference number",
+  "sms_notification.payment.var.customer_name": "References to payment customer name.",
+  "sms_notification.payment.var.amount": "References to payment transaction amount.",
+  "sms_notification.payment.company_name": "References to company name",
+  "sms_notification.payment.var.invoice_number": "Reference to payment invoice number.",
+
+  "sms_notification.estimate.var.estimate_number": "References to estimate number.",
+  "sms_notification.estimate.var.reference_number": "References to estimate reference number.",
+  "sms_notification.estimate.var.customer_name": "References to estimate customer name.",
+  "sms_notification.estimate.var.amount": "References to estimate amount.",
+  "sms_notification.estimate.var.company_name": "References to company name.",
+  "sms_notification.estimate.var.expiration_date": "References to estimate expirtaion date.",
+  "sms_notification.estimate.var.estimate_date": "References to estimate date.",
+
+  "sms_notification.customer.var.customer_name": "References to customer name.",
+  "sms_notification.customer.var.balance": "References to customer outstanding balance.",
+  "sms_notification.customer.var.company_name": "References to company name.",
+
+  "ability.accounts": "Chart of accounts",
+  "ability.manual_journal": "Manual journals",
+  "ability.cashflow": "Cash flow",
+  "ability.inventory_adjustment": "Inventory adjustments",
+  "ability.customers": "Customers",
+  "ability.vendors": "vendors",
+  "ability.sale_estimates": "Sale estimates",
+  "ability.sale_invoices": "Sale invoices",
+  "ability.sale_receipts": "Sale receipts",
+  "ability.expenses": "Expenses",
+  "ability.payments_receive": "Payments receive",
+  "ability.purchase_invoices": "Purchase invoices",
+  "ability.all_reports": "All reports",
+  "ability.payments_made": "Payments made",
+  "ability.preferences": "Preferences",
+  "ability.mutate_system_preferences": "Mutate the system preferences.",
+
+  "ability.items": "Items",
+  "ability.view": "View",
+  "ability.create": "Create",
+  "ability.edit": "Edit",
+  "ability.delete": "Delete",
+  "ability.transactions_locking": "Ability to transactions locking.",
+
+  "ability.balance_sheet_report": "Balance sheet.",
+  "ability.profit_loss_sheet": "Profit/loss sheet",
+  "ability.journal": "Journal",
+  "ability.general_ledger": "General ledger",
+  "ability.cashflow_report": "Cashflow",
+  "ability.AR_aging_summary_report": "A/R aging summary",
+  "ability.AP_aging_summary_report": "A/P aging summary",
+  "ability.purchases_by_items": "Purchases by items",
+  "ability.sales_by_items_report": "Sales by items",
+  "ability.customers_transactions_report": "Customers transactions",
+  "ability.vendors_transactions_report": "Vendors transactions",
+  "ability.customers_summary_balance_report": "Customers summary balance",
+  "ability.vendors_summary_balance_report": "Vendors summary balance",
+  "ability.inventory_valuation_summary": "Inventory valuation summary",
+  "ability.inventory_items_details": "Inventory items details",
+
+  "vendor_credit.field.vendor": "Vendor name",
+  "vendor_credit.field.amount": "Amount",
+  "vendor_credit.field.currency_code": "Currency code",
+  "vendor_credit.field.credit_date": "Credit date",
+  "vendor_credit.field.credit_number": "Credit number",
+  "vendor_credit.field.note": "Note",
+  "vendor_credit.field.created_at": "Created at",
+  "vendor_credit.field.reference_no": "Reference No.",
+
+  "credit_note.field.terms_conditions": "Terms and conditions",
+  "credit_note.field.note": "Note",
+  "credit_note.field.currency_code": "Currency code",
+  "credit_note.field.created_at": "Created at",
+  "credit_note.field.amount": "Amount",
+  "credit_note.field.credit_note_number": "Credit note number",
+  "credit_note.field.credit_note_date": "Credit date",
+  "credit_note.field.customer": "Customer",
+  "credit_note.field.reference_no": "Reference No.",
+
+  "Credit note": "Credit note",
+  "Vendor credit": "Vendor credit",
+  "Refund credit note": "Refund credit note",
+  "Refund vendor credit": "Refund vendor credit",
+  "credit_note.field.status": "Status",
+  "credit_note.field.status.draft": "Draft",
+  "credit_note.field.status.published": "Published",
+  "credit_note.field.status.open": "Open",
+  "credit_note.field.status.closed": "Closed",
+
+  "transactions_locking.module.sales.label": "Sales",
+  "transactions_locking.module.purchases.label": "Purchases",
+  "transactions_locking.module.financial.label": "Financial",
+  "transactions_locking.module.all_transactions": "All transactions",
+
+  "transactions_locking.module.sales.desc": "Sale invoices, Receipts, credit notes, customers payment receive and customers opening balances.",
+  "transactions_locking.module.purchases.desc": "Purchase invoices, vendors payments, vendor credit notes and vendors opening balances.",
+  "transactions_locking.module.financial.desc": "Manual journal, expenses and inventory adjustments.",
+
+  "inventory_adjustment.type.increment": "Increment",
+  "inventory_adjustment.type.decrement": "Decrement",
+
+  "customer.type.individual": "Individual",
+  "customer.type.business": "Business",
+
+  "credit_note.view.draft": "Draft",
+  "credit_note.view.closed": "Closed",
+  "credit_note.view.open": "Open",
+  "credit_note.view.published": "Published",
+
+  "vendor_credit.view.draft": "Draft",
+  "vendor_credit.view.closed": "Closed",
+  "vendor_credit.view.open": "Open",
+  "vendor_credit.view.published": "Published",
+
+  "allocation_method.value.label": "Value",
+  "allocation_method.quantity.label": "Quantity",
+
+  "balance_sheet.assets": "Assets",
+  "balance_sheet.current_asset": "Current Asset",
+  "balance_sheet.cash_and_cash_equivalents": "Cash and cash equivalents",
+  "balance_sheet.accounts_receivable": "Accounts Receivable",
+  "balance_sheet.inventory": "Inventory",
+  "balance_sheet.other_current_assets": "Other current assets",
+  "balance_sheet.fixed_asset": "Fixed Asset",
+  "balance_sheet.non_current_assets": "Non-Current Assets",
+  "balance_sheet.liabilities_and_equity": "Liabilities and Equity",
+  "balance_sheet.liabilities": "Liabilities",
+  "balance_sheet.current_liabilties": "Current Liabilties",
+  "balance_sheet.long_term_liabilities": "Long-Term Liabilities",
+  "balance_sheet.non_current_liabilities": "Non-Current Liabilities",
+  "balance_sheet.equity": "Equity",
+
+  "balance_sheet.account_name": "Account name",
+  "balance_sheet.total": "Total",
+  "balance_sheet.percentage_of_column": "% of Column",
+  "balance_sheet.percentage_of_row": "% of Row",
+
+  "financial_sheet.previoud_period_date": "{{date}} (PP)",
+  "fianncial_sheet.previous_period_change": "Change (PP)",
+  "financial_sheet.previous_period_percentage": "% Change (PP)",
+
+  "financial_sheet.previous_year_date": "{{date}} (PY)",
+  "financial_sheet.previous_year_change": "Change (PY)",
+  "financial_sheet.previous_year_percentage": "% Change (PY)",
+  "financial_sheet.total_row": "Total {{value}}",
+
+  "profit_loss_sheet.income": "Income",
+  "profit_loss_sheet.cost_of_sales": "Cost of sales",
+  "profit_loss_sheet.gross_profit": "GROSS PROFIT",
+  "profit_loss_sheet.expenses": "Expenses",
+  "profit_loss_sheet.net_operating_income": "NET OPERATING INCOME",
+  "profit_loss_sheet.other_income": "Other income",
+  "profit_loss_sheet.other_expenses": "Other expenses",
+  "profit_loss_sheet.net_income": "NET INCOME",
+
+  "profit_loss_sheet.account_name": "Account name",
+  "profit_loss_sheet.total": "Total",
+
+  "profit_loss_sheet.percentage_of_income": "% of Income",
+  "profit_loss_sheet.percentage_of_expenses": "% of Expenses",
+  "profit_loss_sheet.percentage_of_column": "% of Column",
+  "profit_loss_sheet.percentage_of_row": "% of Row",
+
+  "contact_summary_balance.account_name": "Account name",
+  "contact_summary_balance.total": "Total",
+  "contact_summary_balance.percentage_column": "% of Column",
+
+  "warehouses.primary_warehouse": "Primary warehouse",
+  "branches.head_branch": "Head Branch",
+
+  "account.accounts_payable.currency": "Accounts Payable (A/P) - {{currency}}",
+  "account.accounts_receivable.currency": "Accounts Receivable (A/R) - {{currency}}",
+
+  "role.admin.name": "Admin",
+  "role.admin.desc": "Unrestricted access to all modules.",
+
+  "role.staff.name": "Staff",
+  "role.staff.desc": "Access to all modules except reports, settings and accountant.",
+
+  "warehouse_transfer.view.draft.name": "Draft",
+  "warehouse_transfer.view.in_transit.name": "In Transit",
+  "warehouse_transfer.view.transferred.name": "Transferred"
+}
\ No newline at end of file
diff --git a/packages/server/resources/scss/base.scss b/packages/server/resources/scss/base.scss
new file mode 100644
index 000000000..bf7b32cc6
--- /dev/null
+++ b/packages/server/resources/scss/base.scss
@@ -0,0 +1,35 @@
+@import "./normalize.scss";
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+th {
+    text-align: inherit; // 2
+    text-align: -webkit-match-parent; // 3
+}
+
+thead,
+tbody,
+tfoot,
+tr,
+td,
+th {
+    border-color: inherit;
+    border-style: solid;
+    border-width: 0;
+}
+
+body{
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  background-color: #fff;
+  direction: ltr;
+  -webkit-text-size-adjust: 100%;
+  -webkit-tap-highlight-color: transparent;
+}
diff --git a/packages/server/resources/scss/fonts.scss b/packages/server/resources/scss/fonts.scss
new file mode 100644
index 000000000..000d1500c
--- /dev/null
+++ b/packages/server/resources/scss/fonts.scss
@@ -0,0 +1,26 @@
+
+$SegoeUIFont: "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";
+
+
+$NotoSansSrc: "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";
+
+// Noto Sans
+// -------------------------------------
+@font-face {
+  font-family: "Noto Sans";
+  src: local('Noto Sans'), url(data:font/woff2;base64,#{$NotoSansSrc}) format('woff');
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+
+// Segoe UI Arabic
+// -------------------------------------
+@font-face {
+  font-family: 'Segoe UI';
+  src: local('Segoe UI'), url(data:application/x-font-woff;charset=utf-8;base64,#{$SegoeUIFont}) format('woff');
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+}
+ 
\ No newline at end of file
diff --git a/packages/server/resources/scss/layouts/paper-layout.scss b/packages/server/resources/scss/layouts/paper-layout.scss
new file mode 100644
index 000000000..11a43d1ba
--- /dev/null
+++ b/packages/server/resources/scss/layouts/paper-layout.scss
@@ -0,0 +1,19 @@
+@import "../base.scss";
+@import "../fonts.scss";
+
+body {
+  background: #f8f9fa;
+  text-align: left;
+  -webkit-print-color-adjust: exact;
+
+  html[lang^='ar'] & {
+    font-family: "Segoe UI";
+  }
+  html[lang^='en'] & {
+    font-family: "Noto Sans";
+  }
+
+  @media print {
+    background: #fff;
+  }
+}
diff --git a/packages/server/resources/scss/modules/credit.scss b/packages/server/resources/scss/modules/credit.scss
new file mode 100644
index 000000000..860cdfcd4
--- /dev/null
+++ b/packages/server/resources/scss/modules/credit.scss
@@ -0,0 +1,193 @@
+@import "../layouts/paper-layout.scss";
+
+.credit {
+  text-align: left;
+  padding: 45px 40px;
+
+  &__header {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    margin: 0 0 30px;
+
+    .organization {
+      .title {
+        margin: 0 0 4px;
+      }
+
+      .creditNumber {
+        font-size: 12px;
+      }
+    }
+
+    .paper {
+
+      .title {
+        font-weight: 400;
+        text-transform: uppercase;
+        margin: 0 0 2px;
+        font-size: 32px;
+        line-height: 1;
+      }
+    }
+  }
+
+
+  &__full-amount {
+    margin-bottom: 18px;
+
+    .label {
+      font-size: 12px;
+    }
+
+    .amount {
+      font-size: 18px;
+      font-weight: 800;
+    }
+  }
+
+  &__meta {
+    display: flex;
+    flex-direction: column;
+    margin-bottom: 20px;
+    font-size: 13px;
+
+    &-item {
+      padding-right: 10px;
+      font-weight: 400;
+      margin-bottom: 10px;
+      display: flex;
+      flex-direction: row;
+
+      .value {
+        color: #000;
+      }
+
+      .label {
+        color: #444;
+        margin-bottom: 2px;
+        width: 180px;
+      }
+    }
+  }
+
+  &__table {
+    display: flex;
+    flex-direction: column;
+
+    table {
+      font-size: 12px;
+      color: #000;
+      text-align: left;
+      border-spacing: 0;
+
+      thead th,
+      tbody tr td {
+        margin-bottom: 15px;
+        background: transparent;
+      }
+
+      thead th {
+        font-weight: 400;
+        border-bottom: none;
+        padding: 8px;
+        color: #fff;
+        background-color: #333;
+      }
+
+      tbody tr td {
+        padding: 8px;
+        border-bottom: 1px solid #cecbcb;
+      }
+
+      thead tr th,
+      tbody tr td {
+        &.item {
+          width: 45%;
+        }
+
+        &.rate {
+          width: 18%;
+          text-align: right;
+        }
+
+        &.quantity {
+          width: 16%;
+          text-align: right;
+        }
+
+        &.total {
+          width: 21%;
+          text-align: right;
+        }
+      }
+
+      .description {
+        color: #666;
+      }
+    }
+  }
+
+  &__table-after {
+    display: flex;
+  }
+
+  &__table-total {
+    margin-bottom: 20px;
+    width: 50%;
+    float: right;
+    margin-left: auto;
+
+    table {
+      border-spacing: 0;
+      width: 100%;
+      font-size: 12px;
+
+      tbody tr td {
+        padding: 8px 10px 8px 0;
+        border-top: 1px solid #d5d5d5;
+
+        &:last-child {
+          width: 140px;
+          text-align: right;
+        }
+      }
+
+      tbody tr:first-child td {
+        border-top: 0;
+      }
+
+      tbody tr.payment-amount td:last-child {
+        color: red
+      }
+
+      tbody tr.blanace-due td {
+        border-top: 3px double #666;
+        font-weight: bold;
+      }
+    }
+  }
+
+  &__footer {
+    font-size: 12px;
+  }
+
+  &__conditions,
+  &__notes {
+
+    h3 {
+      color: #666;
+      font-size: 12px;
+      margin-top: 0;
+      margin-bottom: 10px;
+    }
+
+    p {
+      margin: 0;
+    }
+  }
+
+  &__conditions+&__notes {
+    margin-top: 20px;
+  }
+}
\ No newline at end of file
diff --git a/packages/server/resources/scss/modules/estimate.scss b/packages/server/resources/scss/modules/estimate.scss
new file mode 100644
index 000000000..6588d5766
--- /dev/null
+++ b/packages/server/resources/scss/modules/estimate.scss
@@ -0,0 +1,174 @@
+@import "../layouts/paper-layout.scss";
+
+.estimate {
+  text-align: left;
+  padding: 45px;
+
+  &__header {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    margin: 0 0 30px;
+
+    .organization {
+      .title {
+        margin: 0 0 4px;
+      }
+    }
+
+    .paper {
+      .title {
+        font-weight: 400;
+        text-transform: uppercase;
+        margin: 0 0 2px;
+        font-size: 32px;
+        line-height: 1;
+      }
+    }
+  }
+
+  &__estimate-amount {
+    margin-bottom: 18px;
+
+    .label {
+      font-size: 12px;
+    }
+    .amount {
+      font-size: 18px;
+      font-weight: 800;
+    }
+  }
+  &__meta {
+    display: flex;
+    flex-direction: column;
+    margin-bottom: 20px;
+    font-size: 13px;
+
+    &-item {
+      padding-right: 10px;
+      margin-bottom: 10px;
+      display: flex;
+      flex-direction: row;
+
+      .value {
+        color: #000;
+      }
+
+      .label {
+        color: #444;
+        margin-bottom: 2px;
+        width: 180px;
+      }
+    }
+  }
+
+  &__table {
+    display: flex;
+    flex-direction: column;
+
+    table {
+      font-size: 12px;
+      color: #000;
+      text-align: left;
+      border-spacing: 0;
+
+      thead th,
+      tbody tr td {
+        margin-bottom: 15px;
+        background: transparent;
+      }
+
+      thead th {
+        font-weight: 400;
+        border-bottom: none;
+        padding: 8px;
+        color: #fff;
+        background-color: #333;
+      }
+
+      tbody tr td {
+        padding: 8px;
+        border-bottom: 1px solid #cecbcb;
+      }
+
+      thead tr th,
+      tbody tr td {
+        &.item {
+          width: 45%;
+        }
+
+        &.rate {
+          width: 18%;
+          text-align: right;
+        }
+
+        &.quantity {
+          width: 16%;
+          text-align: right;
+        }
+
+        &.total {
+          width: 21%;
+          text-align: right;
+        }
+
+        .description {
+          color: #666;
+        }
+      }
+    }
+  }
+
+  &__table-after {
+    display: flex;
+  }
+
+  &__table-total {
+    margin-bottom: 20px;
+    width: 50%;
+    float: right;
+    margin-left: auto;
+
+    table {
+      border-spacing: 0;
+      width: 100%;
+      font-size: 12px;
+
+      tbody tr td {
+        padding: 8px 10px 8px 0;
+        border-top: 1px solid #d5d5d5;
+
+        &:last-child {
+          width: 140px;
+          text-align: right;
+        }
+      }
+
+      tbody tr:first-child td {
+        border-top: 0;
+      }
+
+      tbody tr.total td {
+        border-top: 3px double #666;
+        font-weight: bold;
+      }
+    }
+  }
+
+  &__footer{
+    font-size: 12px;
+  }
+  &__conditions,
+  &__notes {
+
+    h3 {
+      color: #666;
+      font-size: 12px;
+      margin-top: 0;
+      margin-bottom: 10px;
+    }
+    p {
+      margin: 0 0 20px;
+    }
+  }
+}
\ No newline at end of file
diff --git a/packages/server/resources/scss/modules/invoice.scss b/packages/server/resources/scss/modules/invoice.scss
new file mode 100644
index 000000000..98d8dd1a7
--- /dev/null
+++ b/packages/server/resources/scss/modules/invoice.scss
@@ -0,0 +1,179 @@
+@import "../layouts/paper-layout.scss";
+
+.invoice {
+  text-align: left;
+  padding: 45px 40px;
+
+  &__header {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    margin: 0 0 30px;
+
+    .organization {
+      .title {
+        margin: 0 0 4px;
+      }
+      .invoiceNo {
+        font-size: 12px;
+      }
+    }
+
+    .paper {
+
+      .title {
+        font-weight: 400;
+        text-transform: uppercase;
+        margin: 0 0 2px;
+        font-size: 32px;
+        line-height: 1;
+      }
+    }
+  }
+
+  &__meta {
+    display: flex;
+    flex-direction: column;
+    margin-bottom: 20px;
+    font-size: 13px;
+
+    &-item {
+      padding-right: 10px;
+      font-weight: 400;
+      margin-bottom: 10px;
+      display: flex;
+      flex-direction: row;
+
+      .value {
+        color: #000;
+      }
+
+      .label {
+        color: #444;
+        margin-bottom: 2px;
+        width: 180px;
+      }
+    }
+  }
+
+  &__table {
+    display: flex;
+    flex-direction: column;
+
+    table {
+      font-size: 12px;
+      color: #000;
+      text-align: left;
+      border-spacing: 0;
+
+      thead th,
+      tbody tr td {
+        margin-bottom: 15px;
+        background: transparent;
+      }
+
+      thead th {
+        font-weight: 400;
+        border-bottom: none;
+        padding: 8px;
+        color: #fff;
+        background-color: #333;
+      }
+      tbody tr td {
+        padding: 8px;
+        border-bottom: 1px solid #cecbcb;
+      }
+
+      thead tr th,
+      tbody tr td {
+        &.item {
+          width: 45%;
+        }
+        &.rate {
+          width: 18%;
+          text-align: right;
+        }
+        &.quantity {
+          width: 16%;
+          text-align: right;
+        }
+        &.total {
+          width: 21%;
+          text-align: right;
+        }
+      }
+      .description {
+        color: #666;
+      }
+    }
+  }
+
+  &__table-after{
+    display: flex;
+  }
+  &__table-total {
+    margin-bottom: 20px;
+    width: 50%;
+    float: right;
+    margin-left: auto;
+
+    table {
+      border-spacing: 0;
+      width: 100%;
+      font-size: 12px;
+
+      tbody tr td {
+        padding: 8px 10px 8px 0;
+        border-top: 1px solid #d5d5d5;
+
+        &:last-child {
+          width: 140px;
+          text-align: right;
+        }
+      }
+      tbody tr:first-child td {
+        border-top: 0;
+      }
+      tbody tr.payment-amount td:last-child {
+        color: red
+      }
+      tbody tr.blanace-due td {
+        border-top: 3px double #666;
+        font-weight: bold;
+      }
+    }
+  }
+
+  &__due-amount {
+    margin-bottom: 18px;
+
+    .label {
+      font-size: 12px;
+    }
+    .amount {
+      font-size: 18px;
+      font-weight: 800;
+    }
+  }
+
+  &__footer{
+    font-size: 12px;
+  }
+
+  &__conditions,
+  &__notes {
+
+    h3 {
+      color: #666;
+      font-size: 12px;
+      margin-top: 0;
+      margin-bottom: 10px;
+    }
+    p{
+      margin: 0;
+    }
+  }
+  &__conditions + &__notes{
+    margin-top: 20px;
+  }
+}
\ No newline at end of file
diff --git a/packages/server/resources/scss/modules/payment.scss b/packages/server/resources/scss/modules/payment.scss
new file mode 100644
index 000000000..7408ee44c
--- /dev/null
+++ b/packages/server/resources/scss/modules/payment.scss
@@ -0,0 +1,178 @@
+@import "../layouts/paper-layout.scss";
+
+.payment {
+  text-align: left;
+  padding: 45px 40px;
+
+  &__header {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    margin: 0 0 30px;
+
+    .organization {
+      .title {
+        margin: 0 0 4px;
+      }
+      .paymentNumber {
+        font-size: 12px;
+      }
+    }
+
+    .paper {
+
+      .title {
+        font-weight: 400;
+        text-transform: uppercase;
+        margin: 0 0 2px;
+        font-size: 32px;
+        line-height: 1;
+      }
+    }
+  }
+
+  &__meta {
+    display: flex;
+    flex-direction: column;
+    margin-bottom: 20px;
+    font-size: 13px;
+
+    &-item {
+      padding-right: 10px;
+      font-weight: 400;
+      margin-bottom: 10px;
+      display: flex;
+      flex-direction: row;
+
+      .value {
+        color: #000;
+      }
+
+      .label {
+        color: #444;
+        margin-bottom: 2px;
+        width: 180px;
+      }
+    }
+  }
+
+  &__table {
+    display: flex;
+    flex-direction: column;
+
+    table {
+      font-size: 12px;
+      color: #000;
+      text-align: left;
+      border-spacing: 0;
+
+      thead th,
+      tbody tr td {
+        margin-bottom: 15px;
+        background: transparent;
+      }
+
+      thead th {
+        font-weight: 400;
+        border-bottom: none;
+        padding: 8px;
+        color: #fff;
+        background-color: #333;
+      }
+      tbody tr td {
+        padding: 8px;
+        border-bottom: 1px solid #cecbcb;
+      }
+
+      thead tr th,
+      tbody tr td {
+        &.item {
+          width: 34%;
+        }
+        &.date {
+          width: 22%;
+          text-align: right;
+        }
+        &.invoiceAmount {
+          width: 22%;
+          text-align: right;
+        }
+        &.paymentAmount {
+          width: 22%;
+          text-align: right;
+        }
+      }
+      .description {
+        color: #666;
+      }
+    }
+  }
+
+  &__table-after{
+    display: flex;
+  }
+  &__table-total {
+    margin-bottom: 20px;
+    width: 50%;
+    float: right;
+    margin-left: auto;
+
+    table {
+      border-spacing: 0;
+      width: 100%;
+      font-size: 12px;
+
+      tbody tr td {
+        padding: 8px 10px 8px 0;
+        border-top: 1px solid #d5d5d5;
+
+        &:last-child {
+          width: 140px;
+          text-align: right;
+        }
+      }
+      tbody tr:first-child td {
+        border-top: 0;
+      }
+      tbody tr.payment-amount td:last-child {
+        color: red
+      }
+      tbody tr.blanace-due td {
+        border-top: 3px double #666;
+        font-weight: bold;
+      }
+    }
+  }
+
+  &__received-amount {
+    margin-bottom: 18px;
+
+    .label {
+      font-size: 12px;
+    }
+    .amount {
+      font-size: 18px;
+      font-weight: 800;
+    }
+  }
+
+  &__footer{
+    font-size: 12px;
+  }
+  &__conditions,
+  &__notes {
+
+    h3 {
+      color: #666;
+      font-size: 12px;
+      margin-top: 0;
+      margin-bottom: 10px;
+    }
+    p{
+      margin: 0;
+    }
+  }
+  &__conditions + &__notes{
+    margin-top: 20px;
+  }
+}
\ No newline at end of file
diff --git a/packages/server/resources/scss/modules/receipt.scss b/packages/server/resources/scss/modules/receipt.scss
new file mode 100644
index 000000000..a5981fc84
--- /dev/null
+++ b/packages/server/resources/scss/modules/receipt.scss
@@ -0,0 +1,185 @@
+@import "../layouts/paper-layout.scss";
+
+.receipt {
+  text-align: left;
+  padding: 45px;
+
+  &__header {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    margin: 0 0 30px;
+
+    .organization {
+
+      .title {
+        margin: 0 0 4px;
+      }
+
+      .receiptNumber {
+        margin: 0 0 12px;
+      }
+    }
+
+    .paper {
+
+      .title {
+        font-weight: 400;
+        text-transform: uppercase;
+        margin: 0 0 2px;
+        font-size: 32px;
+        line-height: 1;
+      }
+    }
+  }
+
+
+  &__receipt-amount {
+    margin-bottom: 18px;
+
+    .label {
+      font-size: 12px;
+    }
+    .amount {
+      font-size: 18px;
+      font-weight: 800;
+    }
+  }
+
+  &__meta {
+    display: flex;
+    flex-direction: column;
+    margin-bottom: 20px;
+    font-size: 13px;
+
+    &-item {
+      padding-right: 10px;
+      margin-bottom: 10px;
+      display: flex;
+      flex-direction: row;
+
+      .value {
+        color: #000;
+      }
+
+      .label {
+        color: #444;
+        margin-bottom: 2px;
+        width: 180px;
+      }
+    }
+  }
+
+  &__table {
+    display: flex;
+    flex-direction: column;
+
+    table {
+      font-size: 12px;
+      color: #000;
+      text-align: left;
+      border-spacing: 0;
+
+      thead th,
+      tbody tr td {
+        margin-bottom: 15px;
+        background: transparent;
+      }
+
+      thead th {
+        font-weight: 400;
+        border-bottom: none;
+        padding: 8px;
+        color: #fff;
+        background-color: #333;
+      }
+
+      tbody tr td {
+        padding: 10px;
+        border-bottom: 1px solid #cecbcb;
+      }
+
+      thead tr th,
+      tbody tr td {
+        &.item {
+          width: 45%;
+        }
+
+        &.rate {
+          width: 18%;
+          text-align: right;
+        }
+
+        &.quantity {
+          width: 16%;
+          text-align: right;
+        }
+
+        &.total {
+          width: 21%;
+          text-align: right;
+        }
+      }
+    }
+  }
+
+  &__table-after {
+    display: flex;
+  }
+
+  &__table-total {
+    margin-bottom: 20px;
+    width: 50%;
+    float: right;
+    margin-left: auto;
+
+    table {
+      border-spacing: 0;
+      width: 100%;
+      font-size: 12px;
+
+      tbody tr td {
+        padding: 8px 10px 8px 0;
+        border-top: 1px solid #d5d5d5;
+
+        &:last-child {
+          width: 140px;
+          text-align: right;
+        }
+      }
+
+      tbody tr:first-child td {
+        border-top: 0;
+      }
+
+      tbody tr.payment-amount td:last-child {
+        color: red
+      }
+
+      tbody tr.blanace-due td {
+        border-top: 3px double #666;
+        font-weight: bold;
+      }
+    }
+  }
+
+
+  &__footer {
+    font-size: 12px;
+  }
+
+  &__conditions,
+  &__notes {
+
+    h3 {
+      color: #666;
+      font-size: 12px;
+      margin-top: 0;
+      margin-bottom: 10px;
+    }
+
+    p {
+      margin: 0 0 20px;
+    }
+  }
+}
\ No newline at end of file
diff --git a/packages/server/resources/scss/normalize.scss b/packages/server/resources/scss/normalize.scss
new file mode 100644
index 000000000..5096fd90f
--- /dev/null
+++ b/packages/server/resources/scss/normalize.scss
@@ -0,0 +1,379 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+
+/* Document
+   ========================================================================== */
+
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+
+html {
+  line-height: 1.15;
+  /* 1 */
+  -webkit-text-size-adjust: 100%;
+  /* 2 */
+}
+
+/* Sections
+     ========================================================================== */
+
+/**
+   * Remove the margin in all browsers.
+   */
+
+body {
+  margin: 0;
+}
+
+/**
+   * Render the `main` element consistently in IE.
+   */
+
+main {
+  display: block;
+}
+
+/**
+   * Correct the font size and margin on `h1` elements within `section` and
+   * `article` contexts in Chrome, Firefox, and Safari.
+   */
+
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+/* Grouping content
+     ========================================================================== */
+
+/**
+   * 1. Add the correct box sizing in Firefox.
+   * 2. Show the overflow in Edge and IE.
+   */
+
+hr {
+  box-sizing: content-box;
+  /* 1 */
+  height: 0;
+  /* 1 */
+  overflow: visible;
+  /* 2 */
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+
+pre {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/* Text-level semantics
+     ========================================================================== */
+
+/**
+   * Remove the gray background on active links in IE 10.
+   */
+
+a {
+  background-color: transparent;
+}
+
+/**
+   * 1. Remove the bottom border in Chrome 57-
+   * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+   */
+
+abbr[title] {
+  border-bottom: none;
+  /* 1 */
+  text-decoration: underline;
+  /* 2 */
+  text-decoration: underline dotted;
+  /* 2 */
+}
+
+/**
+   * Add the correct font weight in Chrome, Edge, and Safari.
+   */
+
+b,
+strong {
+  font-weight: bolder;
+}
+
+/**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+
+code,
+kbd,
+samp {
+  font-family: monospace, monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/**
+   * Add the correct font size in all browsers.
+   */
+
+small {
+  font-size: 80%;
+}
+
+/**
+   * Prevent `sub` and `sup` elements from affecting the line height in
+   * all browsers.
+   */
+
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/* Embedded content
+     ========================================================================== */
+
+/**
+   * Remove the border on images inside links in IE 10.
+   */
+
+img {
+  border-style: none;
+}
+
+/* Forms
+     ========================================================================== */
+
+/**
+   * 1. Change the font styles in all browsers.
+   * 2. Remove the margin in Firefox and Safari.
+   */
+
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+  /* 1 */
+  font-size: 100%;
+  /* 1 */
+  line-height: 1.15;
+  /* 1 */
+  margin: 0;
+  /* 2 */
+}
+
+/**
+   * Show the overflow in IE.
+   * 1. Show the overflow in Edge.
+   */
+
+button,
+input {
+  /* 1 */
+  overflow: visible;
+}
+
+/**
+   * Remove the inheritance of text transform in Edge, Firefox, and IE.
+   * 1. Remove the inheritance of text transform in Firefox.
+   */
+
+button,
+select {
+  /* 1 */
+  text-transform: none;
+}
+
+/**
+   * Correct the inability to style clickable types in iOS and Safari.
+   */
+
+button,
+[type="button"],
+[type="reset"],
+[type="submit"] {
+  -webkit-appearance: button;
+}
+
+/**
+   * Remove the inner border and padding in Firefox.
+   */
+
+button::-moz-focus-inner,
+[type="button"]::-moz-focus-inner,
+[type="reset"]::-moz-focus-inner,
+[type="submit"]::-moz-focus-inner {
+  border-style: none;
+  padding: 0;
+}
+
+/**
+   * Restore the focus styles unset by the previous rule.
+   */
+
+button:-moz-focusring,
+[type="button"]:-moz-focusring,
+[type="reset"]:-moz-focusring,
+[type="submit"]:-moz-focusring {
+  outline: 1px dotted ButtonText;
+}
+
+/**
+   * Correct the padding in Firefox.
+   */
+
+fieldset {
+  padding: 0.35em 0.75em 0.625em;
+}
+
+/**
+   * 1. Correct the text wrapping in Edge and IE.
+   * 2. Correct the color inheritance from `fieldset` elements in IE.
+   * 3. Remove the padding so developers are not caught out when they zero out
+   *    `fieldset` elements in all browsers.
+   */
+
+legend {
+  box-sizing: border-box;
+  /* 1 */
+  color: inherit;
+  /* 2 */
+  display: table;
+  /* 1 */
+  max-width: 100%;
+  /* 1 */
+  padding: 0;
+  /* 3 */
+  white-space: normal;
+  /* 1 */
+}
+
+/**
+   * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+   */
+
+progress {
+  vertical-align: baseline;
+}
+
+/**
+   * Remove the default vertical scrollbar in IE 10+.
+   */
+
+textarea {
+  overflow: auto;
+}
+
+/**
+   * 1. Add the correct box sizing in IE 10.
+   * 2. Remove the padding in IE 10.
+   */
+
+[type="checkbox"],
+[type="radio"] {
+  box-sizing: border-box;
+  /* 1 */
+  padding: 0;
+  /* 2 */
+}
+
+/**
+   * Correct the cursor style of increment and decrement buttons in Chrome.
+   */
+
+[type="number"]::-webkit-inner-spin-button,
+[type="number"]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/**
+   * 1. Correct the odd appearance in Chrome and Safari.
+   * 2. Correct the outline style in Safari.
+   */
+
+[type="search"] {
+  -webkit-appearance: textfield;
+  /* 1 */
+  outline-offset: -2px;
+  /* 2 */
+}
+
+/**
+   * Remove the inner padding in Chrome and Safari on macOS.
+   */
+
+[type="search"]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/**
+   * 1. Correct the inability to style clickable types in iOS and Safari.
+   * 2. Change font properties to `inherit` in Safari.
+   */
+
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  /* 1 */
+  font: inherit;
+  /* 2 */
+}
+
+/* Interactive
+     ========================================================================== */
+
+/*
+   * Add the correct display in Edge, IE 10+, and Firefox.
+   */
+
+details {
+  display: block;
+}
+
+/*
+   * Add the correct display in all browsers.
+   */
+
+summary {
+  display: list-item;
+}
+
+/* Misc
+     ========================================================================== */
+
+/**
+   * Add the correct display in IE 10+.
+   */
+
+template {
+  display: none;
+}
+
+/**
+   * Add the correct display in IE 10.
+   */
+
+[hidden] {
+  display: none;
+}
\ No newline at end of file
diff --git a/packages/server/resources/views/PaperTemplateLayout.pug b/packages/server/resources/views/PaperTemplateLayout.pug
new file mode 100644
index 000000000..4678ae166
--- /dev/null
+++ b/packages/server/resources/views/PaperTemplateLayout.pug
@@ -0,0 +1,7 @@
+html(lang=locale)
+  head
+    title My Site - #{title}
+    block head
+  body
+    div.paper-template
+      block content
\ No newline at end of file
diff --git a/packages/server/resources/views/modules/credit-note-regular.pug b/packages/server/resources/views/modules/credit-note-regular.pug
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/server/resources/views/modules/credit-note-standard.pug b/packages/server/resources/views/modules/credit-note-standard.pug
new file mode 100644
index 000000000..8f9367a6b
--- /dev/null
+++ b/packages/server/resources/views/modules/credit-note-standard.pug
@@ -0,0 +1,81 @@
+extends ../PaperTemplateLayout.pug
+
+block head 
+  style
+    if (isRtl)
+      include ../../css/modules/credit-rtl.css
+    else
+      include ../../css/modules/credit.css
+
+block content
+ div.credit
+  div.credit__header
+    div.paper
+      h1.title #{__('credit.paper.credit_note')}
+      if creditNote.creditNoteNumber
+       span.creditNoteNumber #{creditNote.creditNoteNumber}
+
+    div.organization
+      h3.title #{organizationName}
+      if organizationEmail
+       span.email #{organizationEmail}
+
+  div.credit__full-amount
+    div.label #{__('credit.paper.amount')}
+    div.amount #{creditNote.formattedAmount}
+
+  div.credit__meta
+   div.credit__meta-item.credit__meta-item--amount
+    span.label #{__('credit.paper.remaining')}
+    span.value #{creditNote.formattedCreditsRemaining}
+
+   div.credit__meta-item.credit__meta-item--billed-to
+    span.label #{__("credit.paper.billed_to")}
+    span.value #{creditNote.customer.displayName}
+
+   div.credit__meta-item.credit__meta-item--credit-date
+    span.label #{__("credit.paper.credit_date")}
+    span.value #{creditNote.formattedCreditNoteDate}
+
+  div.credit__table
+   table 
+    thead 
+     tr
+       th.item #{__("item_entry.paper.item_name")}
+       th.rate #{__("item_entry.paper.rate")}
+       th.quantity #{__("item_entry.paper.quantity")}
+       th.total #{__("item_entry.paper.total")}
+    tbody
+      each entry in creditNote.entries
+       tr
+        td.item
+         div.title=entry.item.name
+         span.description=entry.description
+        td.rate=entry.rate
+        td.quantity=entry.quantity
+        td.total=entry.amount
+
+  div.credit__table-after
+    div.credit__table-total
+      table 
+        tbody
+          tr.total
+            td #{__('credit.paper.total')}
+            td #{creditNote.formattedAmount}
+          tr.payment-amount
+            td #{__('credit.paper.credits_used')}
+            td #{creditNote.formattedCreditsUsed}
+          tr.blanace-due
+            td #{__('credit.paper.credits_remaining')}
+            td #{creditNote.formattedCreditsRemaining}
+
+  div.credit__footer        
+    if creditNote.termsConditions
+     div.credit__conditions
+      h3 #{__("credit.paper.terms_conditions")}
+      p #{creditNote.termsConditions}
+
+    if creditNote.note
+     div.credit__notes
+      h3 #{__("credit.paper.notes")}
+      p #{creditNote.note}
\ No newline at end of file
diff --git a/packages/server/resources/views/modules/estimate-regular.pug b/packages/server/resources/views/modules/estimate-regular.pug
new file mode 100644
index 000000000..37cf85bfa
--- /dev/null
+++ b/packages/server/resources/views/modules/estimate-regular.pug
@@ -0,0 +1,82 @@
+extends ../PaperTemplateLayout.pug
+
+block head 
+  style
+    if (isRtl)
+      include ../../css/modules/estimate-rtl.css
+    else
+      include ../../css/modules/estimate.css
+
+block content 
+ div.estimate
+  div.estimate__header
+    div.paper
+      h1.title #{__("estimate.paper.estimate")}
+      span.email #{saleEstimate.estimateNumber}
+
+    div.organization 
+      h3.title #{organizationName}
+      if organizationEmail
+       span.email #{organizationEmail}
+
+  div.estimate__estimate-amount
+    div.label #{__('estimate.paper.estimate_amount')}
+    div.amount #{saleEstimate.formattedAmount}
+
+  div.estimate__meta
+    if saleEstimate.estimateNumber
+      div.estimate__meta-item.estimate__meta-item--estimate-number
+        span.label #{__("estimate.paper.estimate_number")}
+        span.value #{saleEstimate.estimateNumber}
+
+    div.estimate__meta-item.estimate__meta-item--billed-to
+      span.label #{__("estimate.paper.billed_to")}
+      span.value #{saleEstimate.customer.displayName}
+
+    div.estimate__meta-item.estimate__meta-item--estimate-date
+      span.label #{__("estimate.paper.estimate_date")}
+      span.value #{saleEstimate.formattedEstimateDate}
+
+    div.estimate__meta-item.estimate__meta-item--due-date
+      span.label #{__("estimate.paper.expiration_date")}
+      span.value #{saleEstimate.formattedExpirationDate}
+
+  div.estimate__table
+   table 
+     thead 
+      tr
+        th.item #{__("item_entry.paper.item_name")}
+        th.rate #{__("item_entry.paper.rate")}
+        th.quantity #{__("item_entry.paper.quantity")}
+        th.total #{__("item_entry.paper.total")}
+      tbody
+        each entry in saleEstimate.entries
+         tr
+           td.item
+            div.title=entry.item.name
+            span.description=entry.description
+           td.rate=entry.rate
+           td.quantity=entry.quantity
+           td.total=entry.amount
+
+  div.estimate__table-after
+    div.estimate__table-total 
+      table
+        tbody
+          tr.subtotal 
+            td #{__('estimate.paper.subtotal')}
+            td #{saleEstimate.formattedAmount}
+          tr.total 
+            td #{__('estimate.paper.total')}
+            td #{saleEstimate.formattedAmount}
+
+  div.estimate__footer
+    if saleEstimate.termsConditions
+      div.estimate__conditions
+        h3 #{__("estimate.paper.conditions_title")}
+        p #{saleEstimate.termsConditions}
+
+    if saleEstimate.note
+      div.estimate__notes
+        h3 #{__("estimate.paper.notes_title")}
+        p #{saleEstimate.note}
\ No newline at end of file
diff --git a/packages/server/resources/views/modules/invoice-regular.pug b/packages/server/resources/views/modules/invoice-regular.pug
new file mode 100644
index 000000000..00416b97c
--- /dev/null
+++ b/packages/server/resources/views/modules/invoice-regular.pug
@@ -0,0 +1,85 @@
+extends ../PaperTemplateLayout.pug
+
+block head
+  style
+    if (isRtl)
+      include ../../css/modules/invoice-rtl.css
+    else
+      include ../../css/modules/invoice.css
+
+block content 
+ div.invoice
+  div.invoice__header
+    div.paper
+      h1.title #{__("invoice.paper.invoice")}
+      if saleInvoice.invoiceNo
+       span.invoiceNo #{saleInvoice.invoiceNo}
+
+    div.organization
+      h3.title #{organizationName}
+      if organizationEmail
+       span.email #{organizationEmail}
+
+  div.invoice__due-amount
+    div.label #{__('invoice.paper.invoice_amount')}
+    div.amount #{saleInvoice.formattedAmount}
+
+  div.invoice__meta
+   div.invoice__meta-item.invoice__meta-item--amount
+    span.label #{__('invoice.paper.due_amount')}
+    span.value #{saleInvoice.formattedDueAmount}
+
+   div.invoice__meta-item.invoice__meta-item--billed-to
+    span.label #{__("invoice.paper.billed_to")}
+    span.value #{saleInvoice.customer.displayName}
+
+   div.invoice__meta-item.invoice__meta-item--invoice-date
+    span.label #{__("invoice.paper.invoice_date")}
+    span.value #{saleInvoice.formattedInvoiceDate}
+
+   div.invoice__meta-item.invoice__meta-item--due-date
+    span.label #{__("invoice.paper.due_date")}
+    span.value #{saleInvoice.formattedDueDate}
+
+  div.invoice__table
+   table 
+    thead 
+     tr
+       th.item #{__("item_entry.paper.item_name")}
+       th.rate #{__("item_entry.paper.rate")}
+       th.quantity #{__("item_entry.paper.quantity")}
+       th.total #{__("item_entry.paper.total")}
+    tbody
+      each entry in saleInvoice.entries
+       tr
+        td.item
+         div.title=entry.item.name
+         span.description=entry.description
+        td.rate=entry.rate
+        td.quantity=entry.quantity
+        td.total=entry.amount
+
+  div.invoice__table-after
+    div.invoice__table-total
+      table 
+        tbody
+          tr.total
+            td #{__('invoice.paper.total')}
+            td #{saleInvoice.formattedAmount}
+          tr.payment-amount
+            td #{__('invoice.paper.payment_amount')}
+            td #{saleInvoice.formattedPaymentAmount}
+          tr.blanace-due
+            td #{__('invoice.paper.balance_due')}
+            td #{saleInvoice.formattedDueAmount}
+
+  div.invoice__footer        
+    if saleInvoice.termsConditions
+     div.invoice__conditions
+      h3 #{__("invoice.paper.conditions_title")}
+      p #{saleInvoice.termsConditions}
+
+    if saleInvoice.invoiceMessage
+     div.invoice__notes
+      h3 #{__("invoice.paper.notes_title")}
+      p #{saleInvoice.invoiceMessage}
\ No newline at end of file
diff --git a/packages/server/resources/views/modules/payment-receipt-regular.pug b/packages/server/resources/views/modules/payment-receipt-regular.pug
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/server/resources/views/modules/payment-receive-standard.pug b/packages/server/resources/views/modules/payment-receive-standard.pug
new file mode 100644
index 000000000..b3aa1fe26
--- /dev/null
+++ b/packages/server/resources/views/modules/payment-receive-standard.pug
@@ -0,0 +1,67 @@
+extends ../PaperTemplateLayout.pug
+
+block head
+  style
+    if (isRtl)
+      include ../../css/modules/payment-rtl.css
+    else
+      include ../../css/modules/payment.css
+
+block content
+ div.payment
+  div.payment__header
+    div.paper
+      h1.title #{__("payment.paper.payment_receipt")}
+      if paymentReceive.paymentReceiveNo
+       span.paymentNumber #{paymentReceive.paymentReceiveNo}
+
+    div.organization
+      h3.title #{organizationName}
+      if organizationEmail
+       span.email #{organizationEmail}
+
+  div.payment__received-amount
+    div.label #{__('payment.paper.amount_received')}
+    div.amount #{paymentReceive.formattedAmount}
+
+  div.payment__meta
+   div.payment__meta-item.payment__meta-item--billed-to
+    span.label #{__("payment.paper.billed_to")}
+    span.value #{paymentReceive.customer.displayName}
+
+   div.payment__meta-item.payment__meta-item--payment-date
+    span.label #{__("payment.paper.payment_date")}
+    span.value #{paymentReceive.formattedPaymentDate}
+
+  div.payment__table
+   table 
+    thead 
+     tr
+       th.item #{__("payment.paper.invoice_number")}
+       th.date #{__("payment.paper.invoice_date")}
+       th.invoiceAmount #{__("payment.paper.invoice_amount")}
+       th.paymentAmount #{__("payment.paper.payment_amount")}
+    tbody
+      each entry in paymentReceive.entries
+       tr
+        td.item=entry.invoice.invoiceNo
+        td.date=entry.invoice.formattedInvoiceDate
+        td.invoiceAmount=entry.invoice.formattedAmount
+        td.paymentAmount=entry.invoice.formattedPaymentAmount
+
+  div.payment__table-after
+    div.payment__table-total
+      table
+        tbody
+          tr.payment-amount
+            td #{__('payment.paper.payment_amount')}
+            td #{paymentReceive.formattedAmount}
+          tr.blanace-due
+            td #{__('payment.paper.balance_due')}
+            td #{paymentReceive.customer.closingBalance}
+
+  div.payment__footer
+    if paymentReceive.statement
+     div.payment__notes
+      h3 #{__("payment.paper.statement")}
+      p #{paymentReceive.statement}
\ No newline at end of file
diff --git a/packages/server/resources/views/modules/purchase-invoice-regular.pug b/packages/server/resources/views/modules/purchase-invoice-regular.pug
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/server/resources/views/modules/receipt-regular.pug b/packages/server/resources/views/modules/receipt-regular.pug
new file mode 100644
index 000000000..a0cbb1f61
--- /dev/null
+++ b/packages/server/resources/views/modules/receipt-regular.pug
@@ -0,0 +1,77 @@
+extends ../PaperTemplateLayout.pug
+
+block head 
+  style
+    if (isRtl)
+      include ../../css/modules/receipt-rtl.css
+    else
+      include ../../css/modules/receipt.css
+
+block content 
+ div.receipt
+  div.receipt__header
+    div.paper
+      h1.title #{__("receipt.paper.receipt")}
+      span.receiptNumber #{saleReceipt.receiptNumber}
+
+    div.organization
+      h3.title #{organizationName}
+
+  div.receipt__receipt-amount
+    div.label #{__('receipt.paper.receipt_amount')}
+    div.amount #{saleReceipt.formattedAmount}
+
+  div.receipt__meta
+   div.receipt__meta-item.receipt__meta-item--billed-to
+    span.label #{__("receipt.paper.billed_to")}
+    span.value #{saleReceipt.customer.displayName}
+
+   div.receipt__meta-item.receipt__meta-item--invoice-date
+    span.label #{__("receipt.paper.receipt_date")}
+    span.value #{saleReceipt.formattedReceiptDate}
+
+   if saleReceipt.receiptNumber
+    div.receipt__meta-item.receipt__meta-item--invoice-number
+     span.label #{__("receipt.paper.receipt_number")}
+     span.value #{saleReceipt.receiptNumber}
+
+  div.receipt__table
+   table 
+    thead 
+     tr
+      th.item #{__("item_entry.paper.item_name")}
+      th.rate #{__("item_entry.paper.rate")}
+      th.quantity #{__("item_entry.paper.quantity")}
+      th.total #{__("item_entry.paper.total")}
+     tbody
+      each entry in saleReceipt.entries
+       tr
+        td.item=entry.item.name
+        td.rate=entry.rate
+        td.quantity=entry.quantity
+        td.total=entry.amount
+ 
+  div.receipt__table-after
+    div.receipt__table-total
+      table 
+        tbody
+          tr.total
+            td #{__('receipt.paper.total')}
+            td #{saleReceipt.formattedAmount}
+          tr.payment-amount
+            td #{__('receipt.paper.payment_amount')}
+            td #{saleReceipt.formattedAmount}
+          tr.blanace-due
+            td #{__('receipt.paper.balance_due')}
+            td #{'$0'}
+
+  div.receipt__footer
+    if saleReceipt.statement
+      div.receipt__conditions
+        h3 #{__("receipt.paper.statement")}
+        p #{saleReceipt.statement}
+
+    if saleReceipt.receiptMessage
+      div.receipt__notes
+        h3 #{__("receipt.paper.notes")}
+        p #{saleReceipt.receiptMessage}
\ No newline at end of file
diff --git a/packages/server/scripts/gulpConfig.js b/packages/server/scripts/gulpConfig.js
new file mode 100644
index 000000000..51bbc3aff
--- /dev/null
+++ b/packages/server/scripts/gulpConfig.js
@@ -0,0 +1,145 @@
+/**
+ * # Gulp Configuration.
+ * ------------------------------------------------------------------
+ */
+
+const RESOURCES_PATH = '../resources/';
+module.exports = {
+  banner: [
+    '/**',
+    ' * <%= pkg.name %> - <%= pkg.description %>',
+    ' * @version v<%= pkg.version %>',
+    ' * @link <%= pkg.homepage %>',
+    ' * @author <%= pkg.author %>',
+    ' * @license <%= pkg.license %>',
+    '**/',
+    '',
+  ].join('\n'),
+
+  // Browser Sync
+  browsersync: {
+    files: ['**/*', '!**.map', '!**.css'], // Exclude map files.
+    notify: false, //
+    open: true, // Set it to false if you don't like the broser window opening automatically.
+    port: 8080, //
+    proxy: 'localhost/customatic', //
+    watchOptions: {
+      debounceDelay: 2000, // This introduces a small delay when watching for file change events to avoid triggering too many reloads
+    },
+    snippetOptions: {
+      whitelist: ['/wp-admin/admin-ajax.php'],
+      blacklist: ['/wp-admin/**'],
+    },
+  },
+
+  // Style Related.
+  style: {
+    clean: ['style.css', 'style.min.css', 'style-rtl.css', 'style-rtl.min.css'],
+    build: [
+      {
+        src: `${RESOURCES_PATH}/scss/modules/invoice.scss`,
+        dest: `${RESOURCES_PATH}/css/modules`,
+        // sourcemaps: true, // Allow to enable/disable sourcemaps or pass object to configure it.
+        // minify: true, // Allow to enable/disable minify the source.
+      },
+      {
+        src: `${RESOURCES_PATH}/scss/modules/estimate.scss`,
+        dest: `${RESOURCES_PATH}/css/modules`,
+        // sourcemaps: true, // Allow to enable/disable sourcemaps or pass object to configure it.
+        // minify: true, // Allow to enable/disable minify the source.
+      },
+      {
+        src: `${RESOURCES_PATH}/scss/modules/receipt.scss`,
+        dest: `${RESOURCES_PATH}/css/modules`,
+        // sourcemaps: true, // Allow to enable/disable sourcemaps or pass object to configure it.
+        // minify: true, // Allow to enable/disable minify the source.
+      },
+      {
+        src: `${RESOURCES_PATH}/scss/modules/credit.scss`,
+        dest: `${RESOURCES_PATH}/css/modules`,
+        // sourcemaps: true, // Allow to enable/disable sourcemaps or pass object to configure it.
+        // minify: true, // Allow to enable/disable minify the source.
+      },
+      {
+        src: `${RESOURCES_PATH}/scss/modules/payment.scss`,
+        dest: `${RESOURCES_PATH}/css/modules`,
+        // sourcemaps: true, // Allow to enable/disable sourcemaps or pass object to configure it.
+        // minify: true, // Allow to enable/disable minify the source.
+      },
+    //   {
+    //     src: './assets/sass/editor-style.scss',
+    //     dest: './assets/css',
+    //     sourcemaps: true,
+    //     minify: true,
+    //   },
+    ],
+    // RTL builds.
+    rtl: [
+      {
+        src: `${RESOURCES_PATH}/css/modules/invoice.css`,
+        dest: `${RESOURCES_PATH}/css/modules`,
+      },
+      {
+        src: `${RESOURCES_PATH}/css/modules/estimate.css`,
+        dest: `${RESOURCES_PATH}/css/modules`,
+      },
+      {
+        src: `${RESOURCES_PATH}/css/modules/receipt.css`,
+        dest: `${RESOURCES_PATH}/css/modules`,
+      },
+      {
+        src: `${RESOURCES_PATH}/css/modules/credit.css`,
+        dest: `${RESOURCES_PATH}/css/modules`,
+      },
+      {
+        src: `${RESOURCES_PATH}/css/modules/payment.css`,
+        dest: `${RESOURCES_PATH}/css/modules`,
+      },
+    ],
+
+    // Browsers you care about for auto-prefixing.
+    autoprefixer: {
+      browsers: [
+        'Android 2.3',
+        'Android >= 4',
+        'Chrome >= 20',
+        'Firefox >= 24',
+        'Explorer >= 9',
+        'iOS >= 6',
+        'Opera >= 12',
+        'Safari >= 6',
+      ],
+    },
+
+    // SASS Configuration for all builds.
+    sass: {
+      errLogToConsole: true,
+    //   outputStyle: 'compact',
+    },
+
+    // CSS MQ Packer configuration for all builds and style tasks.
+    cssMqpacker: {},
+
+    // CSS nano configuration for all builds.
+    cssnano: {},
+
+    // rtlcss configuration for all builds.
+    rtlcss: {},
+  },
+
+  // Clean specific files.
+  clean: [
+    '**/.DS_Store',
+    './assets/js/**/*.min.js',
+    '**/*.map',
+    '**/*.min.css',
+    'assets/js/hypernews.js',
+  ],
+
+  // Watch related.
+  watch: {
+    css: ['./assets/sass/**/*'],
+    js: ['assets/js/**/*.js', '!assets/js/**/*.min.js'],
+    images: ['./assets/images/**/*'],
+  },
+};
diff --git a/packages/server/scripts/gulpfile.js b/packages/server/scripts/gulpfile.js
new file mode 100644
index 000000000..00eb828a5
--- /dev/null
+++ b/packages/server/scripts/gulpfile.js
@@ -0,0 +1,50 @@
+const gulp = require('gulp');
+const sass = require('sass');
+const gulpSass = require('gulp-sass')(sass); // Gulp pluign for Sass compilation.
+const mergeStream = require('merge-stream');
+
+const rename = require('gulp-rename'); // Renames files E.g. style.css -> style.min.css
+
+// Style related.
+const postcss = require('gulp-postcss'); // Transforming styles with JS plugins
+const rtlcss = require('rtlcss'); // Convert LTR CSS to RTL.
+
+const config = require('./gulpConfig');
+
+gulp.task('styles', () => {
+  const builds = config.style.build.map((build) => {
+    return gulp
+      .src(build.src)
+      .pipe(gulpSass(config.style.sass))
+      .pipe(gulp.dest(build.dest));
+  });
+  return mergeStream(builds);
+});
+
+/**
+ * Task: `styles-rtl`
+ *
+ * This task does the following.
+ *  1. Gets the source css files.
+ *  2. Covert LTR CSS to RTL.
+ *  3. Suffix all CSS files to `-rtl`.
+ *  4. Reloads css files via browser sync stream.
+ *  5. Combine matching media queries for `.min.css` version.
+ *  6. Minify all CSS files.
+ *  7. Reload minified css files via browser sync stream.
+ */
+gulp.task('styles-rtl', () => {
+  const builds = config.style.rtl.map((build) => {
+    return gulp
+      .src(build.src)
+      .pipe(
+        postcss([
+          rtlcss(config.style.rtlcss), // Convert LTR CSS to RTL.
+        ]),
+      )
+      .pipe(rename({ suffix: '-rtl' })) // Append "-rtl" to the filename.
+      .pipe(gulp.dest(build.dest));
+  });
+
+  return mergeStream(builds);
+});
diff --git a/packages/server/scripts/install.sh b/packages/server/scripts/install.sh
new file mode 100644
index 000000000..ad899bf99
--- /dev/null
+++ b/packages/server/scripts/install.sh
@@ -0,0 +1,4 @@
+
+npm install
+npm run build
+npm run copy-i18n
\ No newline at end of file
diff --git a/packages/server/scripts/run_test_db.sh b/packages/server/scripts/run_test_db.sh
new file mode 100644
index 000000000..80412012d
--- /dev/null
+++ b/packages/server/scripts/run_test_db.sh
@@ -0,0 +1,31 @@
+MYSQL_USER="ratteb"
+MYSQL_DATABASE="ratteb"
+MYSQL_CONTAINER_NAME="ratteb_test"
+
+MYSQL_ROOT_PASSWORD="root"
+MYSQL_PASSWORD="root"
+
+echo "Start the testing MySql database..."
+
+docker \
+  run \
+    --detach \
+    --env MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD} \
+    --env MYSQL_USER=${MYSQL_USER} \
+    --env MYSQL_PASSWORD=${MYSQL_PASSWORD} \
+    --env MYSQL_DATABASE=${MYSQL_DATABASE} \
+    --name ${MYSQL_CONTAINER_NAME} \
+    --publish 3306:3306 \
+    --tmpfs /var/lib/mysql:rw \
+  mysql:5.7;
+
+echo "Sleeping for 10 seconds to allow time for the DB to be provisioned:"
+for i in `seq 1 10`;
+do
+  echo "."
+  sleep 1
+done
+
+echo "Database '${MYSQL_DATABASE}' running."
+echo "  Username: ${MYSQL_USER}"
+echo "  Password: ${MYSQL_PASSWORD}"
diff --git a/packages/server/scripts/webpack.config.js b/packages/server/scripts/webpack.config.js
new file mode 100644
index 000000000..cdf738bef
--- /dev/null
+++ b/packages/server/scripts/webpack.config.js
@@ -0,0 +1,74 @@
+const path = require('path');
+const { NormalModuleReplacementPlugin } = require('webpack');
+const TsconfigPathsPlugin = require('tsconfig-paths-webpack-plugin');
+const { RunScriptWebpackPlugin } = require('run-script-webpack-plugin');
+const nodeExternals = require('webpack-node-externals');
+const ProgressBarPlugin = require('progress-bar-webpack-plugin');
+
+const isDev = process.env.NODE_ENV === 'development';
+const outputDir = '../build';
+const outputFilename = 'index.js';
+const inputEntry = './src/server.ts';
+
+const webpackOptions = {
+  entry: ['regenerator-runtime/runtime', inputEntry],
+  target: 'node',
+  mode: isDev ? 'development' : 'production',
+  watch: isDev,
+  watchOptions: {
+    aggregateTimeout: 200,
+    poll: 1000,
+  },
+  output: {
+    path: path.resolve(__dirname, outputDir),
+    filename: outputFilename,
+  },
+  resolve: {
+    extensions: ['.ts', '.tsx', '.js'],
+    extensionAlias: {
+      '.ts': ['.js', '.ts'],
+      '.cts': ['.cjs', '.cts'],
+      '.mts': ['.mjs', '.mts'],
+    },
+    plugins: [
+      new TsconfigPathsPlugin({
+        configFile: './tsconfig.json',
+        extensions: ['.ts', '.tsx', '.js'],
+      }),
+    ],
+  },
+  plugins: [
+    // Ignore knex dynamic required dialects that we don't use
+    new NormalModuleReplacementPlugin(
+      /m[sy]sql2?|oracle(db)?|sqlite3|pg-(native|query)/,
+      'noop2'
+    ),
+    new ProgressBarPlugin(),
+  ],
+  externals: [nodeExternals(), 'aws-sdk', 'prettier'],
+  module: {
+    rules: [
+      {
+        test: /\.([cm]?ts|tsx|js)$/,
+        use: [
+          {
+            loader: 'ts-loader',
+            options: {
+              transpileOnly: true,
+              configFile: 'tsconfig.json',
+            },
+          },
+        ],
+        exclude: /(node_modules)/,
+      },
+    ],
+  },
+};
+
+if (isDev) {
+  webpackOptions.plugins.push(
+    new RunScriptWebpackPlugin({ name: outputFilename })
+  );
+}
+
+module.exports = webpackOptions;
diff --git a/packages/server/src/api/controllers/Account/index.ts b/packages/server/src/api/controllers/Account/index.ts
new file mode 100644
index 000000000..15111fe8e
--- /dev/null
+++ b/packages/server/src/api/controllers/Account/index.ts
@@ -0,0 +1,52 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { Service, Inject } from 'typedi';
+import BaseController from '@/api/controllers/BaseController';
+import AuthenticatedAccount from '@/services/AuthenticatedAccount';
+import TenancyMiddleware from '@/api/middleware/TenancyMiddleware';
+import AttachCurrentTenantUser from '@/api/middleware/AttachCurrentTenantUser';
+import JWTAuth from '@/api/middleware/jwtAuth';
+
+@Service()
+export default class AccountController extends BaseController {
+  @Inject()
+  accountService: AuthenticatedAccount;
+
+  /**
+   * Router constructor method.
+   */
+  public router() {
+    const router = Router();
+
+    // Should before build tenant database the user be authorized and
+    // most important than that, should be subscribed to any plan.
+    router.use(JWTAuth);
+    router.use(AttachCurrentTenantUser);
+    router.use(TenancyMiddleware);
+
+    router.get('/', this.getAccount);
+
+    return router;
+  }
+
+  /**
+   * Creates a new account.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  private getAccount = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId, user } = req;
+
+    try {
+      const account = await this.accountService.getAccount(tenantId, user);
+
+      return res.status(200).send({ data: account });
+    } catch (error) {
+      next(error);
+    }
+  };
+}
diff --git a/packages/server/src/api/controllers/AccountTypes.ts b/packages/server/src/api/controllers/AccountTypes.ts
new file mode 100644
index 000000000..a80a2e7df
--- /dev/null
+++ b/packages/server/src/api/controllers/AccountTypes.ts
@@ -0,0 +1,42 @@
+  import { Service, Inject } from 'typedi';
+import { Request, Response, Router, NextFunction } from 'express';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseController from '@/api/controllers/BaseController';
+import AccountsTypesService from '@/services/Accounts/AccountsTypesServices';
+
+@Service()
+export default class AccountsTypesController extends BaseController {
+  @Inject()
+  accountsTypesService: AccountsTypesService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get('/', asyncMiddleware(this.getAccountTypesList.bind(this)));
+
+    return router;
+  }
+
+  /**
+   * Retrieve accounts types list.
+   * @param {Request} req - Request.
+   * @param {Response} res - Response.
+   * @return {Response}
+   */
+  getAccountTypesList(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+
+    try {
+      const accountTypes = this.accountsTypesService.getAccountsTypes(tenantId);
+
+      return res.status(200).send({
+        account_types: this.transfromToResponse(accountTypes, ['label'], req),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/Accounts.ts b/packages/server/src/api/controllers/Accounts.ts
new file mode 100644
index 000000000..94c673293
--- /dev/null
+++ b/packages/server/src/api/controllers/Accounts.ts
@@ -0,0 +1,500 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query } from 'express-validator';
+import { Service, Inject } from 'typedi';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseController from '@/api/controllers/BaseController';
+import { AbilitySubject, AccountAction, IAccountDTO } from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { DATATYPES_LENGTH } from '@/data/DataTypes';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { AccountsApplication } from '@/services/Accounts/AccountsApplication';
+
+@Service()
+export default class AccountsController extends BaseController {
+  @Inject()
+  private accountsApplication: AccountsApplication;
+
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  /**
+   * Router constructor method.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/transactions',
+      CheckPolicies(AccountAction.VIEW, AbilitySubject.Account),
+      [query('account_id').optional().isInt().toInt()],
+      this.asyncMiddleware(this.accountTransactions.bind(this)),
+      this.catchServiceErrors
+    );
+    router.post(
+      '/:id/activate',
+      CheckPolicies(AccountAction.EDIT, AbilitySubject.Account),
+      [...this.accountParamSchema],
+      asyncMiddleware(this.activateAccount.bind(this)),
+      this.catchServiceErrors
+    );
+    router.post(
+      '/:id/inactivate',
+      CheckPolicies(AccountAction.EDIT, AbilitySubject.Account),
+      [...this.accountParamSchema],
+      asyncMiddleware(this.inactivateAccount.bind(this)),
+      this.catchServiceErrors
+    );
+    router.post(
+      '/:id',
+      CheckPolicies(AccountAction.EDIT, AbilitySubject.Account),
+      [...this.editAccountDTOSchema, ...this.accountParamSchema],
+      this.validationResult,
+      asyncMiddleware(this.editAccount.bind(this)),
+      this.catchServiceErrors
+    );
+    router.post(
+      '/',
+      CheckPolicies(AccountAction.CREATE, AbilitySubject.Account),
+      [...this.createAccountDTOSchema],
+      this.validationResult,
+      asyncMiddleware(this.newAccount.bind(this)),
+      this.catchServiceErrors
+    );
+    router.get(
+      '/:id',
+      CheckPolicies(AccountAction.VIEW, AbilitySubject.Account),
+      [...this.accountParamSchema],
+      this.validationResult,
+      asyncMiddleware(this.getAccount.bind(this)),
+      this.catchServiceErrors
+    );
+    router.get(
+      '/',
+      CheckPolicies(AccountAction.VIEW, AbilitySubject.Account),
+      [...this.accountsListSchema],
+      this.validationResult,
+      asyncMiddleware(this.getAccountsList.bind(this)),
+      this.dynamicListService.handlerErrorsToResponse,
+      this.catchServiceErrors
+    );
+    router.delete(
+      '/:id',
+      CheckPolicies(AccountAction.DELETE, AbilitySubject.Account),
+      [...this.accountParamSchema],
+      this.validationResult,
+      asyncMiddleware(this.deleteAccount.bind(this)),
+      this.catchServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Create account DTO Schema validation.
+   */
+  get createAccountDTOSchema() {
+    return [
+      check('name')
+        .exists()
+        .isLength({ min: 3, max: DATATYPES_LENGTH.STRING })
+        .trim()
+        .escape(),
+      check('code')
+        .optional({ nullable: true })
+        .isLength({ min: 3, max: 6 })
+        .trim()
+        .escape(),
+      check('currency_code').optional(),
+      check('account_type')
+        .exists()
+        .isLength({ min: 3, max: DATATYPES_LENGTH.STRING })
+        .trim()
+        .escape(),
+      check('description')
+        .optional({ nullable: true })
+        .isLength({ max: DATATYPES_LENGTH.TEXT })
+        .trim()
+        .escape(),
+      check('parent_account_id')
+        .optional({ nullable: true })
+        .isInt({ min: 0, max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+    ];
+  }
+
+  /**
+   * Account DTO Schema validation.
+   */
+  get editAccountDTOSchema() {
+    return [
+      check('name')
+        .exists()
+        .isLength({ min: 3, max: DATATYPES_LENGTH.STRING })
+        .trim()
+        .escape(),
+      check('code')
+        .optional({ nullable: true })
+        .isLength({ min: 3, max: 6 })
+        .trim()
+        .escape(),
+      check('account_type')
+        .exists()
+        .isLength({ min: 3, max: DATATYPES_LENGTH.STRING })
+        .trim()
+        .escape(),
+      check('description')
+        .optional({ nullable: true })
+        .isLength({ max: DATATYPES_LENGTH.TEXT })
+        .trim()
+        .escape(),
+      check('parent_account_id')
+        .optional({ nullable: true })
+        .isInt({ min: 0, max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+    ];
+  }
+
+  get accountParamSchema() {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  /**
+   * Accounts list validation schema.
+   */
+  get accountsListSchema() {
+    return [
+      query('view_slug').optional({ nullable: true }).isString().trim(),
+      query('stringified_filter_roles').optional().isJSON(),
+
+      query('column_sort_by').optional(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+
+      query('inactive_mode').optional().isBoolean().toBoolean(),
+      query('search_keyword').optional({ nullable: true }).isString().trim(),
+    ];
+  }
+
+  get closingAccountSchema() {
+    return [
+      check('to_account_id').exists().isNumeric().toInt(),
+      check('delete_after_closing').exists().isBoolean(),
+    ];
+  }
+
+  /**
+   * Creates a new account.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  async newAccount(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const accountDTO: IAccountDTO = this.matchedBodyData(req);
+
+    try {
+      const account = await this.accountsApplication.createAccount(
+        tenantId,
+        accountDTO
+      );
+
+      return res.status(200).send({
+        id: account.id,
+        message: 'The account has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Edit account details.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async editAccount(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: accountId } = req.params;
+    const accountDTO: IAccountDTO = this.matchedBodyData(req);
+
+    try {
+      const account = await this.accountsApplication.editAccount(
+        tenantId,
+        accountId,
+        accountDTO
+      );
+
+      return res.status(200).send({
+        id: account.id,
+        message: 'The account has been edited successfully',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Get details of the given account.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async getAccount(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: accountId } = req.params;
+
+    try {
+      const account = await this.accountsApplication.getAccount(
+        tenantId,
+        accountId
+      );
+      return res
+        .status(200)
+        .send({ account: this.transfromToResponse(account) });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Delete the given account.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async deleteAccount(req: Request, res: Response, next: NextFunction) {
+    const { id: accountId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      await this.accountsApplication.deleteAccount(tenantId, accountId);
+
+      return res.status(200).send({
+        id: accountId,
+        message: 'The deleted account has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Activate the given account.
+   * @param {Response} res -
+   * @param {Request} req -
+   * @return {Response}
+   */
+  async activateAccount(req: Request, res: Response, next: Function) {
+    const { id: accountId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      await this.accountsApplication.activateAccount(tenantId, accountId);
+
+      return res.status(200).send({
+        id: accountId,
+        message: 'The account has been activated successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Inactive the given account.
+   * @param {Response} res -
+   * @param {Request} req -
+   * @return {Response}
+   */
+  async inactivateAccount(req: Request, res: Response, next: Function) {
+    const { id: accountId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      await this.accountsApplication.inactivateAccount(tenantId, accountId);
+
+      return res.status(200).send({
+        id: accountId,
+        message: 'The account has been inactivated successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve accounts datatable list.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {Response}
+   */
+  public async getAccountsList(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+
+    // Filter query.
+    const filter = {
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      inactiveMode: false,
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const { accounts, filterMeta } =
+        await this.accountsApplication.getAccounts(tenantId, filter);
+
+      return res.status(200).send({
+        accounts: this.transfromToResponse(accounts, 'accountTypeLabel', req),
+        filter_meta: this.transfromToResponse(filterMeta),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve accounts transactions list.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @returns {Response}
+   */
+  async accountTransactions(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const transactionsFilter = this.matchedQueryData(req);
+
+    try {
+      const transactions =
+        await this.accountsApplication.getAccountsTransactions(
+          tenantId,
+          transactionsFilter
+        );
+      return res.status(200).send({
+        transactions: this.transfromToResponse(transactions),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Transforms service errors to response.
+   * @param {Error}
+   * @param {Request} req
+   * @param {Response} res
+   * @param {ServiceError} error
+   */
+  private catchServiceErrors(
+    error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'account_not_found') {
+        return res.boom.notFound('The given account not found.', {
+          errors: [{ type: 'ACCOUNT.NOT.FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'account_name_not_unqiue') {
+        return res.boom.badRequest('The given account not unique.', {
+          errors: [{ type: 'ACCOUNT.NAME.NOT.UNIQUE', code: 150 }],
+        });
+      }
+      if (error.errorType === 'account_type_not_found') {
+        return res.boom.badRequest('The given account type not found.', {
+          errors: [{ type: 'ACCOUNT_TYPE_NOT_FOUND', code: 200 }],
+        });
+      }
+      if (error.errorType === 'account_type_not_allowed_to_changed') {
+        return res.boom.badRequest(
+          'Not allowed to change account type of the account.',
+          {
+            errors: [{ type: 'NOT.ALLOWED.TO.CHANGE.ACCOUNT.TYPE', code: 300 }],
+          }
+        );
+      }
+      if (error.errorType === 'parent_account_not_found') {
+        return res.boom.badRequest('The parent account not found.', {
+          errors: [{ type: 'PARENT_ACCOUNT_NOT_FOUND', code: 400 }],
+        });
+      }
+      if (error.errorType === 'parent_has_different_type') {
+        return res.boom.badRequest('The parent account has different type.', {
+          errors: [
+            { type: 'PARENT.ACCOUNT.HAS.DIFFERENT.ACCOUNT.TYPE', code: 500 },
+          ],
+        });
+      }
+      if (error.errorType === 'account_code_not_unique') {
+        return res.boom.badRequest('The given account code is not unique.', {
+          errors: [{ type: 'NOT_UNIQUE_CODE', code: 600 }],
+        });
+      }
+      if (error.errorType === 'account_has_associated_transactions') {
+        return res.boom.badRequest(
+          'You could not delete account has associated transactions.',
+          {
+            errors: [
+              { type: 'ACCOUNT.HAS.ASSOCIATED.TRANSACTIONS', code: 800 },
+            ],
+          }
+        );
+      }
+      if (error.errorType === 'account_predefined') {
+        return res.boom.badRequest('You could not delete predefined account', {
+          errors: [{ type: 'ACCOUNT.PREDEFINED', code: 900 }],
+        });
+      }
+      if (error.errorType === 'accounts_not_found') {
+        return res.boom.notFound('Some of the given accounts not found.', {
+          errors: [{ type: 'SOME.ACCOUNTS.NOT_FOUND', code: 1000 }],
+        });
+      }
+      if (error.errorType === 'predefined_accounts') {
+        return res.boom.badRequest(
+          'Some of the given accounts are predefined.',
+          { errors: [{ type: 'ACCOUNTS_PREDEFINED', code: 1100 }] }
+        );
+      }
+      if (error.errorType === 'close_account_and_to_account_not_same_type') {
+        return res.boom.badRequest(
+          'The close account has different root type with to account.',
+          {
+            errors: [
+              {
+                type: 'CLOSE_ACCOUNT_AND_TO_ACCOUNT_NOT_SAME_TYPE',
+                code: 1200,
+              },
+            ],
+          }
+        );
+      }
+      if (error.errorType === 'ACCOUNT_TYPE_NOT_SUPPORTS_MULTI_CURRENCY') {
+        return res.boom.badRequest(
+          'The given account type does not support multi-currency.',
+          {
+            errors: [
+              { type: 'ACCOUNT_TYPE_NOT_SUPPORTS_MULTI_CURRENCY', code: 1300 },
+            ],
+          }
+        );
+      }
+      if (error.errorType === 'ACCOUNT_CURRENCY_NOT_SAME_PARENT_ACCOUNT') {
+        return res.boom.badRequest(
+          'You could not add account has currency different on the parent account.',
+          {
+            errors: [
+              { type: 'ACCOUNT_CURRENCY_NOT_SAME_PARENT_ACCOUNT', code: 1400 },
+            ],
+          }
+        );
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Agendash.ts b/packages/server/src/api/controllers/Agendash.ts
new file mode 100644
index 000000000..810915073
--- /dev/null
+++ b/packages/server/src/api/controllers/Agendash.ts
@@ -0,0 +1,24 @@
+import { Router } from 'express';
+import basicAuth from 'express-basic-auth';
+import agendash from 'agendash';
+import { Container } from 'typedi';
+import config from '@/config';
+
+export default class AgendashController {
+  static router() {
+    const router = Router();
+    const agendaInstance = Container.get('agenda');
+
+    router.use(
+      '/dash',
+      basicAuth({
+        users: {
+          [config.agendash.user]: config.agendash.password,
+        },
+        challenge: true,
+      }),
+      agendash(agendaInstance)
+    );
+    return router;
+  }
+}
diff --git a/packages/server/src/api/controllers/Authentication.ts b/packages/server/src/api/controllers/Authentication.ts
new file mode 100644
index 000000000..dbe5b62a1
--- /dev/null
+++ b/packages/server/src/api/controllers/Authentication.ts
@@ -0,0 +1,314 @@
+import { Request, Response, Router } from 'express';
+import { check, ValidationChain } from 'express-validator';
+import { Service, Inject } from 'typedi';
+import countries from 'country-codes-list';
+import parsePhoneNumber from 'libphonenumber-js';
+import BaseController from '@/api/controllers/BaseController';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import AuthenticationService from '@/services/Authentication';
+import { ILoginDTO, ISystemUser, IRegisterDTO } from '@/interfaces';
+import { ServiceError, ServiceErrors } from '@/exceptions';
+import { DATATYPES_LENGTH } from '@/data/DataTypes';
+import LoginThrottlerMiddleware from '@/api/middleware/LoginThrottlerMiddleware';
+import config from '@/config';
+
+@Service()
+export default class AuthenticationController extends BaseController {
+  @Inject()
+  authService: AuthenticationService;
+
+  /**
+   * Constructor method.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/login',
+      this.loginSchema,
+      this.validationResult,
+      LoginThrottlerMiddleware,
+      asyncMiddleware(this.login.bind(this)),
+      this.handlerErrors
+    );
+    router.post(
+      '/register',
+      this.registerSchema,
+      this.validationResult,
+      asyncMiddleware(this.register.bind(this)),
+      this.handlerErrors
+    );
+    router.post(
+      '/send_reset_password',
+      this.sendResetPasswordSchema,
+      this.validationResult,
+      asyncMiddleware(this.sendResetPassword.bind(this)),
+      this.handlerErrors
+    );
+    router.post(
+      '/reset/:token',
+      this.resetPasswordSchema,
+      this.validationResult,
+      asyncMiddleware(this.resetPassword.bind(this)),
+      this.handlerErrors
+    );
+    return router;
+  }
+
+  /**
+   * Login schema.
+   */
+  get loginSchema(): ValidationChain[] {
+    return [
+      check('crediential').exists().isEmail(),
+      check('password').exists().isLength({ min: 5 }),
+    ];
+  }
+
+  /**
+   * Register schema.
+   */
+  get registerSchema(): ValidationChain[] {
+    return [
+      check('first_name')
+        .exists()
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('last_name')
+        .exists()
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('email')
+        .exists()
+        .isString()
+        .isEmail()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('phone_number')
+        .exists()
+        .isString()
+        .trim()
+        .escape()
+        .custom(this.phoneNumberValidator)
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('password')
+        .exists()
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('country')
+        .exists()
+        .isString()
+        .trim()
+        .escape()
+        .custom(this.countryValidator)
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+    ];
+  }
+
+  /**
+   * Country validator.
+   */
+  countryValidator(value, { req }) {
+    const {
+      countries: { whitelist, blacklist },
+    } = config.registration;
+    const foundCountry = countries.findOne('countryCode', value);
+
+    if (!foundCountry) {
+      throw new Error('The country code is invalid.');
+    }
+    if (
+      // Focus with me! In case whitelist is not empty and the given coutry is not
+      // in whitelist throw the error.
+      //
+      // Or in case the blacklist is not empty and the given country exists
+      // in the blacklist throw the goddamn error.
+      (whitelist.length > 0 && whitelist.indexOf(value) === -1) ||
+      (blacklist.length > 0 && blacklist.indexOf(value) !== -1)
+    ) {
+      throw new Error('The country code is not supported yet.');
+    }
+    return true;
+  }
+
+  /**
+   * Phone number validator.
+   */
+  phoneNumberValidator(value, { req }) {
+    const phoneNumber = parsePhoneNumber(value, req.body.country);
+
+    if (!phoneNumber || !phoneNumber.isValid()) {
+      throw new Error('Phone number is invalid with the given country code.');
+    }
+    return true;
+  }
+
+  /**
+   * Reset password schema.
+   */
+  get resetPasswordSchema(): ValidationChain[] {
+    return [
+      check('password')
+        .exists()
+        .isLength({ min: 5 })
+        .custom((value, { req }) => {
+          if (value !== req.body.confirm_password) {
+            throw new Error("Passwords don't match");
+          } else {
+            return value;
+          }
+        }),
+    ];
+  }
+
+  /**
+   * Send reset password validation schema.
+   */
+  get sendResetPasswordSchema(): ValidationChain[] {
+    return [check('email').exists().isEmail().trim().escape()];
+  }
+
+  /**
+   * Handle user login.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async login(req: Request, res: Response, next: Function): Response {
+    const userDTO: ILoginDTO = this.matchedBodyData(req);
+
+    try {
+      const { token, user, tenant } = await this.authService.signIn(
+        userDTO.crediential,
+        userDTO.password
+      );
+      return res.status(200).send({ token, user, tenant });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Organization register handler.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async register(req: Request, res: Response, next: Function) {
+    const registerDTO: IRegisterDTO = this.matchedBodyData(req);
+
+    try {
+      const registeredUser: ISystemUser = await this.authService.register(
+        registerDTO
+      );
+
+      return res.status(200).send({
+        type: 'success',
+        code: 'REGISTER.SUCCESS',
+        message: 'Register organization has been success.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Send reset password handler
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async sendResetPassword(req: Request, res: Response, next: Function) {
+    const { email } = this.matchedBodyData(req);
+
+    try {
+      await this.authService.sendResetPassword(email);
+
+      return res.status(200).send({
+        code: 'SEND_RESET_PASSWORD_SUCCESS',
+        message: 'The reset password message has been sent successfully.',
+      });
+    } catch (error) {
+      if (error instanceof ServiceError) {
+      }
+      next(error);
+    }
+  }
+
+  /**
+   * Reset password handler
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async resetPassword(req: Request, res: Response, next: Function) {
+    const { token } = req.params;
+    const { password } = req.body;
+
+    try {
+      await this.authService.resetPassword(token, password);
+
+      return res.status(200).send({
+        type: 'RESET_PASSWORD_SUCCESS',
+        message: 'The password has been reset successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handles the service errors.
+   */
+  handlerErrors(error, req: Request, res: Response, next: Function) {
+    if (error instanceof ServiceError) {
+      if (
+        ['INVALID_DETAILS', 'invalid_password'].indexOf(error.errorType) !== -1
+      ) {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'INVALID_DETAILS', code: 100 }],
+        });
+      }
+      if (error.errorType === 'USER_INACTIVE') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'USER_INACTIVE', code: 200 }],
+        });
+      }
+      if (
+        error.errorType === 'TOKEN_INVALID' ||
+        error.errorType === 'TOKEN_EXPIRED'
+      ) {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'TOKEN_INVALID', code: 300 }],
+        });
+      }
+      if (error.errorType === 'USER_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'USER_NOT_FOUND', code: 400 }],
+        });
+      }
+      if (error.errorType === 'EMAIL_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'EMAIL.NOT.REGISTERED', code: 500 }],
+        });
+      }
+    }
+    if (error instanceof ServiceErrors) {
+      const errorReasons = [];
+
+      if (error.hasType('PHONE_NUMBER_EXISTS')) {
+        errorReasons.push({ type: 'PHONE_NUMBER_EXISTS', code: 100 });
+      }
+      if (error.hasType('EMAIL_EXISTS')) {
+        errorReasons.push({ type: 'EMAIL.EXISTS', code: 200 });
+      }
+      if (errorReasons.length > 0) {
+        return res.boom.badRequest(null, { errors: errorReasons });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/BaseController.ts b/packages/server/src/api/controllers/BaseController.ts
new file mode 100644
index 000000000..4ae651518
--- /dev/null
+++ b/packages/server/src/api/controllers/BaseController.ts
@@ -0,0 +1,140 @@
+import { Response, Request, NextFunction } from 'express';
+import { matchedData, validationResult } from 'express-validator';
+import accepts from 'accepts';
+import { isArray, drop, first, camelCase, snakeCase, omit, set, get } from 'lodash';
+import { mapKeysDeep } from 'utils';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+
+export default class BaseController {
+  /**
+   * Converts plain object keys to cameCase style.
+   * @param {Object} data
+   */
+  protected dataToCamelCase(data) {
+    return mapKeysDeep(data, (v, k) => camelCase(k));
+  }
+
+  /**
+   * Matches the body data from validation schema.
+   * @param {Request} req
+   * @param options
+   */
+  protected matchedBodyData(req: Request, options: any = {}) {
+    const data = matchedData(req, {
+      locations: ['body'],
+      includeOptionals: true,
+      ...omit(options, ['locations']), // override any propery except locations.
+    });
+    return this.dataToCamelCase(data);
+  }
+
+  /**
+   * Matches the query data from validation schema.
+   * @param {Request} req
+   */
+  protected matchedQueryData(req: Request) {
+    const data = matchedData(req, {
+      locations: ['query'],
+    });
+    return this.dataToCamelCase(data);
+  }
+
+  /**
+   * Validate validation schema middleware.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  protected validationResult(req: Request, res: Response, next: NextFunction) {
+    const validationErrors = validationResult(req);
+
+    if (!validationErrors.isEmpty()) {
+      return res.boom.badData(null, {
+        code: 'validation_error',
+        ...validationErrors,
+      });
+    }
+    next();
+  }
+
+  /**
+   * Sets localization to response object by the given path.
+   * @param {Response} response - 
+   * @param {string} path - 
+   * @param {Request} req - 
+   */
+  private setLocalizationByPath(
+    response: any,
+    path: string,
+    req: Request,
+  ) {
+    const DOT = '.';
+
+    if (isArray(response)) {
+      response.forEach((va) => {
+        const currentPath = first(path.split(DOT));
+        const value = get(va, currentPath);
+
+        if (isArray(value)) {
+          const nextPath = drop(path.split(DOT)).join(DOT);
+          this.setLocalizationByPath(value, nextPath, req);
+        } else {
+          set(va, path, req.__(value));
+        }
+      })
+    } else {
+      const value = get(response, path);
+      set(response, path, req.__(value));
+    }
+  }
+
+  /**
+   * Transform the given data to response.
+   * @param {any} data
+   */
+  protected transfromToResponse(
+    data: any,
+    translatable?: string | string[],
+    req?: Request
+  ) {
+    const response = mapKeysDeep(data, (v, k) => snakeCase(k));
+
+    if (translatable) {
+      const translatables = Array.isArray(translatable)
+        ? translatable
+        : [translatable];
+
+      translatables.forEach((path) => {
+        this.setLocalizationByPath(response, path, req);
+      });
+    }
+    return response;
+  }
+
+  /**
+   * Async middleware.
+   * @param {function} callback
+   */
+  protected asyncMiddleware(callback) {
+    return asyncMiddleware(callback);
+  }
+
+  /**
+   *
+   * @param {Request} req
+   * @returns
+   */
+  protected accepts(req) {
+    return accepts(req);
+  }
+
+  /**
+   * 
+   * @param {Request} req 
+   * @param {string[]} types 
+   * @returns {string}
+   */
+  protected acceptTypes(req: Request, types: string[])  {
+    return this.accepts(req).types(types);
+  }
+}
diff --git a/packages/server/src/api/controllers/Branches/index.ts b/packages/server/src/api/controllers/Branches/index.ts
new file mode 100644
index 000000000..56704ffe4
--- /dev/null
+++ b/packages/server/src/api/controllers/Branches/index.ts
@@ -0,0 +1,335 @@
+import { Service, Inject } from 'typedi';
+import { Request, Response, Router, NextFunction } from 'express';
+import { check, param } from 'express-validator';
+import BaseController from '@/api/controllers/BaseController';
+import { Features, ICreateBranchDTO, IEditBranchDTO } from '@/interfaces';
+import { BranchesApplication } from '@/services/Branches/BranchesApplication';
+import { ServiceError } from '@/exceptions';
+import { FeatureActivationGuard } from '@/api/middleware/FeatureActivationGuard';
+
+@Service()
+export class BranchesController extends BaseController {
+  @Inject()
+  branchesApplication: BranchesApplication;
+
+  /**
+   * Branches routes.
+   * @returns {Router}
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/activate',
+      [],
+      this.validationResult,
+      this.asyncMiddleware(this.activateBranches),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/',
+      FeatureActivationGuard(Features.BRANCHES),
+      [
+        check('name').exists(),
+        check('code').optional({ nullable: true }),
+
+        check('address').optional({ nullable: true }),
+        check('city').optional({ nullable: true }),
+        check('country').optional({ nullable: true }),
+
+        check('phone_number').optional({ nullable: true }),
+        check('email').optional({ nullable: true }).isEmail(),
+        check('website').optional({ nullable: true }).isURL(),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.createBranch),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/:id',
+      FeatureActivationGuard(Features.BRANCHES),
+      [
+        param('id').exists().isInt().toInt(),
+        check('name').exists(),
+        check('code').optional({ nullable: true }),
+
+        check('address').optional({ nullable: true }),
+        check('city').optional({ nullable: true }),
+        check('country').optional({ nullable: true }),
+
+        check('phone_number').optional({ nullable: true }),
+        check('email').optional({ nullable: true }).isEmail(),
+        check('website').optional({ nullable: true }).isURL(),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.editBranch),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/:id/mark-primary',
+      FeatureActivationGuard(Features.BRANCHES),
+      [],
+      this.validationResult,
+      this.asyncMiddleware(this.markBranchAsPrimary),
+      this.handlerServiceErrors
+    );
+    router.delete(
+      '/:id',
+      FeatureActivationGuard(Features.BRANCHES),
+      [param('id').exists().isInt().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.deleteBranch),
+      this.handlerServiceErrors
+    );
+    router.get(
+      '/:id',
+      FeatureActivationGuard(Features.BRANCHES),
+      [param('id').exists().isInt().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.getBranch),
+      this.handlerServiceErrors
+    );
+    router.get(
+      '/',
+      FeatureActivationGuard(Features.BRANCHES),
+      [],
+      this.validationResult,
+      this.asyncMiddleware(this.getBranches),
+      this.handlerServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Creates a new branch.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  public createBranch = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const createBranchDTO: ICreateBranchDTO = this.matchedBodyData(req);
+
+    try {
+      const branch = await this.branchesApplication.createBranch(
+        tenantId,
+        createBranchDTO
+      );
+      return res.status(200).send({
+        id: branch.id,
+        message: 'The branch has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Edits the given branch.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  public editBranch = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: branchId } = req.params;
+    const editBranchDTO: IEditBranchDTO = this.matchedBodyData(req);
+
+    try {
+      const branch = await this.branchesApplication.editBranch(
+        tenantId,
+        branchId,
+        editBranchDTO
+      );
+      return res.status(200).send({
+        id: branch.id,
+        message: 'The branch has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Deletes the given branch.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  public deleteBranch = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: branchId } = req.params;
+
+    try {
+      await this.branchesApplication.deleteBranch(tenantId, branchId);
+
+      return res.status(200).send({
+        id: branchId,
+        message: 'The branch has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieves specific branch.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  public getBranch = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: branchId } = req.params;
+
+    try {
+      const branch = await this.branchesApplication.getBranch(
+        tenantId,
+        branchId
+      );
+      return res.status(200).send({ branch });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieves branches list.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  public getBranches = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+
+    try {
+      const branches = await this.branchesApplication.getBranches(tenantId);
+
+      return res.status(200).send({ branches });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Activates the multi-branches feature.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  public activateBranches = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+
+    try {
+      await this.branchesApplication.activateBranches(tenantId);
+
+      return res.status(200).send({
+        message: 'Multi-branches feature has been activated successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Marks the given branch as primary.
+   * @param {Request} req 
+   * @param {Response} res 
+   * @param {NextFunction} next 
+   * @returns {Response}
+   */
+  public markBranchAsPrimary = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: branchId } = req.params;
+
+    try {
+      await this.branchesApplication.markBranchAsPrimary(tenantId, branchId);
+
+      return res.status(200).send({
+        id: branchId,
+        message: 'The branch has been marked as primary.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handlerServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'BRANCH_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'BRANCH_NOT_FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'MUTLI_BRANCHES_ALREADY_ACTIVATED') {
+        return res.status(400).send({
+          errors: [{ type: 'MUTLI_BRANCHES_ALREADY_ACTIVATED', code: 100 }],
+        });
+      }
+      if (error.errorType === 'COULD_NOT_DELETE_ONLY_BRANCH') {
+        return res.status(400).send({
+          errors: [{ type: 'COULD_NOT_DELETE_ONLY_BRANCH', code: 300 }],
+        });
+      }
+      if (error.errorType === 'BRANCH_CODE_NOT_UNIQUE') {
+        return res.status(400).send({
+          errors: [{ type: 'BRANCH_CODE_NOT_UNIQUE', code: 400 }],
+        });
+      }
+      if (error.errorType === 'BRANCH_HAS_ASSOCIATED_TRANSACTIONS') {
+        return res.status(400).send({
+          errors: [
+            { type: 'BRANCH_HAS_ASSOCIATED_TRANSACTIONS', code: 500 },
+          ],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Cashflow/CashflowController.ts b/packages/server/src/api/controllers/Cashflow/CashflowController.ts
new file mode 100644
index 000000000..c6dfe5c29
--- /dev/null
+++ b/packages/server/src/api/controllers/Cashflow/CashflowController.ts
@@ -0,0 +1,23 @@
+import { Service, Inject, Container } from 'typedi';
+import { Router } from 'express';
+import CommandCashflowTransaction from './NewCashflowTransaction';
+import DeleteCashflowTransaction from './DeleteCashflowTransaction';
+import GetCashflowTransaction from './GetCashflowTransaction';
+import GetCashflowAccounts from './GetCashflowAccounts';
+
+@Service()
+export default class CashflowController {
+  /**
+   * Constructor method.
+   */
+  router() {
+    const router = Router();
+
+    router.use(Container.get(GetCashflowTransaction).router());
+    router.use(Container.get(GetCashflowAccounts).router());
+    router.use(Container.get(CommandCashflowTransaction).router());
+    router.use(Container.get(DeleteCashflowTransaction).router());
+
+    return router;
+  }
+}
diff --git a/packages/server/src/api/controllers/Cashflow/DeleteCashflowTransaction.ts b/packages/server/src/api/controllers/Cashflow/DeleteCashflowTransaction.ts
new file mode 100644
index 000000000..0ddb6d74d
--- /dev/null
+++ b/packages/server/src/api/controllers/Cashflow/DeleteCashflowTransaction.ts
@@ -0,0 +1,98 @@
+import { Service, Inject } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import { param } from 'express-validator';
+import BaseController from '../BaseController';
+import { ServiceError } from '@/exceptions';
+import DeleteCashflowTransactionService from '../../../services/Cashflow/DeleteCashflowTransactionService';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { AbilitySubject, CashflowAction } from '@/interfaces';
+
+@Service()
+export default class DeleteCashflowTransaction extends BaseController {
+  @Inject()
+  deleteCashflowService: DeleteCashflowTransactionService;
+
+  /**
+   * Controller router.
+   */
+  public router() {
+    const router = Router();
+
+    router.delete(
+      '/transactions/:transactionId',
+      CheckPolicies(CashflowAction.Delete, AbilitySubject.Cashflow),
+      [param('transactionId').exists().isInt().toInt()],
+      this.asyncMiddleware(this.deleteCashflowTransaction),
+      this.catchServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Retrieve the cashflow account transactions.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private deleteCashflowTransaction = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { transactionId } = req.params;
+
+    try {
+      const { oldCashflowTransaction } =
+        await this.deleteCashflowService.deleteCashflowTransaction(
+          tenantId,
+          transactionId
+        );
+
+      return res.status(200).send({
+        id: oldCashflowTransaction.id,
+        message: 'The cashflow transaction has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Catches the service errors.
+   * @param error
+   * @param req
+   * @param res
+   * @param next
+   * @returns
+   */
+  private catchServiceErrors(
+    error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'CASHFLOW_TRANSACTION_NOT_FOUND') {
+        return res.boom.badRequest(
+          'The given cashflow transaction not found.',
+          {
+            errors: [{ type: 'CASHFLOW_TRANSACTION_NOT_FOUND', code: 100 }],
+          }
+        );
+      }
+      if (error.errorType === 'TRANSACTIONS_DATE_LOCKED') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'TRANSACTIONS_DATE_LOCKED',
+              code: 4000,
+              data: { ...error.payload },
+            },
+          ],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Cashflow/GetCashflowAccounts.ts b/packages/server/src/api/controllers/Cashflow/GetCashflowAccounts.ts
new file mode 100644
index 000000000..59fdb91ba
--- /dev/null
+++ b/packages/server/src/api/controllers/Cashflow/GetCashflowAccounts.ts
@@ -0,0 +1,95 @@
+import { Service, Inject } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import { param, query } from 'express-validator';
+import GetCashflowAccountsService from '@/services/Cashflow/GetCashflowAccountsService';
+import BaseController from '../BaseController';
+import GetCashflowTransactionsService from '@/services/Cashflow/GetCashflowTransactionsService';
+import { ServiceError } from '@/exceptions';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { AbilitySubject, CashflowAction } from '@/interfaces';
+
+@Service()
+export default class GetCashflowAccounts extends BaseController {
+  @Inject()
+  getCashflowAccountsService: GetCashflowAccountsService;
+
+  @Inject()
+  getCashflowTransactionsService: GetCashflowTransactionsService;
+
+  /**
+   * Controller router.
+   */
+  public router() {
+    const router = Router();
+
+    router.get(
+      '/accounts',
+      CheckPolicies(CashflowAction.View, AbilitySubject.Cashflow),
+      [
+        query('stringified_filter_roles').optional().isJSON(),
+
+        query('column_sort_by').optional(),
+        query('sort_order').optional().isIn(['desc', 'asc']),
+
+        query('inactive_mode').optional().isBoolean().toBoolean(),
+        query('search_keyword').optional({ nullable: true }).isString().trim(),
+      ],
+      this.asyncMiddleware(this.getCashflowAccounts),
+      this.catchServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Retrieve the cashflow accounts.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private getCashflowAccounts = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    // Filter query.
+    const filter = {
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      inactiveMode: false,
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const cashflowAccounts =
+        await this.getCashflowAccountsService.getCashflowAccounts(
+          tenantId,
+          filter
+        );
+
+      return res.status(200).send({
+        cashflow_accounts: this.transfromToResponse(cashflowAccounts),
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Catches the service errors.
+   * @param {Error} error - Error.
+   * @param {Request} req - Request.
+   * @param {Response} res - Response.
+   * @param {NextFunction} next -
+   */
+  private catchServiceErrors(
+    error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Cashflow/GetCashflowTransaction.ts b/packages/server/src/api/controllers/Cashflow/GetCashflowTransaction.ts
new file mode 100644
index 000000000..7cf8d2d8e
--- /dev/null
+++ b/packages/server/src/api/controllers/Cashflow/GetCashflowTransaction.ts
@@ -0,0 +1,98 @@
+import { Service, Inject } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import { param } from 'express-validator';
+import BaseController from '../BaseController';
+import GetCashflowTransactionsService from '@/services/Cashflow/GetCashflowTransactionsService';
+import { ServiceError } from '@/exceptions';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { AbilitySubject, CashflowAction } from '@/interfaces';
+
+@Service()
+export default class GetCashflowAccounts extends BaseController {
+  @Inject()
+  getCashflowTransactionsService: GetCashflowTransactionsService;
+
+  /**
+   * Controller router.
+   */
+  public router() {
+    const router = Router();
+
+    router.get(
+      '/transactions/:transactionId',
+      CheckPolicies(CashflowAction.View, AbilitySubject.Cashflow),
+      [param('transactionId').exists().isInt().toInt()],
+      this.asyncMiddleware(this.getCashflowTransaction),
+      this.catchServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Retrieve the cashflow account transactions.
+   * @param {Request} req - Request object.
+   * @param {Response} res - Response object.
+   * @param {NextFunction} next
+   */
+  private getCashflowTransaction = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { transactionId } = req.params;
+
+    try {
+      const cashflowTransaction =
+        await this.getCashflowTransactionsService.getCashflowTransaction(
+          tenantId,
+          transactionId
+        );
+
+      return res.status(200).send({
+        cashflow_transaction: this.transfromToResponse(cashflowTransaction),
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Catches the service errors.
+   * @param {Error} error - Error.
+   * @param {Request} req - Request.
+   * @param {Response} res - Response.
+   * @param {NextFunction} next -
+   */
+  private catchServiceErrors(
+    error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'CASHFLOW_TRANSACTION_NOT_FOUND') {
+        return res.boom.badRequest(
+          'The given cashflow tranasction not found.',
+          {
+            errors: [{ type: 'CASHFLOW_TRANSACTION_NOT_FOUND', code: 200 }],
+          }
+        );
+      }
+      if (error.errorType === 'ACCOUNT_ID_HAS_INVALID_TYPE') {
+        return res.boom.badRequest(
+          'The given cashflow account has invalid type.',
+          {
+            errors: [{ type: 'ACCOUNT_ID_HAS_INVALID_TYPE', code: 300 }],
+          }
+        );
+      }
+      if (error.errorType === 'ACCOUNT_NOT_FOUND') {
+        return res.boom.badRequest('The given account not found.', {
+          errors: [{ type: 'ACCOUNT_NOT_FOUND', code: 400 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Cashflow/NewCashflowTransaction.ts b/packages/server/src/api/controllers/Cashflow/NewCashflowTransaction.ts
new file mode 100644
index 000000000..91abfcf92
--- /dev/null
+++ b/packages/server/src/api/controllers/Cashflow/NewCashflowTransaction.ts
@@ -0,0 +1,146 @@
+import { Service, Inject } from 'typedi';
+import { check } from 'express-validator';
+import { Router, Request, Response, NextFunction } from 'express';
+import BaseController from '../BaseController';
+import { ServiceError } from '@/exceptions';
+import NewCashflowTransactionService from '@/services/Cashflow/NewCashflowTransactionService';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { AbilitySubject, CashflowAction } from '@/interfaces';
+
+@Service()
+export default class NewCashflowTransactionController extends BaseController {
+  @Inject()
+  private newCashflowTranscationService: NewCashflowTransactionService;
+
+  /**
+   * Router constructor.
+   */
+  public router() {
+    const router = Router();
+
+    router.post(
+      '/transactions',
+      CheckPolicies(CashflowAction.Create, AbilitySubject.Cashflow),
+      this.newTransactionValidationSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.newCashflowTransaction),
+      this.catchServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * New cashflow transaction validation schema.
+   */
+  get newTransactionValidationSchema() {
+    return [
+      check('date').exists().isISO8601().toDate(),
+      check('reference_no').optional({ nullable: true }).trim().escape(),
+      check('description')
+        .optional({ nullable: true })
+        .isLength({ min: 3 })
+        .trim()
+        .escape(),
+      check('transaction_type').exists(),
+
+      check('amount').exists().isFloat().toFloat(),
+      check('cashflow_account_id').exists().isInt().toInt(),
+      check('credit_account_id').exists().isInt().toInt(),
+
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+
+      check('publish').default(false).isBoolean().toBoolean(),
+    ];
+  }
+
+  /**
+   * Creates a new cashflow transaction.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  private newCashflowTransaction = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId, userId } = req;
+    const ownerContributionDTO = this.matchedBodyData(req);
+
+    try {
+      const { cashflowTransaction } =
+        await this.newCashflowTranscationService.newCashflowTransaction(
+          tenantId,
+          ownerContributionDTO,
+          userId
+        );
+
+      return res.status(200).send({
+        id: cashflowTransaction.id,
+        message: 'New cashflow transaction has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handle the service errors.
+   * @param error
+   * @param req
+   * @param res
+   * @param next
+   * @returns
+   */
+  private catchServiceErrors(
+    error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'CASHFLOW_ACCOUNTS_IDS_NOT_FOUND') {
+        return res.boom.badRequest('Cashflow accounts ids not found.', {
+          errors: [{ type: 'CASHFLOW_ACCOUNTS_IDS_NOT_FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'CREDIT_ACCOUNTS_IDS_NOT_FOUND') {
+        return res.boom.badRequest('Credit accounts ids not found.', {
+          errors: [{ type: 'CREDIT_ACCOUNTS_IDS_NOT_FOUND', code: 200 }],
+        });
+      }
+      if (error.errorType === 'CREDIT_ACCOUNTS_HAS_INVALID_TYPE') {
+        return res.boom.badRequest('Cashflow .', {
+          errors: [{ type: 'CREDIT_ACCOUNTS_HAS_INVALID_TYPE', code: 300 }],
+        });
+      }
+      if (error.errorType === 'CASHFLOW_ACCOUNTS_HAS_INVALID_TYPE') {
+        return res.boom.badRequest(
+          'Cashflow accounts should be cash or bank type.',
+          {
+            errors: [{ type: 'CASHFLOW_ACCOUNTS_HAS_INVALID_TYPE', code: 300 }],
+          }
+        );
+      }
+      if (error.errorType === 'CASHFLOW_TRANSACTION_NOT_FOUND') {
+        return res.boom.badRequest('Cashflow transaction not found.', {
+          errors: [{ type: 'CASHFLOW_TRANSACTION_NOT_FOUND', code: 500 }],
+        });
+      }
+      if (error.errorType === 'TRANSACTIONS_DATE_LOCKED') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'TRANSACTIONS_DATE_LOCKED',
+              code: 4000,
+              data: { ...error.payload },
+            },
+          ],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Contacts/Contacts.ts b/packages/server/src/api/controllers/Contacts/Contacts.ts
new file mode 100644
index 000000000..a05ee93fd
--- /dev/null
+++ b/packages/server/src/api/controllers/Contacts/Contacts.ts
@@ -0,0 +1,404 @@
+import { check, param, query, body, ValidationChain } from 'express-validator';
+import { Router, Request, Response, NextFunction } from 'express';
+import { Inject, Service } from 'typedi';
+import { ServiceError } from '@/exceptions';
+import BaseController from '@/api/controllers/BaseController';
+import ContactsService from '@/services/Contacts/ContactsService';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { DATATYPES_LENGTH } from '@/data/DataTypes';
+
+@Service()
+export default class ContactsController extends BaseController {
+  @Inject()
+  contactsService: ContactsService;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  /**
+   * Express router.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/auto-complete',
+      [...this.autocompleteQuerySchema],
+      this.validationResult,
+      this.asyncMiddleware(this.autocompleteContacts.bind(this)),
+      this.dynamicListService.handlerErrorsToResponse
+    );
+    router.get(
+      '/:id',
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.getContact.bind(this))
+    );
+    router.post(
+      '/:id/inactivate',
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.inactivateContact.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/:id/activate',
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.activateContact.bind(this)),
+      this.handlerServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Auto-complete list query validation schema.
+   */
+  get autocompleteQuerySchema() {
+    return [
+      query('column_sort_by').optional().trim().escape(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+
+      query('stringified_filter_roles').optional().isJSON(),
+      query('limit').optional().isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Retrieve details of the given contact.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  async getContact(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: contactId } = req.params;
+
+    try {
+      const contact = await this.contactsService.getContact(
+        tenantId,
+        contactId
+      );
+      return res.status(200).send({
+        customer: this.transfromToResponse(contact),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve auto-complete contacts list.
+   * @param {Request} req - Request object.
+   * @param {Response} res - Response object.
+   * @param {NextFunction} next
+   */
+  async autocompleteContacts(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const filter = {
+      filterRoles: [],
+      sortOrder: 'asc',
+      columnSortBy: 'display_name',
+      limit: 10,
+      ...this.matchedQueryData(req),
+    };
+    try {
+      const contacts = await this.contactsService.autocompleteContacts(
+        tenantId,
+        filter
+      );
+      return res.status(200).send({ contacts });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * @returns {ValidationChain[]}
+   */
+  get contactDTOSchema(): ValidationChain[] {
+    return [
+      check('salutation')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('first_name')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('last_name')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('company_name')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+
+      check('display_name')
+        .exists()
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+
+      check('email')
+        .optional({ nullable: true })
+        .isString()
+        .normalizeEmail()
+        .isEmail()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('website')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .isURL()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('work_phone')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('personal_phone')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+
+      check('billing_address_1')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('billing_address_2')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('billing_address_city')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('billing_address_country')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('billing_address_email')
+        .optional({ nullable: true })
+        .isString()
+        .isEmail()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('billing_address_postcode')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('billing_address_phone')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('billing_address_state')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+
+      check('shipping_address_1')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('shipping_address_2')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('shipping_address_city')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('shipping_address_country')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('shipping_address_email')
+        .optional({ nullable: true })
+        .isString()
+        .isEmail()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('shipping_address_postcode')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('shipping_address_phone')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('shipping_address_state')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+
+      check('note')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.TEXT }),
+      check('active').optional().isBoolean().toBoolean(),
+    ];
+  }
+
+  /**
+   * Contact new DTO schema.
+   * @returns {ValidationChain[]}
+   */
+  get contactNewDTOSchema(): ValidationChain[] {
+    return [
+      check('opening_balance')
+        .optional({ nullable: true })
+        .isInt({ min: 0, max: DATATYPES_LENGTH.DECIMAL_13_3 })
+        .toInt(),
+      check('opening_balance_exchange_rate')
+        .default(1)
+        .isFloat({ gt: 0 })
+        .toFloat(),
+      body('opening_balance_at')
+        .if(body('opening_balance').exists())
+        .exists()
+        .isISO8601(),
+      check('opening_balance_branch_id')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toInt(),
+    ];
+  }
+
+  /**
+   * Contact edit DTO schema.
+   * @returns {ValidationChain[]}
+   */
+  get contactEditDTOSchema(): ValidationChain[] {
+    return [];
+  }
+
+  /**
+   * @returns {ValidationChain[]}
+   */
+  get specificContactSchema(): ValidationChain[] {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  /**
+   * Activates the given contact.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async activateContact(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: contactId } = req.params;
+
+    try {
+      await this.contactsService.activateContact(tenantId, contactId);
+
+      return res.status(200).send({
+        id: contactId,
+        message: 'The given contact activated successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Inactivate the given contact.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async inactivateContact(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: contactId } = req.params;
+
+    try {
+      await this.contactsService.inactivateContact(tenantId, contactId);
+
+      return res.status(200).send({
+        id: contactId,
+        message: 'The given contact inactivated successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handlerServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'contact_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CONTACT.NOT.FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'CONTACT_ALREADY_ACTIVE') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CONTACT_ALREADY_ACTIVE', code: 700 }],
+        });
+      }
+      if (error.errorType === 'CONTACT_ALREADY_INACTIVE') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CONTACT_ALREADY_INACTIVE', code: 800 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Contacts/Customers.ts b/packages/server/src/api/controllers/Contacts/Customers.ts
new file mode 100644
index 000000000..b317a11d2
--- /dev/null
+++ b/packages/server/src/api/controllers/Contacts/Customers.ts
@@ -0,0 +1,351 @@
+import { Request, Response, Router, NextFunction } from 'express';
+import { Service, Inject } from 'typedi';
+import { check, query } from 'express-validator';
+import ContactsController from '@/api/controllers/Contacts/Contacts';
+import CustomersService from '@/services/Contacts/CustomersService';
+import { ServiceError } from '@/exceptions';
+import {
+  ICustomerNewDTO,
+  ICustomerEditDTO,
+  AbilitySubject,
+  CustomerAction,
+} from '@/interfaces';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { CustomersApplication } from '@/services/Contacts/Customers/CustomersApplication';
+
+@Service()
+export default class CustomersController extends ContactsController {
+  @Inject()
+  private customersApplication: CustomersApplication;
+
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  /**
+   * Express router.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/',
+      CheckPolicies(CustomerAction.Create, AbilitySubject.Customer),
+      [
+        ...this.contactDTOSchema,
+        ...this.contactNewDTOSchema,
+        ...this.customerDTOSchema,
+        ...this.createCustomerDTOSchema,
+      ],
+      this.validationResult,
+      asyncMiddleware(this.newCustomer.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/:id/opening_balance',
+      CheckPolicies(CustomerAction.Edit, AbilitySubject.Customer),
+      [
+        ...this.specificContactSchema,
+        check('opening_balance').exists().isNumeric().toFloat(),
+        check('opening_balance_at').optional().isISO8601(),
+        check('opening_balance_exchange_rate')
+          .default(1)
+          .isFloat({ gt: 0 })
+          .toFloat(),
+        check('opening_balance_branch_id')
+          .optional({ nullable: true })
+          .isNumeric()
+          .toInt(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.editOpeningBalanceCustomer.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/:id',
+      CheckPolicies(CustomerAction.Edit, AbilitySubject.Customer),
+      [
+        ...this.contactDTOSchema,
+        ...this.contactEditDTOSchema,
+        ...this.customerDTOSchema,
+      ],
+      this.validationResult,
+      asyncMiddleware(this.editCustomer.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.delete(
+      '/:id',
+      CheckPolicies(CustomerAction.Delete, AbilitySubject.Customer),
+      [...this.specificContactSchema],
+      this.validationResult,
+      asyncMiddleware(this.deleteCustomer.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.get(
+      '/',
+      CheckPolicies(CustomerAction.View, AbilitySubject.Customer),
+      [...this.validateListQuerySchema],
+      this.validationResult,
+      asyncMiddleware(this.getCustomersList.bind(this)),
+      this.dynamicListService.handlerErrorsToResponse
+    );
+    router.get(
+      '/:id',
+      CheckPolicies(CustomerAction.View, AbilitySubject.Customer),
+      [...this.specificContactSchema],
+      this.validationResult,
+      asyncMiddleware(this.getCustomer.bind(this)),
+      this.handlerServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Customer DTO schema.
+   */
+  get customerDTOSchema() {
+    return [
+      check('customer_type')
+        .exists()
+        .isIn(['business', 'individual'])
+        .trim()
+        .escape(),
+    ];
+  }
+
+  /**
+   * Create customer DTO schema.
+   */
+  get createCustomerDTOSchema() {
+    return [
+      check('currency_code')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: 3 }),
+    ];
+  }
+
+  /**
+   * List param query schema.
+   */
+  get validateListQuerySchema() {
+    return [
+      query('column_sort_by').optional().trim().escape(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+
+      query('view_slug').optional().isString().trim(),
+      query('stringified_filter_roles').optional().isJSON(),
+
+      query('inactive_mode').optional().isBoolean().toBoolean(),
+      query('search_keyword').optional({ nullable: true }).isString().trim(),
+    ];
+  }
+
+  /**
+   * Creates a new customer.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async newCustomer(req: Request, res: Response, next: NextFunction) {
+    const contactDTO: ICustomerNewDTO = this.matchedBodyData(req);
+    const { tenantId, user } = req;
+
+    try {
+      const contact = await this.customersApplication.createCustomer(
+        tenantId,
+        contactDTO,
+        user
+      );
+
+      return res.status(200).send({
+        id: contact.id,
+        message: 'The customer has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Edits the given customer details.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async editCustomer(req: Request, res: Response, next: NextFunction) {
+    const contactDTO: ICustomerEditDTO = this.matchedBodyData(req);
+    const { tenantId, user } = req;
+    const { id: contactId } = req.params;
+
+    try {
+      await this.customersApplication.editCustomer(
+        tenantId,
+        contactId,
+        contactDTO,
+        user
+      );
+
+      return res.status(200).send({
+        id: contactId,
+        message: 'The customer has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Changes the opening balance of the given customer.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  async editOpeningBalanceCustomer(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId, user } = req;
+    const { id: customerId } = req.params;
+    const openingBalanceEditDTO = this.matchedBodyData(req);
+
+    try {
+      await this.customersApplication.editOpeningBalance(
+        tenantId,
+        customerId,
+        openingBalanceEditDTO
+      );
+      return res.status(200).send({
+        id: customerId,
+        message:
+          'The opening balance of the given customer has been changed successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve details of the given customer id.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async getCustomer(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const { id: contactId } = req.params;
+
+    try {
+      const customer = await this.customersApplication.getCustomer(
+        tenantId,
+        contactId,
+        user
+      );
+
+      return res.status(200).send({
+        customer: this.transfromToResponse(customer),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Deletes the given customer from the storage.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async deleteCustomer(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const { id: contactId } = req.params;
+
+    try {
+      await this.customersApplication.deleteCustomer(tenantId, contactId, user);
+
+      return res.status(200).send({
+        id: contactId,
+        message: 'The customer has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve customers paginated and filterable list.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async getCustomersList(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+
+    const filter = {
+      inactiveMode: false,
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      page: 1,
+      pageSize: 12,
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const { customers, pagination, filterMeta } =
+        await this.customersApplication.getCustomers(tenantId, filter);
+
+      return res.status(200).send({
+        customers: this.transfromToResponse(customers),
+        pagination: this.transfromToResponse(pagination),
+        filter_meta: this.transfromToResponse(filterMeta),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handlerServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'contact_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER.NOT.FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'contacts_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMERS.NOT.FOUND', code: 200 }],
+        });
+      }
+      if (error.errorType === 'OPENING_BALANCE_DATE_REQUIRED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'OPENING_BALANCE_DATE_REQUIRED', code: 500 }],
+        });
+      }
+      if (error.errorType === 'CUSTOMER_HAS_TRANSACTIONS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER_HAS_TRANSACTIONS', code: 600 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Contacts/Vendors.ts b/packages/server/src/api/controllers/Contacts/Vendors.ts
new file mode 100644
index 000000000..679719a0f
--- /dev/null
+++ b/packages/server/src/api/controllers/Contacts/Vendors.ts
@@ -0,0 +1,332 @@
+import { Request, Response, Router, NextFunction } from 'express';
+import { Service, Inject } from 'typedi';
+import { body, query, ValidationChain, check } from 'express-validator';
+
+import ContactsController from '@/api/controllers/Contacts/Contacts';
+import { ServiceError } from '@/exceptions';
+import {
+  IVendorNewDTO,
+  IVendorEditDTO,
+  IVendorsFilter,
+  AbilitySubject,
+  VendorAction,
+} from '@/interfaces';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { VendorsApplication } from '@/services/Contacts/Vendors/VendorsApplication';
+
+@Service()
+export default class VendorsController extends ContactsController {
+  @Inject()
+  private vendorsApplication: VendorsApplication;
+
+  /**
+   * Express router.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/',
+      CheckPolicies(VendorAction.Create, AbilitySubject.Vendor),
+      [
+        ...this.contactDTOSchema,
+        ...this.contactNewDTOSchema,
+        ...this.vendorDTOSchema,
+      ],
+      this.validationResult,
+      asyncMiddleware(this.newVendor.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/:id/opening_balance',
+      CheckPolicies(VendorAction.Edit, AbilitySubject.Vendor),
+      [
+        ...this.specificContactSchema,
+        check('opening_balance').exists().isNumeric().toFloat(),
+        check('opening_balance_at').optional().isISO8601(),
+        check('opening_balance_exchange_rate')
+          .default(1)
+          .isFloat({ gt: 0 })
+          .toFloat(),
+        check('opening_balance_branch_id')
+          .optional({ nullable: true })
+          .isNumeric()
+          .toInt(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.editOpeningBalanceVendor.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/:id',
+      CheckPolicies(VendorAction.Edit, AbilitySubject.Vendor),
+      [
+        ...this.contactDTOSchema,
+        ...this.contactEditDTOSchema,
+        ...this.vendorDTOSchema,
+      ],
+      this.validationResult,
+      asyncMiddleware(this.editVendor.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.delete(
+      '/:id',
+      CheckPolicies(VendorAction.Delete, AbilitySubject.Vendor),
+      [...this.specificContactSchema],
+      this.validationResult,
+      asyncMiddleware(this.deleteVendor.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.get(
+      '/:id',
+      CheckPolicies(VendorAction.View, AbilitySubject.Vendor),
+      [...this.specificContactSchema],
+      this.validationResult,
+      asyncMiddleware(this.getVendor.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.get(
+      '/',
+      CheckPolicies(VendorAction.View, AbilitySubject.Vendor),
+      [...this.vendorsListSchema],
+      this.validationResult,
+      asyncMiddleware(this.getVendorsList.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Vendor DTO schema.
+   * @returns {ValidationChain[]}
+   */
+  get vendorDTOSchema(): ValidationChain[] {
+    return [
+      check('currency_code')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ min: 3, max: 3 }),
+    ];
+  }
+
+  /**
+   * Vendors datatable list validation schema.
+   * @returns {ValidationChain[]}
+   */
+  get vendorsListSchema() {
+    return [
+      query('view_slug').optional().isString().trim(),
+      query('stringified_filter_roles').optional().isJSON(),
+
+      query('column_sort_by').optional(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+
+      query('inactive_mode').optional().isBoolean().toBoolean(),
+      query('search_keyword').optional({ nullable: true }).isString().trim(),
+    ];
+  }
+
+  /**
+   * Creates a new vendor.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async newVendor(req: Request, res: Response, next: NextFunction) {
+    const contactDTO: IVendorNewDTO = this.matchedBodyData(req);
+    const { tenantId, user } = req;
+
+    try {
+      const vendor = await this.vendorsApplication.createVendor(
+        tenantId,
+        contactDTO,
+        user
+      );
+
+      return res.status(200).send({
+        id: vendor.id,
+        message: 'The vendor has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Edits the given vendor details.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async editVendor(req: Request, res: Response, next: NextFunction) {
+    const contactDTO: IVendorEditDTO = this.matchedBodyData(req);
+    const { tenantId, user } = req;
+    const { id: contactId } = req.params;
+
+    try {
+      await this.vendorsApplication.editVendor(
+        tenantId,
+        contactId,
+        contactDTO,
+        user
+      );
+
+      return res.status(200).send({
+        id: contactId,
+        message: 'The vendor has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Changes the opening balance of the given vendor.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  async editOpeningBalanceVendor(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId, user } = req;
+    const { id: vendorId } = req.params;
+    const editOpeningBalanceDTO = this.matchedBodyData(req);
+
+    try {
+      await this.vendorsApplication.editOpeningBalance(
+        tenantId,
+        vendorId,
+        editOpeningBalanceDTO
+      );
+      return res.status(200).send({
+        id: vendorId,
+        message:
+          'The opening balance of the given vendor has been changed successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Deletes the given vendor from the storage.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async deleteVendor(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const { id: contactId } = req.params;
+
+    try {
+      await this.vendorsApplication.deleteVendor(tenantId, contactId, user);
+
+      return res.status(200).send({
+        id: contactId,
+        message: 'The vendor has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve details of the given vendor id.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async getVendor(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const { id: vendorId } = req.params;
+
+    try {
+      const vendor = await this.vendorsApplication.getVendor(
+        tenantId,
+        vendorId,
+        user
+      );
+      return res.status(200).send(this.transfromToResponse({ vendor }));
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve vendors datatable list.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async getVendorsList(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+
+    const vendorsFilter: IVendorsFilter = {
+      inactiveMode: false,
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      page: 1,
+      pageSize: 12,
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const { vendors, pagination, filterMeta } =
+        await this.vendorsApplication.getVendors(tenantId, vendorsFilter);
+
+      return res.status(200).send({
+        vendors: this.transfromToResponse(vendors),
+        pagination: this.transfromToResponse(pagination),
+        filter_meta: this.transfromToResponse(filterMeta),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handle service errors.
+   * @param {Error} error -
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  private handlerServiceErrors(
+    error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'contact_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'VENDOR.NOT.FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'contacts_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'VENDORS.NOT.FOUND', code: 200 }],
+        });
+      }
+      if (error.errorType === 'OPENING_BALANCE_DATE_REQUIRED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'OPENING_BALANCE_DATE_REQUIRED', code: 500 }],
+        });
+      }
+      if (error.errorType === 'VENDOR_HAS_TRANSACTIONS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'VENDOR_HAS_TRANSACTIONS', code: 600 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Currencies.ts b/packages/server/src/api/controllers/Currencies.ts
new file mode 100644
index 000000000..ba328a78a
--- /dev/null
+++ b/packages/server/src/api/controllers/Currencies.ts
@@ -0,0 +1,211 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query, ValidationChain } from 'express-validator';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseController from './BaseController';
+import CurrenciesService from '@/services/Currencies/CurrenciesService';
+import { Inject, Service } from 'typedi';
+import { ServiceError } from '@/exceptions';
+
+@Service()
+export default class CurrenciesController extends BaseController {
+  @Inject()
+  currenciesService: CurrenciesService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      [...this.listSchema],
+      this.validationResult,
+      asyncMiddleware(this.all.bind(this))
+    );
+    router.post(
+      '/',
+      [...this.currencyDTOSchemaValidation],
+      this.validationResult,
+      asyncMiddleware(this.newCurrency.bind(this)),
+      this.handlerServiceError
+    );
+    router.post(
+      '/:id',
+      [...this.currencyIdParamSchema, ...this.currencyEditDTOSchemaValidation],
+      this.validationResult,
+      asyncMiddleware(this.editCurrency.bind(this)),
+      this.handlerServiceError
+    );
+    router.delete(
+      '/:currency_code',
+      [...this.currencyParamSchema],
+      this.validationResult,
+      asyncMiddleware(this.deleteCurrency.bind(this)),
+      this.handlerServiceError
+    );
+    return router;
+  }
+
+  get currencyDTOSchemaValidation(): ValidationChain[] {
+    return [
+      check('currency_name').exists().trim(),
+      check('currency_code').exists().trim(),
+      check('currency_sign').exists().trim(),
+    ];
+  }
+
+  get currencyEditDTOSchemaValidation(): ValidationChain[] {
+    return [
+      check('currency_name').exists().trim(),
+      check('currency_sign').exists().trim(),
+    ];
+  }
+
+  get currencyIdParamSchema(): ValidationChain[] {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  get currencyParamSchema(): ValidationChain[] {
+    return [param('currency_code').exists().trim().escape()];
+  }
+
+  get listSchema(): ValidationChain[] {
+    return [
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Retrieve all registered currency details.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async all(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+
+    try {
+      const currencies = await this.currenciesService.listCurrencies(tenantId);
+
+      return res.status(200).send({
+        currencies: this.transfromToResponse(currencies),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Creates a new currency on the storage.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async newCurrency(req: Request, res: Response, next: Function) {
+    const { tenantId } = req;
+    const currencyDTO = this.matchedBodyData(req);
+
+    try {
+      await this.currenciesService.newCurrency(tenantId, currencyDTO);
+
+      return res.status(200).send({
+        currency_code: currencyDTO.currencyCode,
+        message: 'The currency has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Edits details of the given currency.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async deleteCurrency(req: Request, res: Response, next: Function) {
+    const { tenantId } = req;
+    const { currency_code: currencyCode } = req.params;
+
+    try {
+      await this.currenciesService.deleteCurrency(tenantId, currencyCode);
+      return res.status(200).send({
+        currency_code: currencyCode,
+        message: 'The currency has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Deletes the currency.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async editCurrency(req: Request, res: Response, next: Function) {
+    const { tenantId } = req;
+    const { id: currencyId } = req.params;
+    const editCurrencyDTO = this.matchedBodyData(req);
+
+    try {
+      const currency = await this.currenciesService.editCurrency(
+        tenantId,
+        currencyId,
+        editCurrencyDTO
+      );
+      return res.status(200).send({
+        currency_code: currency.currencyCode,
+        message: 'The currency has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handles currencies service error.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  handlerServiceError(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'currency_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CURRENCY_NOT_FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'currency_code_exists') {
+        return res.boom.badRequest(null, {
+          errors: [{
+            type: 'CURRENCY_CODE_EXISTS',
+            message: 'The given currency code is already exists.',
+            code: 200,
+           }],
+        });
+      }
+      if (error.errorType === 'CANNOT_DELETE_BASE_CURRENCY') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'CANNOT_DELETE_BASE_CURRENCY',
+              code: 300,
+              message: 'Cannot delete the base currency.',
+            },
+          ],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Dashboard/index.ts b/packages/server/src/api/controllers/Dashboard/index.ts
new file mode 100644
index 000000000..4102fcbe8
--- /dev/null
+++ b/packages/server/src/api/controllers/Dashboard/index.ts
@@ -0,0 +1,47 @@
+import { Inject, Service } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import DashboardService from '@/services/Dashboard/DashboardService';
+
+@Service()
+export default class DashboardMetaController {
+  @Inject()
+  dashboardService: DashboardService;
+
+  /**
+   *
+   * @returns
+   */
+  router() {
+    const router = Router();
+
+    router.get('/boot', this.getDashboardBoot);
+
+    return router;
+  }
+
+  /**
+   * Retrieve the dashboard boot meta.
+   * @param {Request} req -
+   * @param {Response} res - 
+   * @param {NextFunction} next -
+   */
+  getDashboardBoot = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const authorizedUser = req.user;
+    const { tenantId } = req;
+
+    try {
+      const meta = await this.dashboardService.getBootMeta(
+        tenantId,
+        authorizedUser
+      );
+
+      return res.status(200).send({ meta });
+    } catch (error) {
+      next(error);
+    }
+  };
+}
diff --git a/packages/server/src/api/controllers/ExchangeRates.ts b/packages/server/src/api/controllers/ExchangeRates.ts
new file mode 100644
index 000000000..4b808e921
--- /dev/null
+++ b/packages/server/src/api/controllers/ExchangeRates.ts
@@ -0,0 +1,220 @@
+import { Service, Inject } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query } from 'express-validator';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseController from './BaseController';
+import { ServiceError } from '@/exceptions';
+import ExchangeRatesService from '@/services/ExchangeRates/ExchangeRatesService';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+
+@Service()
+export default class ExchangeRatesController extends BaseController {
+  @Inject()
+  exchangeRatesService: ExchangeRatesService;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  /**
+   * Constructor method.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      [...this.exchangeRatesListSchema],
+      this.validationResult,
+      asyncMiddleware(this.exchangeRates.bind(this)),
+      this.dynamicListService.handlerErrorsToResponse,
+      this.handleServiceError,
+    );
+    router.post(
+      '/',
+      [...this.exchangeRateDTOSchema],
+      this.validationResult,
+      asyncMiddleware(this.addExchangeRate.bind(this)),
+      this.handleServiceError
+    );
+    router.post(
+      '/:id',
+      [...this.exchangeRateEditDTOSchema, ...this.exchangeRateIdSchema],
+      this.validationResult,
+      asyncMiddleware(this.editExchangeRate.bind(this)),
+      this.handleServiceError
+    );
+    router.delete(
+      '/:id',
+      [...this.exchangeRateIdSchema],
+      this.validationResult,
+      asyncMiddleware(this.deleteExchangeRate.bind(this)),
+      this.handleServiceError
+    );
+    return router;
+  }
+
+  get exchangeRatesListSchema() {
+    return [
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+
+      query('column_sort_by').optional(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+    ];
+  }
+
+  get exchangeRateDTOSchema() {
+    return [
+      check('exchange_rate').exists().isNumeric().toFloat(),
+      check('currency_code').exists().trim().escape(),
+      check('date').exists().isISO8601(),
+    ];
+  }
+
+  get exchangeRateEditDTOSchema() {
+    return [check('exchange_rate').exists().isNumeric().toFloat()];
+  }
+
+  get exchangeRateIdSchema() {
+    return [param('id').isNumeric().toInt()];
+  }
+
+  get exchangeRatesIdsSchema() {
+    return [
+      query('ids').isArray({ min: 2 }),
+      query('ids.*').isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Retrieve exchange rates.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async exchangeRates(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const filter = {
+      page: 1,
+      pageSize: 12,
+      filterRoles: [],
+      columnSortBy: 'created_at',
+      sortOrder: 'asc',
+      ...this.matchedQueryData(req),
+    };
+    if (filter.stringifiedFilterRoles) {
+      filter.filterRoles = JSON.parse(filter.stringifiedFilterRoles);
+    }
+    try {
+      const exchangeRates = await this.exchangeRatesService.listExchangeRates(
+        tenantId,
+        filter
+      );
+      return res.status(200).send({ exchange_rates: exchangeRates });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Adds a new exchange rate on the given date.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async addExchangeRate(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const exchangeRateDTO = this.matchedBodyData(req);
+
+    try {
+      const exchangeRate = await this.exchangeRatesService.newExchangeRate(
+        tenantId,
+        exchangeRateDTO
+      );
+      return res.status(200).send({ id: exchangeRate.id });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Edit the given exchange rate.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async editExchangeRate(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: exchangeRateId } = req.params;
+    const exchangeRateDTO = this.matchedBodyData(req);
+
+    try {
+      const exchangeRate = await this.exchangeRatesService.editExchangeRate(
+        tenantId,
+        exchangeRateId,
+        exchangeRateDTO
+      );
+
+      return res.status(200).send({
+        id: exchangeRateId,
+        message: 'The exchange rate has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Delete the given exchange rate from the storage.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async deleteExchangeRate(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: exchangeRateId } = req.params;
+
+    try {
+      await this.exchangeRatesService.deleteExchangeRate(
+        tenantId,
+        exchangeRateId
+      );
+      return res.status(200).send({ id: exchangeRateId });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handle service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  handleServiceError(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'EXCHANGE_RATE_NOT_FOUND') {
+        return res.status(404).send({
+          errors: [{ type: 'EXCHANGE.RATE.NOT.FOUND', code: 200 }],
+        });
+      }
+      if (error.errorType === 'NOT_FOUND_EXCHANGE_RATES') {
+        return res.status(400).send({
+          errors: [{ type: 'EXCHANGE.RATES.IS.NOT.FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'EXCHANGE_RATE_PERIOD_EXISTS') {
+        return res.status(400).send({
+          errors: [{ type: 'EXCHANGE.RATE.PERIOD.EXISTS', code: 300 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Expenses/Expenses.ts b/packages/server/src/api/controllers/Expenses/Expenses.ts
new file mode 100644
index 000000000..fe3746910
--- /dev/null
+++ b/packages/server/src/api/controllers/Expenses/Expenses.ts
@@ -0,0 +1,456 @@
+import { Inject, Service } from 'typedi';
+import { check, param, query } from 'express-validator';
+import { Router, Request, Response, NextFunction } from 'express';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseController from '@/api/controllers/BaseController';
+import {
+  AbilitySubject,
+  ExpenseAction,
+  IExpenseCreateDTO,
+  IExpenseEditDTO,
+} from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { DATATYPES_LENGTH } from '@/data/DataTypes';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { ExpensesApplication } from '@/services/Expenses/ExpensesApplication';
+
+@Service()
+export class ExpensesController extends BaseController {
+  @Inject()
+  private expensesApplication: ExpensesApplication;
+
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  /**
+   * Express router.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/',
+      CheckPolicies(ExpenseAction.Create, AbilitySubject.Expense),
+      [...this.expenseDTOSchema],
+      this.validationResult,
+      asyncMiddleware(this.newExpense.bind(this)),
+      this.catchServiceErrors
+    );
+    router.post(
+      '/:id/publish',
+      CheckPolicies(ExpenseAction.Edit, AbilitySubject.Expense),
+      [...this.expenseParamSchema],
+      this.validationResult,
+      asyncMiddleware(this.publishExpense.bind(this)),
+      this.catchServiceErrors
+    );
+    router.post(
+      '/:id',
+      CheckPolicies(ExpenseAction.Edit, AbilitySubject.Expense),
+      [...this.editExpenseDTOSchema, ...this.expenseParamSchema],
+      this.validationResult,
+      asyncMiddleware(this.editExpense.bind(this)),
+      this.catchServiceErrors
+    );
+    router.delete(
+      '/:id',
+      CheckPolicies(ExpenseAction.Delete, AbilitySubject.Expense),
+      [...this.expenseParamSchema],
+      this.validationResult,
+      asyncMiddleware(this.deleteExpense.bind(this)),
+      this.catchServiceErrors
+    );
+    router.get(
+      '/',
+      CheckPolicies(ExpenseAction.View, AbilitySubject.Expense),
+      [...this.expensesListSchema],
+      this.validationResult,
+      asyncMiddleware(this.getExpensesList.bind(this)),
+      this.dynamicListService.handlerErrorsToResponse,
+      this.catchServiceErrors
+    );
+    router.get(
+      '/:id',
+      CheckPolicies(ExpenseAction.View, AbilitySubject.Expense),
+      [this.expenseParamSchema],
+      this.validationResult,
+      asyncMiddleware(this.getExpense.bind(this)),
+      this.catchServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Expense DTO schema.
+   */
+  get expenseDTOSchema() {
+    return [
+      check('reference_no')
+        .optional({ nullable: true })
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('payment_date').exists().isISO8601().toDate(),
+      check('payment_account_id')
+        .exists()
+        .isInt({ max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+      check('description')
+        .optional({ nullable: true })
+        .isString()
+        .isLength({ max: DATATYPES_LENGTH.TEXT }),
+      check('currency_code').optional().isString().isLength({ max: 3 }),
+      check('exchange_rate').optional({ nullable: true }).isNumeric().toFloat(),
+      check('publish').optional().isBoolean().toBoolean(),
+      check('payee_id').optional({ nullable: true }).isNumeric().toInt(),
+
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+
+      check('categories').exists().isArray({ min: 1 }),
+      check('categories.*.index')
+        .exists()
+        .isInt({ max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+      check('categories.*.expense_account_id')
+        .exists()
+        .isInt({ max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+      check('categories.*.amount')
+        .optional({ nullable: true })
+        .isFloat({ max: DATATYPES_LENGTH.DECIMAL_13_3 }) // 13, 3
+        .toFloat(),
+      check('categories.*.description')
+        .optional()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('categories.*.landed_cost').optional().isBoolean().toBoolean(),
+      check('categories.*.project_id')
+        .optional({ nullable: true })
+        .isInt({ max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+    ];
+  }
+
+  /**
+   * Edit expense validation schema.
+   */
+  get editExpenseDTOSchema() {
+    return [
+      check('reference_no')
+        .optional({ nullable: true })
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('payment_date').exists().isISO8601().toDate(),
+      check('payment_account_id')
+        .exists()
+        .isInt({ max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+      check('description')
+        .optional({ nullable: true })
+        .isString()
+        .isLength({ max: DATATYPES_LENGTH.TEXT }),
+      check('currency_code').optional().isString().isLength({ max: 3 }),
+      check('exchange_rate').optional({ nullable: true }).isNumeric().toFloat(),
+      check('publish').optional().isBoolean().toBoolean(),
+      check('payee_id').optional({ nullable: true }).isNumeric().toInt(),
+
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+
+      check('categories').exists().isArray({ min: 1 }),
+      check('categories.*.id').optional().isNumeric().toInt(),
+      check('categories.*.index')
+        .exists()
+        .isInt({ max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+      check('categories.*.expense_account_id')
+        .exists()
+        .isInt({ max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+      check('categories.*.amount')
+        .optional({ nullable: true })
+        .isFloat({ max: DATATYPES_LENGTH.DECIMAL_13_3 }) // 13, 3
+        .toFloat(),
+      check('categories.*.description')
+        .optional()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('categories.*.landed_cost').optional().isBoolean().toBoolean(),
+      check('categories.*.project_id')
+        .optional({ nullable: true })
+        .isInt({ max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+    ];
+  }
+
+  /**
+   * Expense param validation schema.
+   */
+  get expenseParamSchema() {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  /**
+   * Expenses list validation schema.
+   */
+  get expensesListSchema() {
+    return [
+      query('view_slug').optional({ nullable: true }).isString().trim(),
+      query('stringified_filter_roles').optional().isJSON(),
+
+      query('column_sort_by').optional(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+
+      query('search_keyword').optional({ nullable: true }).isString().trim(),
+    ];
+  }
+
+  /**
+   * Creates a new expense on
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async newExpense(req: Request, res: Response, next: NextFunction) {
+    const expenseDTO: IExpenseCreateDTO = this.matchedBodyData(req);
+    const { tenantId, user } = req;
+
+    try {
+      const expense = await this.expensesApplication.createExpense(
+        tenantId,
+        expenseDTO,
+        user
+      );
+      return res.status(200).send({
+        id: expense.id,
+        message: 'The expense has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Edits details of the given expense.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async editExpense(req: Request, res: Response, next: NextFunction) {
+    const { id: expenseId } = req.params;
+    const expenseDTO: IExpenseEditDTO = this.matchedBodyData(req);
+    const { tenantId, user } = req;
+
+    try {
+      await this.expensesApplication.editExpense(
+        tenantId,
+        expenseId,
+        expenseDTO,
+        user
+      );
+      return res.status(200).send({
+        id: expenseId,
+        message: 'The expense has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Deletes the given expense.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async deleteExpense(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const { id: expenseId } = req.params;
+
+    try {
+      await this.expensesApplication.deleteExpense(tenantId, expenseId, user);
+
+      return res.status(200).send({
+        id: expenseId,
+        message: 'The expense has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Publishs the given expense.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async publishExpense(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const { id: expenseId } = req.params;
+
+    try {
+      await this.expensesApplication.publishExpense(tenantId, expenseId, user);
+
+      return res.status(200).send({
+        id: expenseId,
+        message: 'The expense has been published successfully',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve expneses list.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async getExpensesList(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const filter = {
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      page: 1,
+      pageSize: 12,
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const { expenses, pagination, filterMeta } =
+        await this.expensesApplication.getExpenses(tenantId, filter);
+
+      return res.status(200).send({
+        expenses: this.transfromToResponse(expenses),
+        pagination: this.transfromToResponse(pagination),
+        filter_meta: this.transfromToResponse(filterMeta),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve expense details.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async getExpense(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: expenseId } = req.params;
+
+    try {
+      const expense = await this.expensesApplication.getExpense(
+        tenantId,
+        expenseId
+      );
+      return res.status(200).send(this.transfromToResponse({ expense }));
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Transform service errors to api response errors.
+   * @param {Response} res
+   * @param {ServiceError} error
+   */
+  private catchServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'expense_not_found') {
+        return res.boom.badRequest('Expense not found.', {
+          errors: [{ type: 'EXPENSE_NOT_FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'EXPENSES_NOT_FOUND') {
+        return res.boom.badRequest('Expenses not found.', {
+          errors: [{ type: 'EXPENSES_NOT_FOUND', code: 110 }],
+        });
+      }
+      if (error.errorType === 'total_amount_equals_zero') {
+        return res.boom.badRequest('Expense total should not equal zero.', {
+          errors: [{ type: 'TOTAL.AMOUNT.EQUALS.ZERO', code: 200 }],
+        });
+      }
+      if (error.errorType === 'payment_account_not_found') {
+        return res.boom.badRequest('Payment account not found.', {
+          errors: [{ type: 'PAYMENT.ACCOUNT.NOT.FOUND', code: 300 }],
+        });
+      }
+      if (error.errorType === 'some_expenses_not_found') {
+        return res.boom.badRequest('Some expense accounts not found.', {
+          errors: [{ type: 'SOME.EXPENSE.ACCOUNTS.NOT.FOUND', code: 400 }],
+        });
+      }
+      if (error.errorType === 'payment_account_has_invalid_type') {
+        return res.boom.badRequest('Payment account has invalid type.', {
+          errors: [{ type: 'PAYMENT.ACCOUNT.HAS.INVALID.TYPE', code: 500 }],
+        });
+      }
+      if (error.errorType === 'expenses_account_has_invalid_type') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'EXPENSES.ACCOUNT.HAS.INVALID.TYPE', code: 600 }],
+        });
+      }
+      if (error.errorType === 'expense_already_published') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'EXPENSE_ALREADY_PUBLISHED', code: 700 }],
+        });
+      }
+      if (error.errorType === 'contact_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CONTACT_NOT_FOUND', code: 800 }],
+        });
+      }
+      if (error.errorType === 'EXPENSE_HAS_ASSOCIATED_LANDED_COST') {
+        return res.status(400).send({
+          errors: [{ type: 'EXPENSE_HAS_ASSOCIATED_LANDED_COST', code: 900 }],
+        });
+      }
+      if (error.errorType === 'ENTRIES_ALLOCATED_COST_COULD_NOT_DELETED') {
+        return res.status(400).send({
+          errors: [
+            { type: 'ENTRIES_ALLOCATED_COST_COULD_NOT_DELETED', code: 1000 },
+          ],
+        });
+      }
+      if (
+        error.errorType === 'LOCATED_COST_ENTRIES_SHOULD_BIGGE_THAN_NEW_ENTRIES'
+      ) {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'LOCATED_COST_ENTRIES_SHOULD_BIGGE_THAN_NEW_ENTRIES',
+              code: 1100,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'TRANSACTIONS_DATE_LOCKED') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'TRANSACTIONS_DATE_LOCKED',
+              code: 4000,
+              data: { ...error.payload },
+            },
+          ],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Expenses/index.ts b/packages/server/src/api/controllers/Expenses/index.ts
new file mode 100644
index 000000000..11744dd28
--- /dev/null
+++ b/packages/server/src/api/controllers/Expenses/index.ts
@@ -0,0 +1,15 @@
+
+import { Router } from 'express';
+import { Container, Service } from 'typedi';
+import { ExpensesController } from './Expenses';
+
+@Service()
+export default class ExpensesBaseController {
+  router() {
+    const router = Router();
+
+    router.use('/', Container.get(ExpensesController).router());
+
+    return router;
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements.ts b/packages/server/src/api/controllers/FinancialStatements.ts
new file mode 100644
index 000000000..cabbb1235
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements.ts
@@ -0,0 +1,107 @@
+import { Router } from 'express';
+import { Container, Service } from 'typedi';
+
+import BalanceSheetController from './FinancialStatements/BalanceSheet';
+import TrialBalanceSheetController from './FinancialStatements/TrialBalanceSheet';
+import GeneralLedgerController from './FinancialStatements/GeneralLedger';
+import JournalSheetController from './FinancialStatements/JournalSheet';
+import ProfitLossController from './FinancialStatements/ProfitLossSheet';
+import ARAgingSummary from './FinancialStatements/ARAgingSummary';
+import APAgingSummary from './FinancialStatements/APAgingSummary';
+import PurchasesByItemsController from './FinancialStatements/PurchasesByItem';
+import SalesByItemsController from './FinancialStatements/SalesByItems';
+import InventoryValuationController from './FinancialStatements/InventoryValuationSheet';
+import CustomerBalanceSummaryController from './FinancialStatements/CustomerBalanceSummary';
+import VendorBalanceSummaryController from './FinancialStatements/VendorBalanceSummary';
+import TransactionsByCustomers from './FinancialStatements/TransactionsByCustomers';
+import TransactionsByVendors from './FinancialStatements/TransactionsByVendors';
+import CashFlowStatementController from './FinancialStatements/CashFlow/CashFlow';
+import InventoryDetailsController from './FinancialStatements/InventoryDetails';
+import TransactionsByReferenceController from './FinancialStatements/TransactionsByReference';
+import CashflowAccountTransactions from './FinancialStatements/CashflowAccountTransactions';
+import ProjectProfitabilityController from './FinancialStatements/ProjectProfitabilitySummary';
+
+@Service()
+export default class FinancialStatementsService {
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.use(
+      '/balance_sheet',
+      Container.get(BalanceSheetController).router()
+    );
+    router.use(
+      '/profit_loss_sheet',
+      Container.get(ProfitLossController).router()
+    );
+    router.use(
+      '/general_ledger',
+      Container.get(GeneralLedgerController).router()
+    );
+    router.use(
+      '/trial_balance_sheet',
+      Container.get(TrialBalanceSheetController).router()
+    );
+    router.use('/journal', Container.get(JournalSheetController).router());
+    router.use(
+      '/receivable_aging_summary',
+      Container.get(ARAgingSummary).router()
+    );
+    router.use(
+      '/payable_aging_summary',
+      Container.get(APAgingSummary).router()
+    );
+    router.use(
+      '/purchases-by-items',
+      Container.get(PurchasesByItemsController).router()
+    );
+    router.use(
+      '/sales-by-items',
+      Container.get(SalesByItemsController).router()
+    );
+    router.use(
+      '/inventory-valuation',
+      Container.get(InventoryValuationController).router()
+    );
+    router.use(
+      '/customer-balance-summary',
+      Container.get(CustomerBalanceSummaryController).router(),
+    );
+    router.use(
+      '/vendor-balance-summary',
+      Container.get(VendorBalanceSummaryController).router(),
+    );
+    router.use(
+      '/transactions-by-customers',
+      Container.get(TransactionsByCustomers).router(),
+    );
+    router.use(
+      '/transactions-by-vendors',
+      Container.get(TransactionsByVendors).router(),
+    );
+    router.use(
+      '/cash-flow',
+      Container.get(CashFlowStatementController).router(),
+    );
+    router.use(
+      '/inventory-item-details',
+      Container.get(InventoryDetailsController).router(),
+    );
+    router.use(
+      '/transactions-by-reference',
+      Container.get(TransactionsByReferenceController).router(),
+    );
+    router.use(
+      '/cashflow-account-transactions',
+      Container.get(CashflowAccountTransactions).router(),
+    );
+    router.use(
+      '/project-profitability-summary',
+      Container.get(ProjectProfitabilityController).router(),
+    )
+    return router;
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/APAgingSummary.ts b/packages/server/src/api/controllers/FinancialStatements/APAgingSummary.ts
new file mode 100644
index 000000000..8bd6c1014
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/APAgingSummary.ts
@@ -0,0 +1,69 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { query } from 'express-validator';
+import { Inject } from 'typedi';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import APAgingSummaryReportService from '@/services/FinancialStatements/AgingSummary/APAgingSummaryService';
+import BaseFinancialReportController from './BaseFinancialReportController';
+import { AbilitySubject, ReportsAction } from '@/interfaces';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+export default class APAgingSummaryReportController extends BaseFinancialReportController {
+  @Inject()
+  APAgingSummaryService: APAgingSummaryReportService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(ReportsAction.READ_AP_AGING_SUMMARY, AbilitySubject.Report),
+      this.validationSchema,
+      asyncMiddleware(this.payableAgingSummary.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Validation schema.
+   */
+  get validationSchema() {
+    return [
+      ...this.sheetNumberFormatValidationSchema,
+      query('as_date').optional().isISO8601(),
+      query('aging_days_before').optional().isNumeric().toInt(),
+      query('aging_periods').optional().isNumeric().toInt(),
+      query('vendors_ids').optional().isArray({ min: 1 }),
+      query('vendors_ids.*').isInt({ min: 1 }).toInt(),
+      query('none_zero').default(true).isBoolean().toBoolean(),
+
+      // Filtering by branches.
+      query('branches_ids').optional().toArray().isArray({ min: 1 }),
+      query('branches_ids.*').isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Retrieve payable aging summary report.
+   */
+  async payableAgingSummary(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, settings } = req;
+    const filter = this.matchedQueryData(req);
+
+    try {
+      const { data, columns, query, meta } =
+        await this.APAgingSummaryService.APAgingSummary(tenantId, filter);
+
+      return res.status(200).send({
+        data: this.transfromToResponse(data),
+        columns: this.transfromToResponse(columns),
+        query: this.transfromToResponse(query),
+        meta: this.transfromToResponse(meta),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/ARAgingSummary.ts b/packages/server/src/api/controllers/FinancialStatements/ARAgingSummary.ts
new file mode 100644
index 000000000..deb69a172
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/ARAgingSummary.ts
@@ -0,0 +1,74 @@
+import { Service, Inject } from 'typedi';
+import { Router, Request, Response } from 'express';
+import { query } from 'express-validator';
+import ARAgingSummaryService from '@/services/FinancialStatements/AgingSummary/ARAgingSummaryService';
+import BaseFinancialReportController from './BaseFinancialReportController';
+import { AbilitySubject, ReportsAction } from '@/interfaces';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+@Service()
+export default class ARAgingSummaryReportController extends BaseFinancialReportController {
+  @Inject()
+  ARAgingSummaryService: ARAgingSummaryService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(ReportsAction.READ_AR_AGING_SUMMARY, AbilitySubject.Report),
+      this.validationSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.receivableAgingSummary.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * AR aging summary validation roles.
+   */
+  get validationSchema() {
+    return [
+      ...this.sheetNumberFormatValidationSchema,
+
+      query('as_date').optional().isISO8601(),
+
+      query('aging_days_before').optional().isInt({ max: 500 }).toInt(),
+      query('aging_periods').optional().isInt({ max: 12 }).toInt(),
+
+      query('customers_ids').optional().isArray({ min: 1 }),
+      query('customers_ids.*').isInt({ min: 1 }).toInt(),
+
+      query('none_zero').default(true).isBoolean().toBoolean(),
+
+      // Filtering by branches.
+      query('branches_ids').optional().toArray().isArray({ min: 1 }),
+      query('branches_ids.*').isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Retrieve AR aging summary report.
+   */
+  async receivableAgingSummary(req: Request, res: Response) {
+    const { tenantId, settings } = req;
+    const filter = this.matchedQueryData(req);
+
+    try {
+      const { data, columns, query, meta } =
+        await this.ARAgingSummaryService.ARAgingSummary(tenantId, filter);
+
+      return res.status(200).send({
+        data: this.transfromToResponse(data),
+        columns: this.transfromToResponse(columns),
+        query: this.transfromToResponse(query),
+        meta: this.transfromToResponse(meta),
+      });
+    } catch (error) {
+      console.log(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/BalanceSheet.ts b/packages/server/src/api/controllers/FinancialStatements/BalanceSheet.ts
new file mode 100644
index 000000000..51df3c9fa
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/BalanceSheet.ts
@@ -0,0 +1,126 @@
+import { Inject, Service } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import { query, ValidationChain } from 'express-validator';
+import { castArray } from 'lodash';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BalanceSheetStatementService from '@/services/FinancialStatements/BalanceSheet/BalanceSheetService';
+import BaseFinancialReportController from './BaseFinancialReportController';
+import { AbilitySubject, ReportsAction } from '@/interfaces';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import BalanceSheetTable from '@/services/FinancialStatements/BalanceSheet/BalanceSheetTable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export default class BalanceSheetStatementController extends BaseFinancialReportController {
+  @Inject()
+  balanceSheetService: BalanceSheetStatementService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(ReportsAction.READ_BALANCE_SHEET, AbilitySubject.Report),
+      this.balanceSheetValidationSchema,
+      this.validationResult,
+      asyncMiddleware(this.balanceSheet.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Balance sheet validation schecma.
+   * @returns {ValidationChain[]}
+   */
+  get balanceSheetValidationSchema(): ValidationChain[] {
+    return [
+      ...this.sheetNumberFormatValidationSchema,
+      query('accounting_method').optional().isIn(['cash', 'accural']),
+
+      query('from_date').optional(),
+      query('to_date').optional(),
+
+      query('display_columns_type').optional().isIn(['date_periods', 'total']),
+      query('display_columns_by')
+        .optional({ nullable: true, checkFalsy: true })
+        .isIn(['year', 'month', 'week', 'day', 'quarter']),
+
+      query('account_ids').isArray().optional(),
+      query('account_ids.*').isNumeric().toInt(),
+
+      query('none_zero').optional().isBoolean().toBoolean(),
+      query('none_transactions').optional().isBoolean().toBoolean(),
+
+      // Percentage of column/row.
+      query('percentage_of_column').optional().isBoolean().toBoolean(),
+      query('percentage_of_row').optional().isBoolean().toBoolean(),
+
+      // Camparsion periods periods.
+      query('previous_period').optional().isBoolean().toBoolean(),
+      query('previous_period_amount_change').optional().isBoolean().toBoolean(),
+      query('previous_period_percentage_change')
+        .optional()
+        .isBoolean()
+        .toBoolean(),
+      // Camparsion periods periods.
+      query('previous_year').optional().isBoolean().toBoolean(),
+      query('previous_year_amount_change').optional().isBoolean().toBoolean(),
+      query('previous_year_percentage_change')
+        .optional()
+        .isBoolean()
+        .toBoolean(),
+
+      // Filtering by branches.
+      query('branches_ids').optional().toArray().isArray({ min: 1 }),
+      query('branches_ids.*').isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Retrieve the balance sheet.
+   */
+  async balanceSheet(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, settings } = req;
+    const i18n = this.tenancy.i18n(tenantId);
+
+    let filter = this.matchedQueryData(req);
+
+    filter = {
+      ...filter,
+      accountsIds: castArray(filter.accountsIds),
+    };
+
+    try {
+      const { data, columns, query, meta } =
+        await this.balanceSheetService.balanceSheet(tenantId, filter);
+
+      const accept = this.accepts(req);
+      const acceptType = accept.types(['json', 'application/json+table']);
+
+      const table = new BalanceSheetTable(data, query, i18n);
+
+      switch (acceptType) {
+        case 'application/json+table':
+          return res.status(200).send({
+            table: {
+              rows: table.tableRows(),
+              columns: table.tableColumns(),
+            },
+            query,
+            meta,
+          });
+        case 'json':
+        default:
+          return res.status(200).send({ data, columns, query, meta });
+      }
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/BaseFinancialReportController.ts b/packages/server/src/api/controllers/FinancialStatements/BaseFinancialReportController.ts
new file mode 100644
index 000000000..7fccd76f1
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/BaseFinancialReportController.ts
@@ -0,0 +1,26 @@
+import { query } from 'express-validator';
+import BaseController from "../BaseController";
+
+export default class BaseFinancialReportController extends BaseController {
+
+
+  get sheetNumberFormatValidationSchema() {
+    return [
+      query('number_format.precision')
+        .optional()
+        .isInt({ min: 0, max: 5 })
+        .toInt(),
+      query('number_format.divide_on_1000').optional().isBoolean().toBoolean(),
+      query('number_format.show_zero').optional().isBoolean().toBoolean(),
+      query('number_format.format_money')
+        .optional()
+        .isIn(['total', 'always', 'none'])
+        .trim(),
+      query('number_format.negative_format')
+        .optional()
+        .isIn(['parentheses', 'mines'])
+        .trim()
+        .escape(),
+    ];
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/api/controllers/FinancialStatements/CashFlow/CashFlow.ts b/packages/server/src/api/controllers/FinancialStatements/CashFlow/CashFlow.ts
new file mode 100644
index 000000000..df2f3f5dd
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/CashFlow/CashFlow.ts
@@ -0,0 +1,137 @@
+import { Inject, Service } from 'typedi';
+import { query } from 'express-validator';
+import {
+  NextFunction,
+  Router,
+  Request,
+  Response,
+  ValidationChain,
+} from 'express';
+import BaseFinancialReportController from '../BaseFinancialReportController';
+import CashFlowStatementService from '@/services/FinancialStatements/CashFlow/CashFlowService';
+import {
+  ICashFlowStatementDOO,
+  ICashFlowStatement,
+  AbilitySubject,
+  ReportsAction,
+} from '@/interfaces';
+import CashFlowTable from '@/services/FinancialStatements/CashFlow/CashFlowTable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+@Service()
+export default class CashFlowController extends BaseFinancialReportController {
+  @Inject()
+  cashFlowService: CashFlowStatementService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(ReportsAction.READ_CASHFLOW, AbilitySubject.Report),
+      this.cashflowValidationSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.cashFlow.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Balance sheet validation schecma.
+   * @returns {ValidationChain[]}
+   */
+  get cashflowValidationSchema(): ValidationChain[] {
+    return [
+      ...this.sheetNumberFormatValidationSchema,
+      query('from_date').optional(),
+      query('to_date').optional(),
+
+      query('display_columns_type').optional().isIn(['date_periods', 'total']),
+      query('display_columns_by')
+        .optional({ nullable: true, checkFalsy: true })
+        .isIn(['year', 'month', 'week', 'day', 'quarter']),
+
+      query('none_zero').optional().isBoolean().toBoolean(),
+      query('none_transactions').optional().isBoolean().toBoolean(),
+
+      // Filtering by branches.
+      query('branches_ids').optional().toArray().isArray({ min: 1 }),
+      query('branches_ids.*').isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Retrieve the cashflow statment to json response.
+   * @param {ICashFlowStatement} cashFlow -
+   */
+  private transformJsonResponse(cashFlowDOO: ICashFlowStatementDOO) {
+    const { data, query, meta } = cashFlowDOO;
+
+    return {
+      data: this.transfromToResponse(data),
+      query: this.transfromToResponse(query),
+      meta: this.transfromToResponse(meta),
+    };
+  }
+
+  /**
+   * Transformes the report statement to table rows.
+   * @param {ITransactionsByVendorsStatement} statement -
+   */
+  private transformToTableRows(
+    cashFlowDOO: ICashFlowStatementDOO,
+    tenantId: number
+  ) {
+    const i18n = this.tenancy.i18n(tenantId);
+    const cashFlowTable = new CashFlowTable(cashFlowDOO, i18n);
+
+    return {
+      table: {
+        data: cashFlowTable.tableRows(),
+        columns: cashFlowTable.tableColumns(),
+      },
+      query: this.transfromToResponse(cashFlowDOO.query),
+      meta: this.transfromToResponse(cashFlowDOO.meta),
+    };
+  }
+
+  /**
+   * Retrieve the cash flow statment.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @returns {Response}
+   */
+  async cashFlow(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, settings } = req;
+    const filter = {
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const cashFlow = await this.cashFlowService.cashFlow(tenantId, filter);
+
+      const accept = this.accepts(req);
+      const acceptType = accept.types(['json', 'application/json+table']);
+
+      switch (acceptType) {
+        case 'application/json+table':
+          return res
+            .status(200)
+            .send(this.transformToTableRows(cashFlow, tenantId));
+        case 'json':
+        default:
+          return res.status(200).send(this.transformJsonResponse(cashFlow));
+      }
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/CashflowAccountTransactions/index.ts b/packages/server/src/api/controllers/FinancialStatements/CashflowAccountTransactions/index.ts
new file mode 100644
index 000000000..b65c450cf
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/CashflowAccountTransactions/index.ts
@@ -0,0 +1,168 @@
+import { Inject, Service } from 'typedi';
+import { query } from 'express-validator';
+import {
+  NextFunction,
+  Router,
+  Request,
+  Response,
+  ValidationChain,
+} from 'express';
+import BaseFinancialReportController from '../BaseFinancialReportController';
+import {
+  AbilitySubject,
+  ICashFlowStatementDOO,
+  ReportsAction,
+} from '@/interfaces';
+import CashFlowTable from '@/services/FinancialStatements/CashFlow/CashFlowTable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import CashflowAccountTransactionsService from '@/services/FinancialStatements/CashflowAccountTransactions/CashflowAccountTransactionsService';
+import { ServiceError } from '@/exceptions';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+@Service()
+export default class CashFlowAccountTransactionsController extends BaseFinancialReportController {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  cashflowAccountTransactions: CashflowAccountTransactionsService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(
+        ReportsAction.READ_CASHFLOW_ACCOUNT_TRANSACTION,
+        AbilitySubject.Report
+      ),
+      this.validationSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.cashFlow),
+      this.catchServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Cashflow account transactions validation schecma.
+   * @returns {ValidationChain[]}
+   */
+  get validationSchema(): ValidationChain[] {
+    return [
+      query('account_id').exists().isInt().toInt(),
+
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Retrieve the cashflow account transactions statment to json response.
+   * @param {ICashFlowStatement} cashFlow -
+   */
+  private transformJsonResponse(casahflowAccountTransactions) {
+    const { transactions, pagination } = casahflowAccountTransactions;
+
+    return {
+      transactions: this.transfromToResponse(transactions),
+      pagination: this.transfromToResponse(pagination),
+    };
+  }
+
+  /**
+   * Transformes the report statement to table rows.
+   * @param {ITransactionsByVendorsStatement} statement -
+   */
+  private transformToTableRows(
+    cashFlowDOO: ICashFlowStatementDOO,
+    tenantId: number
+  ) {
+    const i18n = this.tenancy.i18n(tenantId);
+    const cashFlowTable = new CashFlowTable(cashFlowDOO, i18n);
+
+    return {
+      table: {
+        data: cashFlowTable.tableRows(),
+        columns: cashFlowTable.tableColumns(),
+      },
+      query: this.transfromToResponse(cashFlowDOO.query),
+      meta: this.transfromToResponse(cashFlowDOO.meta),
+    };
+  }
+
+  /**
+   * Retrieve the cash flow statment.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @returns {Response}
+   */
+  private cashFlow = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const query = this.matchedQueryData(req);
+
+    try {
+      const cashFlowAccountTransactions =
+        await this.cashflowAccountTransactions.cashflowAccountTransactions(
+          tenantId,
+          query
+        );
+
+      const accept = this.accepts(req);
+      const acceptType = accept.types(['json', 'application/json+table']);
+
+      switch (acceptType) {
+        // case 'application/json+table':
+        //   return res
+        //     .status(200)
+        //     .send(this.transformToTableRows(cashFlow, tenantId));
+        case 'json':
+        default:
+          return res
+            .status(200)
+            .send(this.transformJsonResponse(cashFlowAccountTransactions));
+      }
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Catches the service errors.
+   * @param {Error} error - Error.
+   * @param {Request} req - Request.
+   * @param {Response} res - Response.
+   * @param {NextFunction} next -
+   */
+  private catchServiceErrors(
+    error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'ACCOUNT_ID_HAS_INVALID_TYPE') {
+        return res.boom.badRequest(
+          'The given account id should be cash, bank or credit card type.',
+          {
+            errors: [{ type: 'ACCOUNT_ID_HAS_INVALID_TYPE', code: 200 }],
+          }
+        );
+      }
+      if (error.errorType === 'account_not_found') {
+        return res.boom.notFound('The given account not found.', {
+          errors: [{ type: 'ACCOUNT.NOT.FOUND', code: 100 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/CustomerBalanceSummary/index.ts b/packages/server/src/api/controllers/FinancialStatements/CustomerBalanceSummary/index.ts
new file mode 100644
index 000000000..eb026e752
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/CustomerBalanceSummary/index.ts
@@ -0,0 +1,139 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { query } from 'express-validator';
+import { Inject } from 'typedi';
+import {
+  AbilitySubject,
+  ICustomerBalanceSummaryStatement,
+  ReportsAction,
+} from '@/interfaces';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import CustomerBalanceSummary from '@/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummaryService';
+import BaseFinancialReportController from '../BaseFinancialReportController';
+import CustomerBalanceSummaryTableRows from '@/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummaryTableRows';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+export default class CustomerBalanceSummaryReportController extends BaseFinancialReportController {
+  @Inject()
+  customerBalanceSummaryService: CustomerBalanceSummary;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(
+        ReportsAction.READ_CUSTOMERS_SUMMARY_BALANCE,
+        AbilitySubject.Report
+      ),
+      this.validationSchema,
+      this.validationResult,
+      asyncMiddleware(this.customerBalanceSummary.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Validation schema.
+   */
+  get validationSchema() {
+    return [
+      ...this.sheetNumberFormatValidationSchema,
+
+      // As date.
+      query('as_date').optional().isISO8601(),
+
+      // Percentages.
+      query('percentage_column').optional().isBoolean().toBoolean(),
+
+      // Filters none-zero or none-transactions.
+      query('none_zero').optional().isBoolean().toBoolean(),
+      query('none_transactions').optional().isBoolean().toBoolean(),
+
+      // Customers ids.
+      query('customers_ids').optional().isArray({ min: 1 }),
+      query('customers_ids.*').exists().isInt().toInt(),
+    ];
+  }
+
+  /**
+   * Transformes the balance summary statement to table rows.
+   * @param {ICustomerBalanceSummaryStatement} statement -
+   */
+  private transformToTableRows(
+    tenantId,
+    { data, query }: ICustomerBalanceSummaryStatement
+  ) {
+    const i18n = this.tenancy.i18n(tenantId);
+    const tableRows = new CustomerBalanceSummaryTableRows(data, query, i18n);
+
+    return {
+      table: {
+        columns: tableRows.tableColumns(),
+        data: tableRows.tableRows(),
+      },
+      query: this.transfromToResponse(query),
+    };
+  }
+
+  /**
+   * Transformes the balance summary statement to raw json.
+   * @param {ICustomerBalanceSummaryStatement} customerBalance -
+   */
+  private transformToJsonResponse({
+    data,
+    columns,
+    query,
+  }: ICustomerBalanceSummaryStatement) {
+    return {
+      data: this.transfromToResponse(data),
+      columns: this.transfromToResponse(columns),
+      query: this.transfromToResponse(query),
+    };
+  }
+
+  /**
+   * Retrieve payable aging summary report.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  async customerBalanceSummary(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId, settings } = req;
+    const filter = this.matchedQueryData(req);
+
+    try {
+      const customerBalanceSummary =
+        await this.customerBalanceSummaryService.customerBalanceSummary(
+          tenantId,
+          filter
+        );
+      const accept = this.accepts(req);
+      const acceptType = accept.types(['json', 'application/json+table']);
+
+      switch (acceptType) {
+        case 'application/json+table':
+          return res
+            .status(200)
+            .send(this.transformToTableRows(tenantId, customerBalanceSummary));
+        case 'application/json':
+        default:
+          return res
+            .status(200)
+            .send(this.transformToJsonResponse(customerBalanceSummary));
+      }
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/GeneralLedger.ts b/packages/server/src/api/controllers/FinancialStatements/GeneralLedger.ts
new file mode 100644
index 000000000..90955be15
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/GeneralLedger.ts
@@ -0,0 +1,79 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { query, ValidationChain } from 'express-validator';
+import { Inject, Service } from 'typedi';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import GeneralLedgerService from '@/services/FinancialStatements/GeneralLedger/GeneralLedgerService';
+import BaseFinancialReportController from './BaseFinancialReportController';
+import { AbilitySubject, ReportsAction } from '@/interfaces';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+@Service()
+export default class GeneralLedgerReportController extends BaseFinancialReportController {
+  @Inject()
+  generalLedgetService: GeneralLedgerService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(ReportsAction.READ_GENERAL_LEDGET, AbilitySubject.Report),
+      this.validationSchema,
+      this.validationResult,
+      asyncMiddleware(this.generalLedger.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Validation schema.
+   */
+  get validationSchema(): ValidationChain[] {
+    return [
+      query('from_date').optional().isISO8601(),
+      query('to_date').optional().isISO8601(),
+
+      query('basis').optional(),
+
+      query('number_format.no_cents').optional().isBoolean().toBoolean(),
+      query('number_format.divide_1000').optional().isBoolean().toBoolean(),
+
+      query('none_transactions').default(true).isBoolean().toBoolean(),
+
+      query('accounts_ids').optional().isArray({ min: 1 }),
+      query('accounts_ids.*').isInt().toInt(),
+
+      query('orderBy').optional().isIn(['created_at', 'name', 'code']),
+      query('order').optional().isIn(['desc', 'asc']),
+
+      // Filtering by branches.
+      query('branches_ids').optional().toArray().isArray({ min: 1 }),
+      query('branches_ids.*').isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Retrieve the general ledger financial statement.
+   * @param {Request} req -
+   * @param {Response} res -
+   */
+  async generalLedger(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, settings } = req;
+    const filter = this.matchedQueryData(req);
+
+    try {
+      const { data, query, meta } =
+        await this.generalLedgetService.generalLedger(tenantId, filter);
+      return res.status(200).send({
+        meta: this.transfromToResponse(meta),
+        data: this.transfromToResponse(data),
+        query: this.transfromToResponse(query),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/InventoryDetails/index.ts b/packages/server/src/api/controllers/FinancialStatements/InventoryDetails/index.ts
new file mode 100644
index 000000000..2f8df7722
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/InventoryDetails/index.ts
@@ -0,0 +1,148 @@
+import { Inject, Service } from 'typedi';
+import { query } from 'express-validator';
+import {
+  NextFunction,
+  Router,
+  Request,
+  Response,
+  ValidationChain,
+} from 'express';
+import BaseController from '@/api/controllers/BaseController';
+import InventoryDetailsService from '@/services/FinancialStatements/InventoryDetails/InventoryDetailsService';
+import InventoryDetailsTable from '@/services/FinancialStatements/InventoryDetails/InventoryDetailsTable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { AbilitySubject, ReportsAction } from '@/interfaces';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+@Service()
+export default class InventoryDetailsController extends BaseController {
+  @Inject()
+  inventoryDetailsService: InventoryDetailsService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(
+        ReportsAction.READ_INVENTORY_ITEM_DETAILS,
+        AbilitySubject.Report
+      ),
+      this.validationSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.inventoryDetails.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Balance sheet validation schecma.
+   * @returns {ValidationChain[]}
+   */
+  get validationSchema(): ValidationChain[] {
+    return [
+      query('number_format.precision')
+        .optional()
+        .isInt({ min: 0, max: 5 })
+        .toInt(),
+      query('number_format.divide_on_1000').optional().isBoolean().toBoolean(),
+      query('number_format.negative_format')
+        .optional()
+        .isIn(['parentheses', 'mines'])
+        .trim()
+        .escape(),
+      query('from_date').optional(),
+      query('to_date').optional(),
+
+      query('none_zero').optional().isBoolean().toBoolean(),
+      query('none_transactions').optional().isBoolean().toBoolean(),
+
+      query('items_ids').optional().isArray(),
+      query('items_ids.*').optional().isInt().toInt(),
+
+      // Filtering by branches.
+      query('branches_ids').optional().toArray().isArray({ min: 1 }),
+      query('branches_ids.*').isNumeric().toInt(),
+
+      // Filtering by warehouses.
+      query('warehouses_ids').optional().toArray().isArray({ min: 1 }),
+      query('warehouses_ids.*').isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Retrieve the cashflow statment to json response.
+   * @param {ICashFlowStatement} cashFlow -
+   */
+  private transformJsonResponse(inventoryDetails) {
+    const { data, query, meta } = inventoryDetails;
+
+    return {
+      data: this.transfromToResponse(data),
+      query: this.transfromToResponse(query),
+      meta: this.transfromToResponse(meta),
+    };
+  }
+
+  /**
+   * Transformes the report statement to table rows.
+   */
+  private transformToTableRows(inventoryDetails, tenantId: number) {
+    const i18n = this.tenancy.i18n(tenantId);
+    const inventoryDetailsTable = new InventoryDetailsTable(
+      inventoryDetails,
+      i18n
+    );
+
+    return {
+      table: {
+        data: inventoryDetailsTable.tableData(),
+        columns: inventoryDetailsTable.tableColumns(),
+      },
+      query: this.transfromToResponse(inventoryDetails.query),
+      meta: this.transfromToResponse(inventoryDetails.meta),
+    };
+  }
+
+  /**
+   * Retrieve the cash flow statment.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @returns {Response}
+   */
+  async inventoryDetails(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, settings } = req;
+    const filter = {
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const inventoryDetails =
+        await this.inventoryDetailsService.inventoryDetails(tenantId, filter);
+
+      const accept = this.accepts(req);
+      const acceptType = accept.types(['json', 'application/json+table']);
+
+      switch (acceptType) {
+        case 'application/json+table':
+          return res
+            .status(200)
+            .send(this.transformToTableRows(inventoryDetails, tenantId));
+        case 'json':
+        default:
+          return res
+            .status(200)
+            .send(this.transformJsonResponse(inventoryDetails));
+      }
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/InventoryValuationSheet.ts b/packages/server/src/api/controllers/FinancialStatements/InventoryValuationSheet.ts
new file mode 100644
index 000000000..a98c8c997
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/InventoryValuationSheet.ts
@@ -0,0 +1,89 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { query, ValidationChain } from 'express-validator';
+import { Inject, Service } from 'typedi';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseFinancialReportController from './BaseFinancialReportController';
+import InventoryValuationService from '@/services/FinancialStatements/InventoryValuationSheet/InventoryValuationSheetService';
+import { AbilitySubject, ReportsAction } from '@/interfaces';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+@Service()
+export default class InventoryValuationReportController extends BaseFinancialReportController {
+  @Inject()
+  inventoryValuationService: InventoryValuationService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(
+        ReportsAction.READ_INVENTORY_VALUATION_SUMMARY,
+        AbilitySubject.Report
+      ),
+      this.validationSchema,
+      this.validationResult,
+      asyncMiddleware(this.inventoryValuation.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Validation schema.
+   */
+  get validationSchema(): ValidationChain[] {
+    return [
+      query('from_date').optional().isISO8601(),
+      query('to_date').optional().isISO8601(),
+
+      query('items_ids').optional().isArray(),
+      query('items_ids.*').optional().isInt().toInt(),
+
+      query('number_format.no_cents').optional().isBoolean().toBoolean(),
+      query('number_format.divide_1000').optional().isBoolean().toBoolean(),
+
+      query('none_transactions').default(true).isBoolean().toBoolean(),
+      query('none_zero').default(false).isBoolean().toBoolean(),
+      query('only_active').default(false).isBoolean().toBoolean(),
+
+      query('orderBy').optional().isIn(['created_at', 'name', 'code']),
+      query('order').optional().isIn(['desc', 'asc']),
+
+      // Filtering by branches.
+      query('branches_ids').optional().toArray().isArray({ min: 1 }),
+      query('branches_ids.*').isNumeric().toInt(),
+
+      // Filtering by warehouses.
+      query('warehouses_ids').optional().toArray().isArray({ min: 1 }),
+      query('warehouses_ids.*').isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Retrieve the general ledger financial statement.
+   * @param {Request} req -
+   * @param {Response} res -
+   */
+  async inventoryValuation(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const filter = this.matchedQueryData(req);
+
+    try {
+      const { data, query, meta } =
+        await this.inventoryValuationService.inventoryValuationSheet(
+          tenantId,
+          filter
+        );
+      return res.status(200).send({
+        meta: this.transfromToResponse(meta),
+        data: this.transfromToResponse(data),
+        query: this.transfromToResponse(query),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/JournalSheet.ts b/packages/server/src/api/controllers/FinancialStatements/JournalSheet.ts
new file mode 100644
index 000000000..ebd6074f4
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/JournalSheet.ts
@@ -0,0 +1,84 @@
+import { Inject, Service } from 'typedi';
+import { Request, Response, Router, NextFunction } from 'express';
+import { castArray } from 'lodash';
+import { query, oneOf } from 'express-validator';
+import BaseFinancialReportController from './BaseFinancialReportController';
+import JournalSheetService from '@/services/FinancialStatements/JournalSheet/JournalSheetService';
+import { AbilitySubject, ReportsAction } from '@/interfaces';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+@Service()
+export default class JournalSheetController extends BaseFinancialReportController {
+  @Inject()
+  journalService: JournalSheetService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(ReportsAction.READ_JOURNAL, AbilitySubject.Report),
+      this.journalValidationSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.journal.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Validation schema.
+   */
+  get journalValidationSchema() {
+    return [
+      query('from_date').optional().isISO8601(),
+      query('to_date').optional().isISO8601(),
+      query('transaction_type').optional().trim().escape(),
+      query('transaction_id').optional().isInt().toInt(),
+      oneOf(
+        [
+          query('account_ids').optional().isArray({ min: 1 }),
+          query('account_ids.*').optional().isNumeric().toInt(),
+        ],
+        [query('account_ids').optional().isNumeric().toInt()]
+      ),
+      query('from_range').optional().isNumeric().toInt(),
+      query('to_range').optional().isNumeric().toInt(),
+
+      query('number_format.no_cents').optional().isBoolean().toBoolean(),
+      query('number_format.divide_1000').optional().isBoolean().toBoolean(),
+    ];
+  }
+
+  /**
+   * Retrieve the ledger report of the given account.
+   * @param {Request} req -
+   * @param {Response} res -
+   */
+  async journal(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, settings } = req;
+    let filter = this.matchedQueryData(req);
+
+    filter = {
+      ...filter,
+      accountsIds: castArray(filter.accountsIds),
+    };
+
+    try {
+      const { data, query, meta } = await this.journalService.journalSheet(
+        tenantId,
+        filter
+      );
+
+      return res.status(200).send({
+        data: this.transfromToResponse(data),
+        query: this.transfromToResponse(query),
+        meta: this.transfromToResponse(meta),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/ProfitLossSheet.ts b/packages/server/src/api/controllers/FinancialStatements/ProfitLossSheet.ts
new file mode 100644
index 000000000..233654dc0
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/ProfitLossSheet.ts
@@ -0,0 +1,124 @@
+import { Service, Inject } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import { query, ValidationChain } from 'express-validator';
+import ProfitLossSheetService from '@/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetService';
+import BaseFinancialReportController from './BaseFinancialReportController';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { AbilitySubject, ReportsAction } from '@/interfaces';
+import { ProfitLossSheetTable } from '@/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetTable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+@Service()
+export default class ProfitLossSheetController extends BaseFinancialReportController {
+  @Inject()
+  profitLossSheetService: ProfitLossSheetService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(ReportsAction.READ_PROFIT_LOSS, AbilitySubject.Report),
+      this.validationSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.profitLossSheet.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Validation schema.
+   */
+  get validationSchema(): ValidationChain[] {
+    return [
+      ...this.sheetNumberFormatValidationSchema,
+      query('basis').optional(),
+
+      query('from_date').optional().isISO8601().toDate(),
+      query('to_date').optional().isISO8601().toDate(),
+
+      query('none_zero').optional().isBoolean().toBoolean(),
+      query('none_transactions').optional().isBoolean().toBoolean(),
+
+      query('accounts_ids').isArray().optional(),
+      query('accounts_ids.*').isNumeric().toInt(),
+
+      query('display_columns_type').optional().isIn(['total', 'date_periods']),
+      query('display_columns_by')
+        .optional({ nullable: true, checkFalsy: true })
+        .isIn(['year', 'month', 'week', 'day', 'quarter']),
+
+      // Percentage options.
+      query('percentage_column').optional().isBoolean().toBoolean(),
+      query('percentage_row').optional().isBoolean().toBoolean(),
+      query('percentage_expense').optional().isBoolean().toBoolean(),
+      query('percentage_income').optional().isBoolean().toBoolean(),
+
+      // Camparsion periods periods.
+      query('previous_period').optional().isBoolean().toBoolean(),
+      query('previous_period_amount_change').optional().isBoolean().toBoolean(),
+      query('previous_period_percentage_change')
+        .optional()
+        .isBoolean()
+        .toBoolean(),
+      // Camparsion periods periods.
+      query('previous_year').optional().isBoolean().toBoolean(),
+      query('previous_year_amount_change').optional().isBoolean().toBoolean(),
+      query('previous_year_percentage_change')
+        .optional()
+        .isBoolean()
+        .toBoolean(),
+
+      // Filtering by branches.
+      query('branches_ids').optional().isArray({ min: 1 }),
+      query('branches_ids.*').isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Retrieve profit/loss financial statement.
+   * @param {Request} req -
+   * @param {Response} res -
+   */
+  async profitLossSheet(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, settings } = req;
+    const i18n = this.tenancy.i18n(tenantId);
+    const filter = this.matchedQueryData(req);
+
+    try {
+      const { data, query, meta } =
+        await this.profitLossSheetService.profitLossSheet(tenantId, filter);
+
+      const accept = this.accepts(req);
+      const acceptType = accept.types(['json', 'application/json+table']);
+
+      switch (acceptType) {
+        case 'application/json+table':
+          const table = new ProfitLossSheetTable(data, query, i18n);
+
+          return res.status(200).send({
+            table: {
+              rows: table.tableRows(),
+              columns: table.tableColumns(),
+            },
+            query,
+            meta,
+          });
+        case 'json':
+        default:
+          return res.status(200).send({
+            data,
+            query,
+            meta,
+          });
+      }
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/ProjectProfitabilitySummary/index.ts b/packages/server/src/api/controllers/FinancialStatements/ProjectProfitabilitySummary/index.ts
new file mode 100644
index 000000000..26795fc9a
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/ProjectProfitabilitySummary/index.ts
@@ -0,0 +1,151 @@
+import { Inject, Service } from 'typedi';
+import { query } from 'express-validator';
+import {
+  NextFunction,
+  Router,
+  Request,
+  Response,
+  ValidationChain,
+} from 'express';
+import BaseFinancialReportController from '../BaseFinancialReportController';
+import {
+  ICashFlowStatementDOO,
+  AbilitySubject,
+  ReportsAction,
+  IProjectProfitabilitySummaryPOJO,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { ProjectProfitabilitySummaryTable } from '@/services/FinancialStatements/ProjectProfitabilitySummary/ProjectProfitabilitySummaryTable';
+import { ProjectProfitabilitySummaryService } from '@/services/FinancialStatements/ProjectProfitabilitySummary/ProjectProfitabilitySummaryService';
+
+@Service()
+export default class ProjectProfitabilityController extends BaseFinancialReportController {
+  @Inject()
+  private projectProfitabilityService: ProjectProfitabilitySummaryService;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(
+        ReportsAction.READ_PROJECT_PROFITABILITY_SUMMARY,
+        AbilitySubject.Report
+      ),
+      this.validationSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.projectProfitabilitySummary.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Balance sheet validation schecma.
+   * @returns {ValidationChain[]}
+   */
+  get validationSchema(): ValidationChain[] {
+    return [
+      ...this.sheetNumberFormatValidationSchema,
+      query('from_date').optional(),
+      query('to_date').optional(),
+
+      query('none_zero').optional().isBoolean().toBoolean(),
+      query('none_transactions').optional().isBoolean().toBoolean(),
+
+      // Filtering by projects.
+      query('products_ids').optional().toArray().isArray({ min: 1 }),
+      query('products_ids.*').isNumeric().toInt(),
+
+      // Filtering by branches.
+      query('branches_ids').optional().toArray().isArray({ min: 1 }),
+      query('branches_ids.*').isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Retrieve the cashflow statment to json response.
+   * @param {ICashFlowStatement} cashFlow -
+   */
+  private transformJsonResponse(projectProfitabilityPOJO: IProjectProfitabilitySummaryPOJO) {
+    const { data, query, meta } = projectProfitabilityPOJO;
+
+    return {
+      data: this.transfromToResponse(data),
+      query: this.transfromToResponse(query),
+      meta: this.transfromToResponse(meta),
+    };
+  }
+
+  /**
+   * Transformes the report statement to table rows.
+   * @param {ITransactionsByVendorsStatement} statement -
+   */
+  private transformToTableRows(
+    projectProfitabilityPOJO: IProjectProfitabilitySummaryPOJO,
+    tenantId: number
+  ) {
+    const i18n = this.tenancy.i18n(tenantId);
+    const projectProfitabilityTable = new ProjectProfitabilitySummaryTable(
+      projectProfitabilityPOJO.data,
+      i18n
+    );
+
+    return {
+      table: {
+        data: projectProfitabilityTable.tableData(),
+        columns: projectProfitabilityTable.tableColumns(),
+      },
+      query: this.transfromToResponse(projectProfitabilityPOJO.query),
+      // meta: this.transfromToResponse(cashFlowDOO.meta),
+    };
+  }
+
+  /**
+   * Retrieve the cash flow statment.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @returns {Response}
+   */
+  async projectProfitabilitySummary(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+    const filter = {
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const projectProfitability =
+        await this.projectProfitabilityService.projectProfitabilitySummary(
+          tenantId,
+          filter
+        );
+      const accept = this.accepts(req);
+      const acceptType = accept.types(['json', 'application/json+table']);
+
+      switch (acceptType) {
+        case 'application/json+table':
+          return res
+            .status(200)
+            .send(this.transformToTableRows(projectProfitability, tenantId));
+        case 'json':
+        default:
+          return res
+            .status(200)
+            .send(this.transformJsonResponse(projectProfitability));
+      }
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/PurchasesByItem.ts b/packages/server/src/api/controllers/FinancialStatements/PurchasesByItem.ts
new file mode 100644
index 000000000..5e7aacb09
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/PurchasesByItem.ts
@@ -0,0 +1,82 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { query, ValidationChain } from 'express-validator';
+import moment from 'moment';
+import { Inject, Service } from 'typedi';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseFinancialReportController from './BaseFinancialReportController';
+import PurchasesByItemsService from '@/services/FinancialStatements/PurchasesByItems/PurchasesByItemsService';
+import { AbilitySubject, ReportsAction } from '@/interfaces';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+@Service()
+export default class PurchasesByItemReportController extends BaseFinancialReportController {
+  @Inject()
+  purchasesByItemsService: PurchasesByItemsService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(
+        ReportsAction.READ_PURCHASES_BY_ITEMS,
+        AbilitySubject.Report
+      ),
+      this.validationSchema,
+      this.validationResult,
+      asyncMiddleware(this.purchasesByItems.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Validation schema.
+   * @return {ValidationChain[]}
+   */
+  get validationSchema(): ValidationChain[] {
+    return [
+      query('from_date').optional().isISO8601(),
+      query('to_date').optional().isISO8601(),
+
+      // Filter items.
+      query('number_format.no_cents').optional().isBoolean().toBoolean(),
+      query('number_format.divide_1000').optional().isBoolean().toBoolean(),
+
+      // Filters items.
+      query('none_transactions').optional().isBoolean().toBoolean(),
+      query('only_active').optional().isBoolean().toBoolean(),
+
+      // Specific items.
+      query('items_ids').optional().isArray(),
+      query('items_ids.*').optional().isInt().toInt(),
+
+      query('orderBy').optional().isIn(['created_at', 'name', 'code']),
+      query('order').optional().isIn(['desc', 'asc']),
+    ];
+  }
+
+  /**
+   * Retrieve the general ledger financial statement.
+   * @param {Request} req -
+   * @param {Response} res -
+   */
+  async purchasesByItems(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const filter = this.matchedQueryData(req);
+
+    try {
+      const { data, query, meta } =
+        await this.purchasesByItemsService.purchasesByItems(tenantId, filter);
+      return res.status(200).send({
+        meta: this.transfromToResponse(meta),
+        data: this.transfromToResponse(data),
+        query: this.transfromToResponse(query),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/SalesByItems.ts b/packages/server/src/api/controllers/FinancialStatements/SalesByItems.ts
new file mode 100644
index 000000000..759165bd1
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/SalesByItems.ts
@@ -0,0 +1,84 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { query, ValidationChain } from 'express-validator';
+import moment from 'moment';
+import { Inject, Service } from 'typedi';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseFinancialReportController from './BaseFinancialReportController';
+import SalesByItemsReportService from '@/services/FinancialStatements/SalesByItems/SalesByItemsService';
+import { AbilitySubject, ReportsAction } from '@/interfaces';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+@Service()
+export default class SalesByItemsReportController extends BaseFinancialReportController {
+  @Inject()
+  salesByItemsService: SalesByItemsReportService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(
+        ReportsAction.READ_SALES_BY_ITEMS,
+        AbilitySubject.Report
+      ),
+      this.validationSchema,
+      this.validationResult,
+      asyncMiddleware(this.purchasesByItems.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Validation schema.
+   */
+  get validationSchema(): ValidationChain[] {
+    return [
+      query('from_date').optional().isISO8601(),
+      query('to_date').optional().isISO8601(),
+
+      // Specific items.
+      query('items_ids').optional().isArray(),
+      query('items_ids.*').optional().isInt().toInt(),
+
+      // Number format.
+      query('number_format.no_cents').optional().isBoolean().toBoolean(),
+      query('number_format.divide_1000').optional().isBoolean().toBoolean(),
+
+      // Filters items.
+      query('none_transactions').default(true).isBoolean().toBoolean(),
+      query('only_active').default(false).isBoolean().toBoolean(),
+
+      // Order by.
+      query('orderBy').optional().isIn(['created_at', 'name', 'code']),
+      query('order').optional().isIn(['desc', 'asc']),
+    ];
+  }
+
+  /**
+   * Retrieve the general ledger financial statement.
+   * @param {Request} req -
+   * @param {Response} res -
+   */
+  async purchasesByItems(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const filter = this.matchedQueryData(req);
+
+    try {
+      const { data, query, meta } = await this.salesByItemsService.salesByItems(
+        tenantId,
+        filter
+      );
+      return res.status(200).send({
+        meta: this.transfromToResponse(meta),
+        data: this.transfromToResponse(data),
+        query: this.transfromToResponse(query),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/TransactionsByCustomers/index.ts b/packages/server/src/api/controllers/FinancialStatements/TransactionsByCustomers/index.ts
new file mode 100644
index 000000000..fa20ea3f3
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/TransactionsByCustomers/index.ts
@@ -0,0 +1,131 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { query } from 'express-validator';
+import { Inject, Service } from 'typedi';
+import {
+  AbilitySubject,
+  ITransactionsByCustomersStatement,
+  ReportsAction,
+} from '@/interfaces';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseFinancialReportController from '../BaseFinancialReportController';
+import TransactionsByCustomersService from '@/services/FinancialStatements/TransactionsByCustomer/TransactionsByCustomersService';
+import TransactionsByCustomersTableRows from '@/services/FinancialStatements/TransactionsByCustomer/TransactionsByCustomersTableRows';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+@Service()
+export default class TransactionsByCustomersReportController extends BaseFinancialReportController {
+  @Inject()
+  transactionsByCustomersService: TransactionsByCustomersService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(
+        ReportsAction.READ_CUSTOMERS_TRANSACTIONS,
+        AbilitySubject.Report
+      ),
+      this.validationSchema,
+      this.validationResult,
+      asyncMiddleware(this.transactionsByCustomers.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Validation schema.
+   */
+  private get validationSchema() {
+    return [
+      ...this.sheetNumberFormatValidationSchema,
+      query('from_date').optional().isISO8601(),
+      query('to_date').optional().isISO8601(),
+
+      query('none_zero').optional().isBoolean().toBoolean(),
+      query('none_transactions').optional().isBoolean().toBoolean(),
+
+      // Customers ids.
+      query('customers_ids').optional().isArray({ min: 1 }),
+      query('customers_ids.*').exists().isInt().toInt(),
+    ];
+  }
+
+  /**
+   * Transformes the statement to table rows response.
+   * @param {ITransactionsByCustomersStatement} statement -
+   */
+  private transformToTableResponse(customersTransactions, tenantId) {
+    const i18n = this.tenancy.i18n(tenantId);
+    const table = new TransactionsByCustomersTableRows(
+      customersTransactions,
+      i18n
+    );
+    return {
+      table: {
+        rows: table.tableRows(),
+      },
+    };
+  }
+
+  /**
+   * Transformes the statement to json response.
+   * @param {ITransactionsByCustomersStatement} statement -
+   */
+  private transfromToJsonResponse(
+    data,
+    columns
+  ): ITransactionsByCustomersStatement {
+    return {
+      data: this.transfromToResponse(data),
+      columns: this.transfromToResponse(columns),
+      query: this.transfromToResponse(query),
+    };
+  }
+
+  /**
+   * Retrieve payable aging summary report.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  async transactionsByCustomers(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+    const filter = this.matchedQueryData(req);
+
+    try {
+      const report =
+        await this.transactionsByCustomersService.transactionsByCustomers(
+          tenantId,
+          filter
+        );
+      const accept = this.accepts(req);
+      const acceptType = accept.types(['json', 'application/json+table']);
+
+      switch (acceptType) {
+        case 'json':
+          return res
+            .status(200)
+            .send(this.transfromToJsonResponse(report.data, report.columns));
+        case 'application/json+table':
+        default:
+          return res
+            .status(200)
+            .send(this.transformToTableResponse(report.data, tenantId));
+      }
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/TransactionsByReference/index.ts b/packages/server/src/api/controllers/FinancialStatements/TransactionsByReference/index.ts
new file mode 100644
index 000000000..d11c6004c
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/TransactionsByReference/index.ts
@@ -0,0 +1,90 @@
+import { Inject, Service } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import { query, ValidationChain } from 'express-validator';
+import BaseController from '@/api/controllers/BaseController';
+import TransactionsByReferenceService from '@/services/FinancialStatements/TransactionsByReference';
+import { ITransactionsByReferenceTransaction } from '@/interfaces';
+@Service()
+export default class TransactionsByReferenceController extends BaseController {
+  @Inject()
+  private transactionsByReferenceService: TransactionsByReferenceService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      this.validationSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.transactionsByReference.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Validation schema.
+   */
+  get validationSchema(): ValidationChain[] {
+    return [
+      query('reference_id').exists().isInt(),
+      query('reference_type').exists().isString(),
+
+      query('number_format.precision')
+        .optional()
+        .isInt({ min: 0, max: 5 })
+        .toInt(),
+      query('number_format.divide_on_1000').optional().isBoolean().toBoolean(),
+      query('number_format.negative_format')
+        .optional()
+        .isIn(['parentheses', 'mines'])
+        .trim()
+        .escape(),
+    ];
+  }
+
+  /**
+   * Retrieve transactions by the given reference type and id.
+   * @param {Request} req - Request object.
+   * @param {Response} res - Response.
+   * @param {NextFunction} next
+   * @returns
+   */
+  public async transactionsByReference(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+    const filter = this.matchedQueryData(req);
+
+    try {
+      const data =
+        await this.transactionsByReferenceService.getTransactionsByReference(
+          tenantId,
+          filter
+        );
+
+      return res
+        .status(200)
+        .send(this.transformToJsonResponse(data.transactions));
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Transformes the given report transaction to json response.
+   * @param transactions
+   * @returns
+   */
+  private transformToJsonResponse(
+    transactions: ITransactionsByReferenceTransaction[]
+  ) {
+    return {
+      transactions: this.transfromToResponse(transactions),
+    };
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/TransactionsByVendors/index.ts b/packages/server/src/api/controllers/FinancialStatements/TransactionsByVendors/index.ts
new file mode 100644
index 000000000..eaf8e6725
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/TransactionsByVendors/index.ts
@@ -0,0 +1,124 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { query, ValidationChain } from 'express-validator';
+import { Inject } from 'typedi';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseFinancialReportController from '../BaseFinancialReportController';
+import TransactionsByVendorsTableRows from '@/services/FinancialStatements/TransactionsByVendor/TransactionsByVendorTableRows';
+import TransactionsByVendorsService from '@/services/FinancialStatements/TransactionsByVendor/TransactionsByVendorService';
+import {
+  AbilitySubject,
+  ITransactionsByVendorsStatement,
+  ReportsAction,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+export default class TransactionsByVendorsReportController extends BaseFinancialReportController {
+  @Inject()
+  transactionsByVendorsService: TransactionsByVendorsService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(
+        ReportsAction.READ_VENDORS_TRANSACTIONS,
+        AbilitySubject.Report
+      ),
+      this.validationSchema,
+      this.validationResult,
+      asyncMiddleware(this.transactionsByVendors.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Validation schema.
+   */
+  get validationSchema(): ValidationChain[] {
+    return [
+      ...this.sheetNumberFormatValidationSchema,
+
+      query('from_date').optional().isISO8601(),
+      query('to_date').optional().isISO8601(),
+
+      query('none_zero').optional().isBoolean().toBoolean(),
+      query('none_transactions').optional().isBoolean().toBoolean(),
+
+      // Vendors ids.
+      query('vendors_ids').optional().isArray({ min: 1 }),
+      query('vendors_ids.*').exists().isInt().toInt(),
+    ];
+  }
+
+  /**
+   * Transformes the report statement to table rows.
+   * @param {ITransactionsByVendorsStatement} statement -
+   */
+  private transformToTableRows(tenantId: number, transactions: any[]) {
+    const i18n = this.tenancy.i18n(tenantId);
+    const table = new TransactionsByVendorsTableRows(transactions, i18n);
+
+    return {
+      table: {
+        data: table.tableRows(),
+      },
+    };
+  }
+
+  /**
+   * Transformes the report statement to json response.
+   * @param {ITransactionsByVendorsStatement} statement -
+   */
+  private transformToJsonResponse({
+    data,
+    columns,
+    query,
+  }: ITransactionsByVendorsStatement) {
+    return {
+      data: this.transfromToResponse(data),
+      columns: this.transfromToResponse(columns),
+      query: this.transfromToResponse(query),
+    };
+  }
+
+  /**
+   * Retrieve payable aging summary report.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  async transactionsByVendors(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const filter = this.matchedQueryData(req);
+
+    try {
+      const report =
+        await this.transactionsByVendorsService.transactionsByVendors(
+          tenantId,
+          filter
+        );
+      const accept = this.accepts(req);
+      const acceptType = accept.types(['json', 'application/json+table']);
+
+      switch (acceptType) {
+        case 'application/json+table':
+          return res
+            .status(200)
+            .send(this.transformToTableRows(tenantId, report.data));
+        case 'json':
+        default:
+          return res.status(200).send(this.transformToJsonResponse(report));
+      }
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/TrialBalanceSheet.ts b/packages/server/src/api/controllers/FinancialStatements/TrialBalanceSheet.ts
new file mode 100644
index 000000000..4fa298fa0
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/TrialBalanceSheet.ts
@@ -0,0 +1,88 @@
+import { Inject, Service } from 'typedi';
+import { Request, Response, Router, NextFunction } from 'express';
+import { query, ValidationChain } from 'express-validator';
+import { castArray } from 'lodash';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import TrialBalanceSheetService from '@/services/FinancialStatements/TrialBalanceSheet/TrialBalanceSheetService';
+import BaseFinancialReportController from './BaseFinancialReportController';
+import { AbilitySubject, ReportsAction } from '@/interfaces';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+@Service()
+export default class TrialBalanceSheetController extends BaseFinancialReportController {
+  @Inject()
+  trialBalanceSheetService: TrialBalanceSheetService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(
+        ReportsAction.READ_TRIAL_BALANCE_SHEET,
+        AbilitySubject.Report
+      ),
+      this.trialBalanceSheetValidationSchema,
+      this.validationResult,
+      asyncMiddleware(this.trialBalanceSheet.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Validation schema.
+   * @return {ValidationChain[]}
+   */
+  get trialBalanceSheetValidationSchema(): ValidationChain[] {
+    return [
+      ...this.sheetNumberFormatValidationSchema,
+      query('basis').optional(),
+      query('from_date').optional().isISO8601(),
+      query('to_date').optional().isISO8601(),
+      query('account_ids').isArray().optional(),
+      query('account_ids.*').isNumeric().toInt(),
+      query('basis').optional(),
+
+      query('none_zero').optional().isBoolean().toBoolean(),
+      query('none_transactions').optional().isBoolean().toBoolean(),
+      query('only_active').optional().isBoolean().toBoolean(),
+
+      // Filtering by branches.
+      query('branches_ids').optional().toArray().isArray({ min: 1 }),
+      query('branches_ids.*').isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Retrieve the trial balance sheet.
+   */
+  public async trialBalanceSheet(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId, settings } = req;
+    let filter = this.matchedQueryData(req);
+
+    filter = {
+      ...filter,
+      accountsIds: castArray(filter.accountsIds),
+    };
+
+    try {
+      const { data, query, meta } =
+        await this.trialBalanceSheetService.trialBalanceSheet(tenantId, filter);
+
+      return res.status(200).send({
+        data: this.transfromToResponse(data),
+        query: this.transfromToResponse(query),
+        meta: this.transfromToResponse(meta),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/FinancialStatements/VendorBalanceSummary/index.ts b/packages/server/src/api/controllers/FinancialStatements/VendorBalanceSummary/index.ts
new file mode 100644
index 000000000..e93891938
--- /dev/null
+++ b/packages/server/src/api/controllers/FinancialStatements/VendorBalanceSummary/index.ts
@@ -0,0 +1,134 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { query } from 'express-validator';
+import { Inject } from 'typedi';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseFinancialReportController from '../BaseFinancialReportController';
+import VendorBalanceSummaryTableRows from '@/services/FinancialStatements/VendorBalanceSummary/VendorBalanceSummaryTableRows';
+import VendorBalanceSummaryService from '@/services/FinancialStatements/VendorBalanceSummary/VendorBalanceSummaryService';
+import {
+  AbilitySubject,
+  IVendorBalanceSummaryStatement,
+  ReportsAction,
+} from '@/interfaces';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+export default class VendorBalanceSummaryReportController extends BaseFinancialReportController {
+  @Inject()
+  vendorBalanceSummaryService: VendorBalanceSummaryService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(
+        ReportsAction.READ_VENDORS_SUMMARY_BALANCE,
+        AbilitySubject.Report
+      ),
+      this.validationSchema,
+      asyncMiddleware(this.vendorBalanceSummary.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Validation schema.
+   */
+  get validationSchema() {
+    return [
+      ...this.sheetNumberFormatValidationSchema,
+      query('as_date').optional().isISO8601(),
+
+      // Percentage columns.
+      query('percentage_column').optional().isBoolean().toBoolean(),
+
+      // Filters none-zero or none-transactions.
+      query('none_zero').optional().isBoolean().toBoolean(),
+      query('none_transactions').optional().isBoolean().toBoolean(),
+
+      // Vendors ids.
+      query('vendors_ids').optional().isArray({ min: 1 }),
+      query('vendors_ids.*').exists().isInt().toInt(),
+    ];
+  }
+
+  /**
+   * Transformes the report statement to table rows.
+   * @param {IVendorBalanceSummaryStatement} statement -
+   */
+  private transformToTableRows(
+    tenantId: number,
+    { data, query }: IVendorBalanceSummaryStatement
+  ) {
+    const i18n = this.tenancy.i18n(tenantId);
+    const tableData = new VendorBalanceSummaryTableRows(
+      data,
+      query,
+      i18n
+    );
+    return {
+      table: {
+        columns: tableData.tableColumns(),
+        data: tableData.tableRows(),
+      },
+      query,
+    };
+  }
+
+  /**
+   * Transformes the report statement to raw json.
+   * @param {IVendorBalanceSummaryStatement} statement -
+   */
+  private transformToJsonResponse({
+    data,
+    columns,
+  }: IVendorBalanceSummaryStatement) {
+    return {
+      data: this.transfromToResponse(data),
+      columns: this.transfromToResponse(columns),
+      query: this.transfromToResponse(query),
+    };
+  }
+
+  /**
+   * Retrieve vendors balance summary.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  async vendorBalanceSummary(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, settings } = req;
+    const filter = this.matchedQueryData(req);
+
+    try {
+      const vendorBalanceSummary =
+        await this.vendorBalanceSummaryService.vendorBalanceSummary(
+          tenantId,
+          filter
+        );
+      const accept = this.accepts(req);
+      const acceptType = accept.types(['json', 'application/json+table']);
+
+      switch (acceptType) {
+        case 'application/json+table':
+          return res
+            .status(200)
+            .send(this.transformToTableRows(tenantId, vendorBalanceSummary));
+        case 'json':
+        default:
+          return res
+            .status(200)
+            .send(this.transformToJsonResponse(vendorBalanceSummary));
+      }
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/Inventory/InventortyItemsCosts.ts b/packages/server/src/api/controllers/Inventory/InventortyItemsCosts.ts
new file mode 100644
index 000000000..36a3c6408
--- /dev/null
+++ b/packages/server/src/api/controllers/Inventory/InventortyItemsCosts.ts
@@ -0,0 +1,57 @@
+import { Inject, Service } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import { query } from 'express-validator';
+import BaseController from '../BaseController';
+import { InventoryCostApplication } from '@/services/Inventory/InventoryCostApplication';
+
+@Service()
+export class InventoryItemsCostController extends BaseController {
+  @Inject()
+  private inventoryItemCost: InventoryCostApplication;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/items-cost',
+      [
+        query('date').exists().isISO8601().toDate(),
+
+        query('items_ids').exists().isArray({ min: 1 }),
+        query('items_ids.*').exists().isInt().toInt(),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.getItemsCosts)
+    );
+    return router;
+  }
+
+  /**
+   * Retrieves the given items costs.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public getItemsCosts = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const itemsCostQueryDTO = this.matchedQueryData(req);
+
+    try {
+      const costs = await this.inventoryItemCost.getItemsInventoryValuationList(
+        tenantId,
+        itemsCostQueryDTO.itemsIds,
+        itemsCostQueryDTO.date
+      );
+      return res.status(200).send({ costs });
+    } catch (error) {
+      next(error);
+    }
+  };
+}
diff --git a/packages/server/src/api/controllers/Inventory/InventoryAdjustments.ts b/packages/server/src/api/controllers/Inventory/InventoryAdjustments.ts
new file mode 100644
index 000000000..40b1744ff
--- /dev/null
+++ b/packages/server/src/api/controllers/Inventory/InventoryAdjustments.ts
@@ -0,0 +1,345 @@
+import { Inject, Service } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, query, param } from 'express-validator';
+import { ServiceError } from '@/exceptions';
+import BaseController from '../BaseController';
+import InventoryAdjustmentService from '@/services/Inventory/InventoryAdjustmentService';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { AbilitySubject, InventoryAdjustmentAction } from '@/interfaces';
+import CheckPolicies from '../../middleware/CheckPolicies';
+
+@Service()
+export default class InventoryAdjustmentsController extends BaseController {
+  @Inject()
+  inventoryAdjustmentService: InventoryAdjustmentService;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/:id/publish',
+      CheckPolicies(
+        InventoryAdjustmentAction.EDIT,
+        AbilitySubject.InventoryAdjustment
+      ),
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.publishInventoryAdjustment.bind(this)),
+      this.handleServiceErrors
+    );
+    router.delete(
+      '/:id',
+      CheckPolicies(
+        InventoryAdjustmentAction.DELETE,
+        AbilitySubject.InventoryAdjustment
+      ),
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.deleteInventoryAdjustment.bind(this)),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/quick',
+      CheckPolicies(
+        InventoryAdjustmentAction.CREATE,
+        AbilitySubject.InventoryAdjustment
+      ),
+      this.validatateQuickAdjustment,
+      this.validationResult,
+      this.asyncMiddleware(this.createQuickInventoryAdjustment.bind(this)),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id',
+      CheckPolicies(
+        InventoryAdjustmentAction.VIEW,
+        AbilitySubject.InventoryAdjustment
+      ),
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.getInventoryAdjustment.bind(this)),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/',
+      CheckPolicies(
+        InventoryAdjustmentAction.VIEW,
+        AbilitySubject.InventoryAdjustment
+      ),
+      [...this.validateListQuerySchema],
+      this.validationResult,
+      this.asyncMiddleware(this.getInventoryAdjustments.bind(this)),
+      this.dynamicListService.handlerErrorsToResponse,
+      this.handleServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Validate list query schema
+   */
+  get validateListQuerySchema() {
+    return [
+      query('column_sort_by').optional().trim().escape(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+
+      query('stringified_filter_roles').optional().isJSON(),
+    ];
+  }
+
+  /**
+   * Quick inventory adjustment validation schema.
+   */
+  get validatateQuickAdjustment() {
+    return [
+      check('date').exists().isISO8601(),
+      check('type')
+        .exists()
+        .isIn(['increment', 'decrement', 'value_adjustment']),
+      check('reference_no').exists(),
+      check('adjustment_account_id').exists().isInt().toInt(),
+      check('reason').exists().isString().exists(),
+      check('description').optional().isString(),
+      check('item_id').exists().isInt().toInt(),
+      check('quantity')
+        .if(check('type').exists().isIn(['increment', 'decrement']))
+        .exists()
+        .isInt()
+        .toInt(),
+      check('cost')
+        .if(check('type').exists().isIn(['increment']))
+        .exists()
+        .isFloat()
+        .toInt(),
+      check('publish').default(false).isBoolean().toBoolean(),
+
+      check('warehouse_id').optional({ nullable: true }).isNumeric().toInt(),
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Creates a quick inventory adjustment.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async createQuickInventoryAdjustment(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId, user } = req;
+    const quickInventoryAdjustment = this.matchedBodyData(req);
+
+    try {
+      const inventoryAdjustment =
+        await this.inventoryAdjustmentService.createQuickAdjustment(
+          tenantId,
+          quickInventoryAdjustment,
+          user
+        );
+
+      return res.status(200).send({
+        id: inventoryAdjustment.id,
+        message: 'The inventory adjustment has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Deletes the given inventory adjustment transaction.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async deleteInventoryAdjustment(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+    const { id: adjustmentId } = req.params;
+
+    try {
+      await this.inventoryAdjustmentService.deleteInventoryAdjustment(
+        tenantId,
+        adjustmentId
+      );
+      return res.status(200).send({
+        id: adjustmentId,
+        message: 'The inventory adjustment has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Publish the given inventory adjustment transaction.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async publishInventoryAdjustment(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+    const { id: adjustmentId } = req.params;
+
+    try {
+      await this.inventoryAdjustmentService.publishInventoryAdjustment(
+        tenantId,
+        adjustmentId
+      );
+      return res.status(200).send({
+        id: adjustmentId,
+        message: 'The inventory adjustment has been published successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve the specific inventory adjustment transaction of  the given id.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  async getInventoryAdjustment(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+    const { id: adjustmentId } = req.params;
+
+    try {
+      const inventoryAdjustment =
+        await this.inventoryAdjustmentService.getInventoryAdjustment(
+          tenantId,
+          adjustmentId
+        );
+
+      return res.status(200).send({
+        data: this.transfromToResponse(inventoryAdjustment),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve the inventory adjustments paginated list.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async getInventoryAdjustments(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+    const filter = {
+      page: 1,
+      pageSize: 12,
+      columnSortBy: 'created_at',
+      sortOrder: 'desc',
+      filterRoles: [],
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const { pagination, inventoryAdjustments } =
+        await this.inventoryAdjustmentService.getInventoryAdjustments(
+          tenantId,
+          filter
+        );
+
+      return res.status(200).send({
+        inventoy_adjustments: inventoryAdjustments,
+        pagination: this.transfromToResponse(pagination),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handleServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'INVENTORY_ADJUSTMENT_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'INVENTORY_ADJUSTMENT.NOT.FOUND',
+              code: 100,
+              message: 'The inventory adjustment not found.',
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'ITEM.NOT.FOUND', code: 140 }],
+        });
+      }
+      if (error.errorType === 'account_not_found') {
+        return res.boom.notFound('The given account not found.', {
+          errors: [{ type: 'ACCOUNT.NOT.FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'ITEM_SHOULD_BE_INVENTORY_TYPE') {
+        return res.boom.badRequest(
+          'You could not make adjustment on item has no inventory type.',
+          { errors: [{ type: 'ITEM_SHOULD_BE_INVENTORY_TYPE', code: 300 }] }
+        );
+      }
+      if (error.errorType === 'INVENTORY_ADJUSTMENT_ALREADY_PUBLISHED') {
+        return res.boom.badRequest('', {
+          errors: [
+            { type: 'INVENTORY_ADJUSTMENT_ALREADY_PUBLISHED', code: 400 },
+          ],
+        });
+      }
+      if (error.errorType === 'TRANSACTIONS_DATE_LOCKED') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'TRANSACTIONS_DATE_LOCKED',
+              code: 4900,
+              data: { ...error.payload },
+            },
+          ],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/InviteUsers.ts b/packages/server/src/api/controllers/InviteUsers.ts
new file mode 100644
index 000000000..090f33882
--- /dev/null
+++ b/packages/server/src/api/controllers/InviteUsers.ts
@@ -0,0 +1,268 @@
+import { Service, Inject } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, body, param } from 'express-validator';
+import { IInviteUserInput } from '@/interfaces';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import { ServiceError } from '@/exceptions';
+import BaseController from './BaseController';
+import InviteTenantUserService from '@/services/InviteUsers/TenantInviteUser';
+import AcceptInviteUserService from '@/services/InviteUsers/AcceptInviteUser';
+
+@Service()
+export default class InviteUsersController extends BaseController {
+  @Inject()
+  inviteUsersService: InviteTenantUserService;
+
+  @Inject()
+  acceptInviteService: AcceptInviteUserService;
+
+  /**
+   * Routes that require authentication.
+   */
+  authRouter() {
+    const router = Router();
+
+    router.post(
+      '/send',
+      [
+        body('email').exists().trim().escape(),
+        body('role_id').exists().isNumeric().toInt(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.sendInvite.bind(this)),
+      this.handleServicesError
+    );
+    router.post(
+      '/resend/:userId',
+      [param('userId').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.resendInvite.bind(this)),
+      this.handleServicesError
+    );
+    return router;
+  }
+
+  /**
+   * Routes that non-required authentication.
+   */
+  nonAuthRouter() {
+    const router = Router();
+
+    router.post(
+      '/accept/:token',
+      [...this.inviteUserDTO],
+      this.validationResult,
+      asyncMiddleware(this.accept.bind(this)),
+      this.handleServicesError
+    );
+    router.get(
+      '/invited/:token',
+      [param('token').exists().trim().escape()],
+      this.validationResult,
+      asyncMiddleware(this.invited.bind(this)),
+      this.handleServicesError
+    );
+
+    return router;
+  }
+
+  /**
+   * Invite DTO schema validation.
+   */
+  get inviteUserDTO() {
+    return [
+      check('first_name').exists().trim().escape(),
+      check('last_name').exists().trim().escape(),
+      check('phone_number').exists().trim().escape(),
+      check('password').exists().trim().escape(),
+      param('token').exists().trim().escape(),
+    ];
+  }
+
+  /**
+   * Invite a user to the authorized user organization.
+   * @param {Request} req - Request object.
+   * @param {Response} res - Response object.
+   * @param {NextFunction} next - Next function.
+   */
+  async sendInvite(req: Request, res: Response, next: Function) {
+    const sendInviteDTO = this.matchedBodyData(req);
+    const { tenantId } = req;
+    const { user } = req;
+
+    try {
+      const { invite } = await this.inviteUsersService.sendInvite(
+        tenantId,
+        sendInviteDTO,
+        user
+      );
+      return res.status(200).send({
+        type: 'success',
+        code: 'INVITE.SENT.SUCCESSFULLY',
+        message: 'The invite has been sent to the given email.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Resend the user invite.
+   * @param {Request} req - Request object.
+   * @param {Response} res - Response object.
+   * @param {NextFunction} next - Next function.
+   */
+  async resendInvite(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const { userId } = req.params;
+
+    try {
+      await this.inviteUsersService.resendInvite(tenantId, userId, user);
+
+      return res.status(200).send({
+        type: 'success',
+        code: 'INVITE.RESEND.SUCCESSFULLY',
+        message: 'The invite has been sent to the given email.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Accept the inviation.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  async accept(req: Request, res: Response, next: Function) {
+    const inviteUserInput: IInviteUserInput = this.matchedBodyData(req, {
+      locations: ['body'],
+      includeOptionals: true,
+    });
+    const { token } = req.params;
+
+    try {
+      await this.acceptInviteService.acceptInvite(token, inviteUserInput);
+
+      return res.status(200).send({
+        type: 'success',
+        code: 'USER.INVITE.ACCEPTED',
+        message: 'User invite has been accepted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Check if the invite token is valid.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  async invited(req: Request, res: Response, next: Function) {
+    const { token } = req.params;
+
+    try {
+      const { inviteToken, orgName } =
+        await this.acceptInviteService.checkInvite(token);
+
+      return res.status(200).send({
+        inviteToken: inviteToken.token,
+        email: inviteToken.email,
+        organizationName: orgName,
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handles the service error.
+   */
+  handleServicesError(error, req: Request, res: Response, next: Function) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'EMAIL_EXISTS') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'EMAIL.ALREADY.EXISTS',
+              code: 100,
+              message: 'Email already exists in the users.',
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'EMAIL_ALREADY_INVITED') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'EMAIL.ALREADY.INVITED',
+              code: 200,
+              message: 'Email already invited.',
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'INVITE_TOKEN_INVALID') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'INVITE.TOKEN.INVALID',
+              code: 300,
+              message: 'Invite token is invalid, please try another one.',
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'PHONE_NUMBER_EXISTS') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'PHONE_NUMBER.EXISTS',
+              code: 400,
+              message:
+                'Phone number is already invited, please try another unique one.',
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'USER_RECENTLY_INVITED') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'USER_RECENTLY_INVITED',
+              code: 500,
+              message:
+                'This person was recently invited. No need to invite them again just yet.',
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'ROLE_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'ROLE_NOT_FOUND',
+              code: 600,
+              message: 'The given user role is not found.',
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'USER_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'USER_NOT_FOUND',
+              code: 700,
+              message: 'The given user is not found.',
+            },
+          ],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/ItemCategories.ts b/packages/server/src/api/controllers/ItemCategories.ts
new file mode 100644
index 000000000..9310ebc02
--- /dev/null
+++ b/packages/server/src/api/controllers/ItemCategories.ts
@@ -0,0 +1,311 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query } from 'express-validator';
+import ItemCategoriesService from '@/services/ItemCategories/ItemCategoriesService';
+import { Inject, Service } from 'typedi';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import { IItemCategoryOTD } from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import BaseController from '@/api/controllers/BaseController';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { DATATYPES_LENGTH } from '@/data/DataTypes';
+
+@Service()
+export default class ItemsCategoriesController extends BaseController {
+  @Inject()
+  itemCategoriesService: ItemCategoriesService;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  /**
+   * Router constructor method.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/:id',
+      [
+        ...this.categoryValidationSchema,
+        ...this.specificCategoryValidationSchema,
+      ],
+      this.validationResult,
+      asyncMiddleware(this.editCategory.bind(this)),
+      this.handlerServiceError
+    );
+    router.post(
+      '/',
+      [...this.categoryValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.newCategory.bind(this)),
+      this.handlerServiceError
+    );
+    router.delete(
+      '/:id',
+      [...this.specificCategoryValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.deleteItem.bind(this)),
+      this.handlerServiceError
+    );
+    router.get(
+      '/:id',
+      [...this.specificCategoryValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.getCategory.bind(this)),
+      this.handlerServiceError
+    );
+    router.get(
+      '/',
+      [...this.categoriesListValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.getList.bind(this)),
+      this.handlerServiceError,
+      this.dynamicListService.handlerErrorsToResponse
+    );
+    return router;
+  }
+
+  /**
+   * Item category validation schema.
+   */
+  get categoryValidationSchema() {
+    return [
+      check('name')
+        .exists()
+        .trim()
+        .escape()
+        .isLength({ min: 0, max: DATATYPES_LENGTH.STRING }),
+      check('description')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.TEXT }),
+      check('sell_account_id')
+        .optional({ nullable: true })
+        .isInt({ min: 0, max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+      check('cost_account_id')
+        .optional({ nullable: true })
+        .isInt({ min: 0, max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+      check('inventory_account_id')
+        .optional({ nullable: true })
+        .isInt({ min: 0, max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+    ];
+  }
+
+  /**
+   * Validate items categories schema.
+   */
+  get categoriesListValidationSchema() {
+    return [
+      query('column_sort_by').optional().trim().escape(),
+      query('sort_order').optional().trim().escape().isIn(['desc', 'asc']),
+
+      query('stringified_filter_roles').optional().isJSON(),
+    ];
+  }
+
+  /**
+   * Validate specific item category schema.
+   */
+  get specificCategoryValidationSchema() {
+    return [param('id').exists().toInt()];
+  }
+
+  /**
+   * Creates a new item category.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async newCategory(req: Request, res: Response, next: NextFunction) {
+    const { user, tenantId } = req;
+    const itemCategoryOTD: IItemCategoryOTD = this.matchedBodyData(req);
+
+    try {
+      const itemCategory = await this.itemCategoriesService.newItemCategory(
+        tenantId,
+        itemCategoryOTD,
+        user
+      );
+      return res.status(200).send({
+        id: itemCategory.id,
+        message: 'The item category has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Edit details of the given category item.
+   * @param  {Request} req -
+   * @param  {Response} res -
+   * @return {Response}
+   */
+  async editCategory(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const { id: itemCategoryId } = req.params;
+    const itemCategoryOTD: IItemCategoryOTD = this.matchedBodyData(req);
+
+    try {
+      await this.itemCategoriesService.editItemCategory(
+        tenantId,
+        itemCategoryId,
+        itemCategoryOTD,
+        user
+      );
+      return res.status(200).send({
+        id: itemCategoryId,
+        message: 'The item category has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Delete the give item category.
+   * @param  {Request} req -
+   * @param  {Response} res -
+   * @return {Response}
+   */
+  async deleteItem(req: Request, res: Response, next: NextFunction) {
+    const { id: itemCategoryId } = req.params;
+    const { tenantId, user } = req;
+
+    try {
+      await this.itemCategoriesService.deleteItemCategory(
+        tenantId,
+        itemCategoryId,
+        user
+      );
+      return res.status(200).send({
+        id: itemCategoryId,
+        message: 'The item category has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve the list of items.
+   * @param  {Request} req -
+   * @param  {Response} res -
+   * @return {Response}
+   */
+  async getList(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+
+    const itemCategoriesFilter = {
+      sortOrder: 'asc',
+      columnSortBy: 'created_at',
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const {
+        itemCategories,
+        filterMeta,
+      } = await this.itemCategoriesService.getItemCategoriesList(
+        tenantId,
+        itemCategoriesFilter,
+        user
+      );
+      return res.status(200).send({
+        item_categories: itemCategories,
+        filter_meta: this.transfromToResponse(filterMeta),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve details of the given category.
+   * @param  {Request} req -
+   * @param  {Response} res -
+   * @return {Response}
+   */
+  async getCategory(req: Request, res: Response, next: NextFunction) {
+    const itemCategoryId: number = req.params.id;
+    const { tenantId, user } = req;
+
+    try {
+      const itemCategory = await this.itemCategoriesService.getItemCategory(
+        tenantId,
+        itemCategoryId,
+        user
+      );
+      return res.status(200).send({ category: itemCategory });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handles service error.
+   * @param {Error} error
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next
+   */
+  handlerServiceError(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'CATEGORY_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ITEM_CATEGORY_NOT_FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'ITEM_CATEGORIES_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ITEM_CATEGORIES_NOT_FOUND', code: 200 }],
+        });
+      }
+      if (error.errorType === 'CATEGORY_NAME_EXISTS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CATEGORY_NAME_EXISTS', code: 300 }],
+        });
+      }
+      if (error.errorType === 'COST_ACCOUNT_NOT_FOUMD') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'COST.ACCOUNT.NOT.FOUND', code: 400 }],
+        });
+      }
+      if (error.errorType === 'COST_ACCOUNT_NOT_COGS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'COST.ACCOUNT.NOT.COGS.TYPE', code: 500 }],
+        });
+      }
+      if (error.errorType === 'SELL_ACCOUNT_NOT_INCOME') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SELL.ACCOUNT.NOT.FOUND', code: 600 }],
+        });
+      }
+      if (error.errorType === 'SELL_ACCOUNT_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SELL.ACCOUNT.NOT.INCOME.TYPE', code: 700 }],
+        });
+      }
+      if (error.errorType === 'INVENTORY_ACCOUNT_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'INVENTORY.ACCOUNT.NOT.FOUND', code: 800 }],
+        });
+      }
+      if (error.errorType === 'INVENTORY_ACCOUNT_NOT_INVENTORY') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'INVENTORY.ACCOUNT.NOT.CURRENT.ASSET', code: 900 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Items/Items.ts b/packages/server/src/api/controllers/Items/Items.ts
new file mode 100644
index 000000000..104de0b88
--- /dev/null
+++ b/packages/server/src/api/controllers/Items/Items.ts
@@ -0,0 +1,522 @@
+import { Inject, Service } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query, ValidationChain } from 'express-validator';
+import BaseController from '@/api/controllers/BaseController';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { ServiceError } from '@/exceptions';
+import { IItemDTO, ItemAction, AbilitySubject } from '@/interfaces';
+import { DATATYPES_LENGTH } from '@/data/DataTypes';
+import CheckAbilities from '@/api/middleware/CheckPolicies';
+import { ItemsApplication } from '@/services/Items/ItemsApplication';
+
+@Service()
+export default class ItemsController extends BaseController {
+  @Inject()
+  private itemsApplication: ItemsApplication;
+
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/',
+      CheckAbilities(ItemAction.CREATE, AbilitySubject.Item),
+      this.validateItemSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.newItem.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/:id/activate',
+      CheckAbilities(ItemAction.EDIT, AbilitySubject.Item),
+      this.validateSpecificItemSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.activateItem.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/:id/inactivate',
+      CheckAbilities(ItemAction.EDIT, AbilitySubject.Item),
+      [...this.validateSpecificItemSchema],
+      this.validationResult,
+      this.asyncMiddleware(this.inactivateItem.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/:id',
+      CheckAbilities(ItemAction.EDIT, AbilitySubject.Item),
+      [...this.validateItemSchema, ...this.validateSpecificItemSchema],
+      this.validationResult,
+      this.asyncMiddleware(this.editItem.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.delete(
+      '/:id',
+      CheckAbilities(ItemAction.DELETE, AbilitySubject.Item),
+      [...this.validateSpecificItemSchema],
+      this.validationResult,
+      this.asyncMiddleware(this.deleteItem.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.get(
+      '/:id',
+      CheckAbilities(ItemAction.VIEW, AbilitySubject.Item),
+      [...this.validateSpecificItemSchema],
+      this.validationResult,
+      this.asyncMiddleware(this.getItem.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.get(
+      '/',
+      CheckAbilities(ItemAction.VIEW, AbilitySubject.Item),
+      [...this.validateListQuerySchema],
+      this.validationResult,
+      this.asyncMiddleware(this.getItemsList.bind(this)),
+      this.dynamicListService.handlerErrorsToResponse,
+      this.handlerServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Validate item schema.
+   */
+  get validateItemSchema(): ValidationChain[] {
+    return [
+      check('name')
+        .exists()
+        .isString()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('type')
+        .exists()
+        .isString()
+        .trim()
+        .escape()
+        .isIn(['service', 'non-inventory', 'inventory']),
+      check('code')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      // Purchase attributes.
+      check('purchasable').optional().isBoolean().toBoolean(),
+      check('cost_price')
+        .optional({ nullable: true })
+        .isFloat({ min: 0, max: DATATYPES_LENGTH.DECIMAL_13_3 })
+        .toFloat()
+        .if(check('purchasable').equals('true'))
+        .exists(),
+      check('cost_account_id').if(check('purchasable').equals('true')).exists(),
+      check('cost_account_id')
+        .optional({ nullable: true })
+        .isInt({ min: 0, max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+      // Sell attributes.
+      check('sellable').optional().isBoolean().toBoolean(),
+      check('sell_price')
+        .optional({ nullable: true })
+        .isFloat({ min: 0, max: DATATYPES_LENGTH.DECIMAL_13_3 })
+        .toFloat()
+        .if(check('sellable').equals('true'))
+        .exists(),
+      check('sell_account_id').if(check('sellable').equals('true')).exists(),
+      check('sell_account_id')
+        .optional({ nullable: true })
+        .isInt({ min: 0, max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+      check('inventory_account_id')
+        .if(check('type').equals('inventory'))
+        .exists(),
+      check('inventory_account_id')
+        .optional({ nullable: true })
+        .isInt({ min: 0, max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+      check('sell_description')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.TEXT }),
+      check('purchase_description')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.TEXT }),
+      check('category_id')
+        .optional({ nullable: true })
+        .isInt({ min: 0, max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+      check('note')
+        .optional()
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.TEXT }),
+      check('active').optional().isBoolean().toBoolean(),
+
+      check('media_ids').optional().isArray(),
+      check('media_ids.*').exists().isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Validate specific item params schema.
+   * @return {ValidationChain[]}
+   */
+  get validateSpecificItemSchema(): ValidationChain[] {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  /**
+   * Validate list query schema.
+   */
+  get validateListQuerySchema() {
+    return [
+      query('column_sort_by').optional().trim().escape(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+
+      query('view_slug').optional({ nullable: true }).isString().trim(),
+      query('stringified_filter_roles').optional().isJSON(),
+
+      query('inactive_mode').optional().isBoolean().toBoolean(),
+      query('search_keyword').optional({ nullable: true }).isString().trim(),
+    ];
+  }
+
+  /**
+   * Validate autocomplete list query schema.
+   */
+  get autocompleteQuerySchema() {
+    return [
+      query('column_sort_by').optional().trim().escape(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+
+      query('stringified_filter_roles').optional().isJSON(),
+      query('limit').optional().isNumeric().toInt(),
+
+      query('keyword').optional().isString().trim().escape(),
+    ];
+  }
+
+  /**
+   * Stores the given item details to the storage.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async newItem(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const itemDTO: IItemDTO = this.matchedBodyData(req);
+
+    try {
+      const storedItem = await this.itemsApplication.createItem(tenantId, itemDTO);
+
+      return res.status(200).send({
+        id: storedItem.id,
+        message: 'The item has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Updates the given item details on the storage.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async editItem(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const itemId: number = req.params.id;
+    const item: IItemDTO = this.matchedBodyData(req);
+
+    try {
+      await this.itemsApplication.editItem(tenantId, itemId, item);
+
+      return res.status(200).send({
+        id: itemId,
+        message: 'The item has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Activates the given item.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async activateItem(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const itemId: number = req.params.id;
+
+    try {
+      await this.itemsApplication.activateItem(tenantId, itemId);
+
+      return res.status(200).send({
+        id: itemId,
+        message: 'The item has been activated successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Inactivates the given item.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async inactivateItem(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const itemId: number = req.params.id;
+
+    try {
+      await this.itemsApplication.inactivateItem(tenantId, itemId);
+
+      return res.status(200).send({
+        id: itemId,
+        message: 'The item has been inactivated successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Deletes the given item from the storage.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async deleteItem(req: Request, res: Response, next: NextFunction) {
+    const itemId: number = req.params.id;
+    const { tenantId } = req;
+
+    try {
+      await this.itemsApplication.deleteItem(tenantId, itemId);
+
+      return res.status(200).send({
+        id: itemId,
+        message: 'The item has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve details the given item id.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async getItem(req: Request, res: Response, next: NextFunction) {
+    const itemId: number = req.params.id;
+    const { tenantId } = req;
+
+    try {
+      const item = await this.itemsApplication.getItem(tenantId, itemId);
+
+      return res.status(200).send({
+        item: this.transfromToResponse(item),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve items datatable list.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async getItemsList(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+
+    const filter = {
+      sortOrder: 'DESC',
+      columnSortBy: 'created_at',
+      page: 1,
+      pageSize: 12,
+      inactiveMode: false,
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const { items, pagination, filterMeta } =
+        await this.itemsApplication.getItems(tenantId, filter);
+
+      return res.status(200).send({
+        items: this.transfromToResponse(items),
+        pagination: this.transfromToResponse(pagination),
+        filter_meta: this.transfromToResponse(filterMeta),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handlerServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'ITEM.NOT.FOUND', code: 140 }],
+        });
+      }
+      if (error.errorType === 'ITEMS_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'ITEMS_NOT_FOUND', code: 130 }],
+        });
+      }
+      if (error.errorType === 'ITEM_CATEOGRY_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'ITEM_CATEGORY.NOT.FOUND', code: 140 }],
+        });
+      }
+      if (error.errorType === 'ITEM_NAME_EXISTS') {
+        return res.status(400).send({
+          errors: [{ type: 'ITEM.NAME.ALREADY.EXISTS', code: 210 }],
+        });
+      }
+      if (error.errorType === 'COST_ACCOUNT_NOT_FOUMD') {
+        return res.status(400).send({
+          errors: [{ type: 'COST.ACCOUNT.NOT.FOUND', code: 120 }],
+        });
+      }
+      if (error.errorType === 'COST_ACCOUNT_NOT_COGS') {
+        return res.status(400).send({
+          errors: [{ type: 'COST.ACCOUNT.NOT.COGS.TYPE', code: 220 }],
+        });
+      }
+      if (error.errorType === 'SELL_ACCOUNT_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'SELL.ACCOUNT.NOT.FOUND', code: 130 }],
+        });
+      }
+      if (error.errorType === 'SELL_ACCOUNT_NOT_INCOME') {
+        return res.status(400).send({
+          errors: [{ type: 'SELL.ACCOUNT.NOT.INCOME.TYPE', code: 230 }],
+        });
+      }
+      if (error.errorType === 'COST_ACCOUNT_NOT_FOUMD') {
+        return res.status(400).send({
+          errors: [{ type: 'COST.ACCOUNT.NOT.FOUND', code: 120 }],
+        });
+      }
+      if (error.errorType === 'COST_ACCOUNT_NOT_COGS') {
+        return res.status(400).send({
+          errors: [{ type: 'COST.ACCOUNT.NOT.COGS.TYPE', code: 220 }],
+        });
+      }
+      if (error.errorType === 'SELL_ACCOUNT_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'SELL.ACCOUNT.NOT.FOUND', code: 130 }],
+        });
+      }
+      if (error.errorType === 'INVENTORY_ACCOUNT_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'INVENTORY.ACCOUNT.NOT.FOUND', code: 200 }],
+        });
+      }
+      if (error.errorType === 'SELL_ACCOUNT_NOT_INCOME') {
+        return res.status(400).send({
+          errors: [{ type: 'SELL.ACCOUNT.NOT.INCOME.TYPE', code: 230 }],
+        });
+      }
+      if (error.errorType === 'INVENTORY_ACCOUNT_NOT_INVENTORY') {
+        return res.status(400).send({
+          errors: [{ type: 'INVENTORY.ACCOUNT.NOT.INVENTORY.TYPE', code: 300 }],
+        });
+      }
+      if (error.errorType === 'ITEMS_HAVE_ASSOCIATED_TRANSACTIONS') {
+        return res.status(400).send({
+          errors: [{ type: 'ITEMS_HAVE_ASSOCIATED_TRANSACTIONS', code: 310 }],
+        });
+      }
+      if (error.errorType === 'ITEM_HAS_ASSOCIATED_TRANSACTINS') {
+        return res.status(400).send({
+          errors: [{ type: 'ITEM_HAS_ASSOCIATED_TRANSACTINS', code: 320 }],
+        });
+      }
+      if (error.errorType === 'ITEM_HAS_ASSOCIATED_INVENTORY_ADJUSTMENT') {
+        return res.status(400).send({
+          errors: [
+            { type: 'ITEM_HAS_ASSOCIATED_INVENTORY_ADJUSTMENT', code: 330 },
+          ],
+        });
+      }
+      if (error.errorType === 'ITEM_CANNOT_CHANGE_INVENTORY_TYPE') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'ITEM_CANNOT_CHANGE_INVENTORY_TYPE',
+              message: 'Cannot change inventory item type',
+              code: 340,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'TYPE_CANNOT_CHANGE_WITH_ITEM_HAS_TRANSACTIONS') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'TYPE_CANNOT_CHANGE_WITH_ITEM_HAS_TRANSACTIONS',
+              message:
+                'Cannot change item type to inventory with item has associated transactions.',
+              code: 350,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'INVENTORY_ACCOUNT_CANNOT_MODIFIED') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'INVENTORY_ACCOUNT_CANNOT_MODIFIED',
+              message:
+                'Cannot change item inventory account while the item has transactions.',
+              code: 360,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'ITEM_HAS_ASSOCIATED_TRANSACTIONS') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'ITEM_HAS_ASSOCIATED_TRANSACTIONS',
+              code: 370,
+              message:
+                'Could not delete item that has associated transactions.',
+            },
+          ],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Items/ItemsTransactions.ts b/packages/server/src/api/controllers/Items/ItemsTransactions.ts
new file mode 100644
index 000000000..53086c0c7
--- /dev/null
+++ b/packages/server/src/api/controllers/Items/ItemsTransactions.ts
@@ -0,0 +1,137 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { Inject, Service } from 'typedi';
+import ItemTransactionsService from '@/services/Items/ItemTransactionsService';
+import BaseController from '../BaseController';
+
+@Service()
+export default class ItemTransactionsController extends BaseController {
+  @Inject()
+  itemTransactionsService: ItemTransactionsService;
+
+  router() {
+    const router = Router();
+
+    router.get(
+      '/:id/transactions/invoices',
+      this.asyncMiddleware(this.getItemInvoicesTransactions)
+    );
+    router.get(
+      '/:id/transactions/bills',
+      this.asyncMiddleware(this.getItemBillTransactions)
+    );
+    router.get(
+      '/:id/transactions/estimates',
+      this.asyncMiddleware(this.getItemEstimateTransactions)
+    );
+    router.get(
+      '/:id/transactions/receipts',
+      this.asyncMiddleware(this.getItemReceiptTransactions)
+    );
+    return router;
+  }
+
+  /**
+   * Retrieve item associated invoices transactions.
+   * @param {Request} req - Request object.
+   * @param {Response} res - Response object.
+   * @param {NextFunction} next - Next function.
+   */
+  public getItemInvoicesTransactions = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: invoiceId } = req.params;
+
+    try {
+      const transactions =
+        await this.itemTransactionsService.getItemInvoicesTransactions(
+          tenantId,
+          invoiceId
+        );
+
+      return res.status(200).send({ data: transactions });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve item associated bills transactions.
+   * @param {Request} req - Request object.
+   * @param {Response} res - Response object.
+   * @param {NextFunction} next - Next function.
+   */
+  public getItemBillTransactions = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: billId } = req.params;
+
+    try {
+      const transactions =
+        await this.itemTransactionsService.getItemBillTransactions(
+          tenantId,
+          billId
+        );
+      return res.status(200).send({ data: transactions });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve item associated estimates transactions.
+   * @param {Request} req - Request object.
+   * @param {Response} res - Response object.
+   * @param {NextFunction} next - Next function.
+   */
+  public getItemEstimateTransactions = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: estimateId } = req.params;
+
+    try {
+      const transactions =
+        await this.itemTransactionsService.getItemEstimateTransactions(
+          tenantId,
+          estimateId
+        );
+      return res.status(200).send({ data: transactions });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   *
+   * @param req
+   * @param res
+   * @param next
+   */
+  public getItemReceiptTransactions = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: receiptId } = req.params;
+
+    try {
+      const transactions =
+        await this.itemTransactionsService.getItemReceiptTransactions(
+          tenantId,
+          receiptId
+        );
+      return res.status(200).send({ data: transactions });
+    } catch (error) {
+      next(error);
+    }
+  };
+}
diff --git a/packages/server/src/api/controllers/Items/index.ts b/packages/server/src/api/controllers/Items/index.ts
new file mode 100644
index 000000000..33ef7d3b0
--- /dev/null
+++ b/packages/server/src/api/controllers/Items/index.ts
@@ -0,0 +1,17 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { Container, Service } from 'typedi';
+import ItemsController from './Items';
+
+import ItemTransactionsController from './ItemsTransactions';
+
+@Service()
+export default class ItemsBaseController {
+  router() {
+    const router = Router();
+
+    router.use('/', Container.get(ItemsController).router());
+    router.use('/', Container.get(ItemTransactionsController).router());
+
+    return router;
+  }
+}
diff --git a/packages/server/src/api/controllers/Jobs.ts b/packages/server/src/api/controllers/Jobs.ts
new file mode 100644
index 000000000..08786fdea
--- /dev/null
+++ b/packages/server/src/api/controllers/Jobs.ts
@@ -0,0 +1,60 @@
+import { Inject, Service } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import BaseController from '@/api/controllers/BaseController';
+import { ServiceError } from '@/exceptions';
+import JobsService from '@/services/Jobs/JobsService';
+
+@Service()
+export default class ItemsController extends BaseController {
+  @Inject()
+  jobsService: JobsService;
+
+  /**
+   * Router constructor.
+   */
+  public router() {
+    const router = Router();
+
+    router.get('/:id', this.getJob, this.handlerServiceErrors);
+
+    return router;
+  }
+
+  /**
+   * Retrieve job details.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private getJob = async (req: Request, res: Response, next: NextFunction) => {
+    const { id } = req.params;
+
+    try {
+      const job = await this.jobsService.getJob(id);
+
+      return res.status(200).send({
+        job: this.transfromToResponse(job),
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handlerServiceErrors = (
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    if (error instanceof ServiceError) {
+    }
+    next(error);
+  };
+}
diff --git a/packages/server/src/api/controllers/ManualJournals.ts b/packages/server/src/api/controllers/ManualJournals.ts
new file mode 100644
index 000000000..682ef64ce
--- /dev/null
+++ b/packages/server/src/api/controllers/ManualJournals.ts
@@ -0,0 +1,477 @@
+import { Inject, Service } from 'typedi';
+import { Request, Response, Router, NextFunction } from 'express';
+import { check, param, query } from 'express-validator';
+import BaseController from '@/api/controllers/BaseController';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import { ServiceError } from '@/exceptions';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { DATATYPES_LENGTH } from '@/data/DataTypes';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { AbilitySubject, ManualJournalAction } from '@/interfaces';
+import { ManualJournalsApplication } from '@/services/ManualJournals/ManualJournalsApplication';
+
+@Service()
+export default class ManualJournalsController extends BaseController {
+  @Inject()
+  private manualJournalsApplication: ManualJournalsApplication;
+
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      CheckPolicies(ManualJournalAction.View, AbilitySubject.ManualJournal),
+      [...this.manualJournalsListSchema],
+      this.validationResult,
+      asyncMiddleware(this.getManualJournalsList),
+      this.dynamicListService.handlerErrorsToResponse,
+      this.catchServiceErrors
+    );
+    router.get(
+      '/:id',
+      CheckPolicies(ManualJournalAction.View, AbilitySubject.ManualJournal),
+      asyncMiddleware(this.getManualJournal),
+      this.catchServiceErrors
+    );
+    router.post(
+      '/:id/publish',
+      CheckPolicies(ManualJournalAction.Edit, AbilitySubject.ManualJournal),
+      [...this.manualJournalParamSchema],
+      this.validationResult,
+      asyncMiddleware(this.publishManualJournal),
+      this.catchServiceErrors
+    );
+    router.post(
+      '/:id',
+      CheckPolicies(ManualJournalAction.Edit, AbilitySubject.ManualJournal),
+      [...this.manualJournalValidationSchema, ...this.manualJournalParamSchema],
+      this.validationResult,
+      asyncMiddleware(this.editManualJournal),
+      this.catchServiceErrors
+    );
+    router.delete(
+      '/:id',
+      CheckPolicies(ManualJournalAction.Delete, AbilitySubject.ManualJournal),
+      [...this.manualJournalParamSchema],
+      this.validationResult,
+      asyncMiddleware(this.deleteManualJournal),
+      this.catchServiceErrors
+    );
+    router.post(
+      '/',
+      CheckPolicies(ManualJournalAction.Create, AbilitySubject.ManualJournal),
+      [...this.manualJournalValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.makeJournalEntries),
+      this.catchServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Specific manual journal id param validation schema.
+   */
+  get manualJournalParamSchema() {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  /**
+   * Manual journal DTO schema.
+   */
+  get manualJournalValidationSchema() {
+    return [
+      check('date').exists().isISO8601(),
+      check('currency_code').optional(),
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+
+      check('journal_number')
+        .optional()
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('journal_type')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('reference')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('description')
+        .optional({ nullable: true })
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.TEXT }),
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+      check('publish').optional().isBoolean().toBoolean(),
+      check('entries').isArray({ min: 2 }),
+      check('entries.*.index')
+        .exists()
+        .isInt({ max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+      check('entries.*.credit')
+        .optional({ nullable: true })
+        .isFloat({ min: 0, max: DATATYPES_LENGTH.DECIMAL_13_3 })
+        .toFloat(),
+      check('entries.*.debit')
+        .optional({ nullable: true })
+        .isFloat({ min: 0, max: DATATYPES_LENGTH.DECIMAL_13_3 })
+        .toFloat(),
+      check('entries.*.account_id')
+        .isInt({ max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+      check('entries.*.note')
+        .optional({ nullable: true })
+        .isString()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('entries.*.contact_id')
+        .optional({ nullable: true })
+        .isInt({ max: DATATYPES_LENGTH.INT_10 })
+        .toInt(),
+      check('entries.*.branch_id')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toInt(),
+      check('entries.*.project_id')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toInt(),
+    ];
+  }
+
+  /**
+   * Manual journals list validation schema.
+   */
+  get manualJournalsListSchema() {
+    return [
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+      query('custom_view_id').optional().isNumeric().toInt(),
+
+      query('column_sort_by').optional().trim().escape(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+
+      query('stringified_filter_roles').optional().isJSON(),
+      query('search_keyword').optional({ nullable: true }).isString().trim(),
+    ];
+  }
+
+  /**
+   * Make manual journal.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private makeJournalEntries = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId, user } = req;
+    const manualJournalDTO = this.matchedBodyData(req);
+
+    try {
+      const { manualJournal } =
+        await this.manualJournalsApplication.createManualJournal(
+          tenantId,
+          manualJournalDTO,
+          user
+        );
+      return res.status(200).send({
+        id: manualJournal.id,
+        message: 'The manual journal has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Edit the given manual journal.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private editManualJournal = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId, user } = req;
+    const { id: manualJournalId } = req.params;
+    const manualJournalDTO = this.matchedBodyData(req);
+
+    try {
+      const { manualJournal } =
+        await this.manualJournalsApplication.editManualJournal(
+          tenantId,
+          manualJournalId,
+          manualJournalDTO,
+          user
+        );
+      return res.status(200).send({
+        id: manualJournal.id,
+        message: 'The manual journal has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve the given manual journal details.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private getManualJournal = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: manualJournalId } = req.params;
+
+    try {
+      const manualJournal =
+        await this.manualJournalsApplication.getManualJournal(
+          tenantId,
+          manualJournalId
+        );
+      return res.status(200).send({
+        manual_journal: this.transfromToResponse(manualJournal),
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Publish the given manual journal.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private publishManualJournal = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: manualJournalId } = req.params;
+
+    try {
+      await this.manualJournalsApplication.publishManualJournal(
+        tenantId,
+        manualJournalId
+      );
+      return res.status(200).send({
+        id: manualJournalId,
+        message: 'The manual journal has been published successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Delete the given manual journal.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private deleteManualJournal = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId, user } = req;
+    const { id: manualJournalId } = req.params;
+
+    try {
+      await this.manualJournalsApplication.deleteManualJournal(
+        tenantId,
+        manualJournalId
+      );
+      return res.status(200).send({
+        id: manualJournalId,
+        message: 'Manual journal has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve manual journals list.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  getManualJournalsList = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const filter = {
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      page: 1,
+      pageSize: 12,
+      ...this.matchedQueryData(req),
+    };
+    try {
+      const { manualJournals, pagination, filterMeta } =
+        await this.manualJournalsApplication.getManualJournals(
+          tenantId,
+          filter
+        );
+
+      return res.status(200).send({
+        manual_journals: this.transfromToResponse(manualJournals),
+        pagination: this.transfromToResponse(pagination),
+        filter_meta: this.transfromToResponse(filterMeta),
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Catches all service errors.
+   * @param error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  catchServiceErrors = (
+    error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'manual_journal_not_found') {
+        res.boom.badRequest('Manual journal not found.', {
+          errors: [{ type: 'MANUAL.JOURNAL.NOT.FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'credit_debit_not_equal_zero') {
+        return res.boom.badRequest(
+          'Credit and debit should not be equal zero.',
+          {
+            errors: [
+              {
+                type: 'CREDIT.DEBIT.SUMATION.SHOULD.NOT.EQUAL.ZERO',
+                code: 200,
+              },
+            ],
+          }
+        );
+      }
+      if (error.errorType === 'credit_debit_not_equal') {
+        return res.boom.badRequest('Credit and debit should be equal.', {
+          errors: [{ type: 'CREDIT.DEBIT.NOT.EQUALS', code: 300 }],
+        });
+      }
+      if (error.errorType === 'acccounts_ids_not_found') {
+        return res.boom.badRequest(
+          'Journal entries some of accounts ids not exists.',
+          { errors: [{ type: 'ACCOUNTS.IDS.NOT.FOUND', code: 400 }] }
+        );
+      }
+      if (error.errorType === 'journal_number_exists') {
+        return res.boom.badRequest('Journal number should be unique.', {
+          errors: [{ type: 'JOURNAL.NUMBER.ALREADY.EXISTS', code: 500 }],
+        });
+      }
+      if (error.errorType === 'ENTRIES_SHOULD_ASSIGN_WITH_CONTACT') {
+        return res.boom.badRequest('', {
+          errors: [
+            {
+              type: 'ENTRIES_SHOULD_ASSIGN_WITH_CONTACT',
+              code: 600,
+              meta: this.transfromToResponse(error.payload),
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'CONTACTS_SHOULD_ASSIGN_WITH_VALID_ACCOUNT') {
+        return res.boom.badRequest('', {
+          errors: [
+            {
+              type: 'CONTACTS_SHOULD_ASSIGN_WITH_VALID_ACCOUNT',
+              code: 700,
+              meta: this.transfromToResponse(error.payload),
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'contacts_not_found') {
+        return res.boom.badRequest('', {
+          errors: [{ type: 'CONTACTS_NOT_FOUND', code: 800 }],
+        });
+      }
+      if (error.errorType === 'MANUAL_JOURNAL_ALREADY_PUBLISHED') {
+        return res.boom.badRequest('', {
+          errors: [{ type: 'MANUAL_JOURNAL_ALREADY_PUBLISHED', code: 900 }],
+        });
+      }
+      if (error.errorType === 'MANUAL_JOURNAL_NO_REQUIRED') {
+        return res.boom.badRequest('', {
+          errors: [
+            {
+              type: 'MANUAL_JOURNAL_NO_REQUIRED',
+              message: 'The manual journal number required.',
+              code: 1000,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'TRANSACTIONS_DATE_LOCKED') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'TRANSACTIONS_DATE_LOCKED',
+              code: 4000,
+              data: { ...error.payload },
+            },
+          ],
+        });
+      }
+      if (
+        error.errorType === 'COULD_NOT_ASSIGN_DIFFERENT_CURRENCY_TO_ACCOUNTS'
+      ) {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'COULD_NOT_ASSIGN_DIFFERENT_CURRENCY_TO_ACCOUNTS',
+              code: 1100,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'MANUAL_JOURNAL_ENTRIES_HAVE_NO_BRANCH_ID') {
+        return res.boom.badRequest(null, {
+          errors: [
+            { type: 'MANUAL_JOURNAL_ENTRIES_HAVE_NO_BRANCH_ID', code: 1200 },
+          ],
+        });
+      }
+    }
+    next(error);
+  };
+}
diff --git a/packages/server/src/api/controllers/Media.ts b/packages/server/src/api/controllers/Media.ts
new file mode 100644
index 000000000..70fbc0347
--- /dev/null
+++ b/packages/server/src/api/controllers/Media.ts
@@ -0,0 +1,212 @@
+
+import { Router, Request, Response, NextFunction } from 'express';
+import {
+  param,
+  query,
+  check,
+} from 'express-validator';
+import { camelCase, upperFirst } from 'lodash';
+import { Inject, Service } from 'typedi';
+import { IMediaLinkDTO } from '@/interfaces';
+import fs from 'fs';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseController from './BaseController';
+import MediaService from '@/services/Media/MediaService';
+import { ServiceError } from '@/exceptions';
+
+const fsPromises = fs.promises;
+
+@Service()
+export default class MediaController extends BaseController {
+  @Inject()
+  mediaService: MediaService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.post('/upload', [
+      ...this.uploadValidationSchema,
+    ],
+      this.validationResult,
+      asyncMiddleware(this.uploadMedia.bind(this)),
+      this.handlerServiceErrors,
+    );
+    router.post('/:id/link', [
+      ...this.mediaIdParamSchema,
+      ...this.linkValidationSchema,
+    ],
+      this.validationResult,
+      asyncMiddleware(this.linkMedia.bind(this)),
+      this.handlerServiceErrors,
+    );
+    router.delete('/', [
+      ...this.deleteValidationSchema,
+    ],
+      this.validationResult,
+      asyncMiddleware(this.deleteMedia.bind(this)),
+      this.handlerServiceErrors,
+    );
+    router.get('/:id', [
+      ...this.mediaIdParamSchema,
+    ],
+      this.validationResult,
+      asyncMiddleware(this.getMedia.bind(this)),
+      this.handlerServiceErrors,
+    );
+    return router;
+  }
+
+  get uploadValidationSchema() {
+    return [
+      // check('attachment'),
+      check('model_name').optional().trim().escape(),
+      check('model_id').optional().isNumeric().toInt(),
+    ];
+  }
+
+  get linkValidationSchema() {
+    return [
+      check('model_name').exists().trim().escape(),
+      check('model_id').exists().isNumeric().toInt(),
+    ]
+  }
+
+  get deleteValidationSchema() {
+    return [
+      query('ids').exists().isArray(),
+      query('ids.*').exists().isNumeric().toInt(),
+    ];
+  }
+
+  get mediaIdParamSchema() {
+    return [
+      param('id').exists().isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Retrieve all or the given attachment ids.
+   * @param {Request} req - 
+   * @param {Response} req - 
+   * @param {NextFunction} req - 
+   */
+  async getMedia(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: mediaId } = req.params;
+
+    try {
+      const media = await this.mediaService.getMedia(tenantId, mediaId);
+      return res.status(200).send({ media });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Uploads media.
+   * @param {Request} req - 
+   * @param {Response} req - 
+   * @param {NextFunction} req - 
+   */
+  async uploadMedia(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { attachment } = req.files
+   
+    const linkMediaDTO: IMediaLinkDTO = this.matchedBodyData(req);
+    const modelName = linkMediaDTO.modelName
+      ? upperFirst(camelCase(linkMediaDTO.modelName)) : '';
+
+    try {
+      const media = await this.mediaService.upload(tenantId, attachment, modelName, linkMediaDTO.modelId);
+      return res.status(200).send({ media_id: media.id });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Deletes the given attachment ids from file system and database.
+   * @param {Request} req - 
+   * @param {Response} req - 
+   * @param {NextFunction} req - 
+   */
+  async deleteMedia(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { ids: mediaIds } = req.query;
+
+    try {
+      await this.mediaService.deleteMedia(tenantId, mediaIds);
+      return res.status(200).send({ 
+        media_ids: mediaIds
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Links the given media to the specific resource model.
+   * @param {Request} req 
+   * @param {Response} res 
+   * @param {NextFunction} next 
+   */
+  async linkMedia(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: mediaId } = req.params;
+    const linkMediaDTO: IMediaLinkDTO = this.matchedBodyData(req);
+    const modelName = upperFirst(camelCase(linkMediaDTO.modelName));
+
+    try {
+      await this.mediaService.linkMedia(tenantId, mediaId, linkMediaDTO.modelId, modelName);
+      return res.status(200).send({ media_id: mediaId });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handler service errors.
+   * @param {Error} error 
+   * @param {Request} req 
+   * @param {Response} res 
+   * @param {NextFunction} next 
+   */
+  handlerServiceErrors(error, req: Request, res: Response, next: NextFunction) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'MINETYPE_NOT_SUPPORTED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'MINETYPE_NOT_SUPPORTED', code: 100, }]
+        });
+      }
+      if (error.errorType === 'MEDIA_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'MEDIA_NOT_FOUND', code: 200 }]
+        });
+      }
+      if (error.errorType === 'MODEL_NAME_HAS_NO_MEDIA') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'MODEL_NAME_HAS_NO_MEDIA', code: 300 }]
+        });
+      }
+      if (error.errorType === 'MODEL_ID_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'MODEL_ID_NOT_FOUND', code: 400 }]
+        });
+      }
+      if (error.errorType === 'MEDIA_IDS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'MEDIA_IDS_NOT_FOUND', code: 500 }],
+        });
+      }
+      if (error.errorType === 'MEDIA_LINK_EXISTS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'MEDIA_LINK_EXISTS', code: 600 }],
+        });
+      }
+    }
+    next(error);
+  }
+};
diff --git a/packages/server/src/api/controllers/Miscellaneous/index.ts b/packages/server/src/api/controllers/Miscellaneous/index.ts
new file mode 100644
index 000000000..9d8e5367b
--- /dev/null
+++ b/packages/server/src/api/controllers/Miscellaneous/index.ts
@@ -0,0 +1,41 @@
+import { Inject, Service } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import BaseController from '@/api/controllers/BaseController';
+import MiscService from '@/services/Miscellaneous/MiscService';
+import DateFormatsService from '@/services/Miscellaneous/DateFormats';
+
+@Service()
+export default class MiscController extends BaseController {
+  @Inject()
+  dateFormatsService: DateFormatsService;
+
+  /**
+   * Express router.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/date_formats',
+      this.validationResult,
+      this.asyncMiddleware(this.dateFormats.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Retrieve date formats options.
+   * @param {Request} req 
+   * @param {Response} res 
+   * @param {NextFunction} next 
+   */
+  dateFormats(req: Request, res: Response, next: NextFunction) {
+    try {
+      const dateFormats = this.dateFormatsService.getDateFormats();
+
+      return res.status(200).send({ data: dateFormats });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/Organization.ts b/packages/server/src/api/controllers/Organization.ts
new file mode 100644
index 000000000..f133ec922
--- /dev/null
+++ b/packages/server/src/api/controllers/Organization.ts
@@ -0,0 +1,199 @@
+import { Inject, Service } from 'typedi';
+import moment from 'moment-timezone';
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, ValidationChain } from 'express-validator';
+
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import JWTAuth from '@/api/middleware/jwtAuth';
+import TenancyMiddleware from '@/api/middleware/TenancyMiddleware';
+import SubscriptionMiddleware from '@/api/middleware/SubscriptionMiddleware';
+import AttachCurrentTenantUser from '@/api/middleware/AttachCurrentTenantUser';
+import OrganizationService from '@/services/Organization/OrganizationService';
+import {
+  ACCEPTED_CURRENCIES,
+  MONTHS,
+  ACCEPTED_LOCALES,
+} from '@/services/Organization/constants';
+import { DATE_FORMATS } from '@/services/Miscellaneous/DateFormats/constants';
+
+import { ServiceError } from '@/exceptions';
+import BaseController from '@/api/controllers/BaseController';
+
+const ACCEPTED_LOCATIONS = ['libya'];
+
+@Service()
+export default class OrganizationController extends BaseController {
+  @Inject()
+  organizationService: OrganizationService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    // Should before build tenant database the user be authorized and
+    // most important than that, should be subscribed to any plan.
+    router.use(JWTAuth);
+    router.use(AttachCurrentTenantUser);
+    router.use(TenancyMiddleware);
+
+    router.use('/build', SubscriptionMiddleware('main'));
+    router.post(
+      '/build',
+      this.organizationValidationSchema,
+      this.validationResult,
+      asyncMiddleware(this.build.bind(this)),
+      this.handleServiceErrors.bind(this)
+    );
+    router.put(
+      '/',
+      this.organizationValidationSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.updateOrganization.bind(this)),
+      this.handleServiceErrors.bind(this)
+    );
+    router.get(
+      '/',
+      asyncMiddleware(this.currentOrganization.bind(this)),
+      this.handleServiceErrors.bind(this)
+    );
+    return router;
+  }
+
+  /**
+   * Organization setup schema.
+   * @return {ValidationChain[]}
+   */
+  private get organizationValidationSchema(): ValidationChain[] {
+    return [
+      check('name').exists().trim(),
+      check('industry').optional().isString(),
+      check('location').exists().isString().isIn(ACCEPTED_LOCATIONS),
+      check('base_currency').exists().isIn(ACCEPTED_CURRENCIES),
+      check('timezone').exists().isIn(moment.tz.names()),
+      check('fiscal_year').exists().isIn(MONTHS),
+      check('language').exists().isString().isIn(ACCEPTED_LOCALES),
+      check('date_format').optional().isIn(DATE_FORMATS),
+    ];
+  }
+
+  /**
+   * Builds tenant database and migrate database schema.
+   * @param {Request} req - Express request.
+   * @param {Response} res - Express response.
+   * @param {NextFunction} next
+   */
+  private async build(req: Request, res: Response, next: Function) {
+    const { tenantId, user } = req;
+    const buildDTO = this.matchedBodyData(req);
+
+    try {
+      const result = await this.organizationService.buildRunJob(
+        tenantId,
+        buildDTO,
+        user
+      );
+      return res.status(200).send({
+        type: 'success',
+        code: 'ORGANIZATION.DATABASE.INITIALIZED',
+        message: 'The organization database has been initialized.',
+        data: result,
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve the current organization of the associated authenticated user.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private async currentOrganization(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+
+    try {
+      const organization = await this.organizationService.currentOrganization(
+        tenantId
+      );
+      return res.status(200).send({
+        organization: this.transfromToResponse(organization),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Update the organization information.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @returns
+   */
+  private async updateOrganization(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+    const tenantDTO = this.matchedBodyData(req);
+
+    try {
+      await this.organizationService.updateOrganization(tenantId, tenantDTO);
+
+      return res.status(200).send(
+        this.transfromToResponse({
+          tenantId,
+          message: 'Organization information has been updated successfully.',
+        })
+      );
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handleServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'tenant_not_found') {
+        return res.status(400).send({
+          errors: [{ type: 'TENANT.NOT.FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'TENANT_ALREADY_BUILT') {
+        return res.status(400).send({
+          errors: [{ type: 'TENANT_ALREADY_BUILT', code: 200 }],
+        });
+      }
+      if (error.errorType === 'TENANT_IS_BUILDING') {
+        return res.status(400).send({
+          errors: [{ type: 'TENANT_IS_BUILDING', code: 300 }],
+        });
+      }
+      if (error.errorType === 'BASE_CURRENCY_MUTATE_LOCKED') {
+        return res.status(400).send({
+          errors: [{ type: 'BASE_CURRENCY_MUTATE_LOCKED', code: 400 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/OrganizationDashboard.ts b/packages/server/src/api/controllers/OrganizationDashboard.ts
new file mode 100644
index 000000000..a374645c7
--- /dev/null
+++ b/packages/server/src/api/controllers/OrganizationDashboard.ts
@@ -0,0 +1,124 @@
+import { Inject, Service } from 'typedi';
+import { Request, Response, Router, NextFunction } from 'express';
+import BaseController from '@/api/controllers/BaseController';
+import OrganizationService from '../../services/Organization/OrganizationService';
+import OrganizationUpgrade from '../../services/Organization/OrganizationUpgrade';
+import { ServiceError } from '../../exceptions';
+
+@Service()
+export default class OrganizationDashboardController extends BaseController {
+  @Inject()
+  organizationService: OrganizationService;
+
+  @Inject()
+  organizationUpgrade: OrganizationUpgrade;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/base_currency_mutate',
+      this.baseCurrencyMutateAbility.bind(this)
+    );
+    router.post(
+      '/upgrade',
+      this.validationResult,
+      this.asyncMiddleware(this.upgradeOrganization),
+      this.handleServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   *
+   * @param req
+   * @param res
+   * @param next
+   * @returns
+   */
+  private async baseCurrencyMutateAbility(
+    req: Request,
+    res: Response,
+    next: Function
+  ) {
+    const { tenantId } = req;
+
+    try {
+      const abilities =
+        await this.organizationService.mutateBaseCurrencyAbility(tenantId);
+
+      return res.status(200).send({ abilities });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Upgrade the authenticated organization.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   * @returns {Response}
+   */
+  public upgradeOrganization = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+
+    try {
+      // Upgrade organization database.
+      const { jobId } = await this.organizationUpgrade.upgrade(tenantId);
+
+      return res.status(200).send({
+        job_id: jobId,
+        message: 'The organization has been upgraded successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handle service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @returns
+   */
+  private handleServiceErrors = (
+    error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'TENANT_DATABASE_UPGRADED') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'TENANT_DATABASE_UPGRADED',
+              message: 'Organization database is already upgraded.',
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'TENANT_UPGRADE_IS_RUNNING') {
+        return res.status(200).send({
+          errors: [
+            {
+              type: 'TENANT_UPGRADE_IS_RUNNING',
+              message: 'Organization database upgrade is running.',
+            },
+          ],
+        });
+      }
+    }
+    next(error);
+  };
+}
diff --git a/packages/server/src/api/controllers/Ping.ts b/packages/server/src/api/controllers/Ping.ts
new file mode 100644
index 000000000..df199d8c2
--- /dev/null
+++ b/packages/server/src/api/controllers/Ping.ts
@@ -0,0 +1,28 @@
+import { Router, Request, Response } from 'express';
+
+export default class Ping {
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/',
+      this.ping,
+    );
+    return router;
+  }
+
+  /**
+   * Handle the ping request.
+   * @param {Request} req 
+   * @param {Response} res 
+   */
+  async ping(req: Request, res: Response)
+  {
+    return res.status(200).send({
+      server: true,
+    });
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/api/controllers/Projects/Projects.ts b/packages/server/src/api/controllers/Projects/Projects.ts
new file mode 100644
index 000000000..33155fa81
--- /dev/null
+++ b/packages/server/src/api/controllers/Projects/Projects.ts
@@ -0,0 +1,273 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query } from 'express-validator';
+import { Service, Inject } from 'typedi';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseController from '@/api/controllers/BaseController';
+import { AbilitySubject, IProjectStatus, ProjectAction } from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { ProjectsApplication } from '@/services/Projects/Projects/ProjectsApplication';
+
+@Service()
+export class ProjectsController extends BaseController {
+  @Inject()
+  private projectsApplication: ProjectsApplication;
+
+  /**
+   * Router constructor method.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/',
+      CheckPolicies(ProjectAction.CREATE, AbilitySubject.Project),
+      [
+        check('contact_id').exists(),
+        check('name').exists().trim(),
+        check('deadline').exists().isISO8601(),
+        check('cost_estimate').exists().isDecimal(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.createProject.bind(this)),
+      this.catchServiceErrors
+    );
+    router.post(
+      '/:id',
+      CheckPolicies(ProjectAction.EDIT, AbilitySubject.Project),
+      [
+        param('id').exists().isInt().toInt(),
+        check('contact_id').exists(),
+        check('name').exists().trim(),
+        check('deadline').exists().isISO8601(),
+        check('cost_estimate').exists().isDecimal(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.editProject.bind(this)),
+      this.catchServiceErrors
+    );
+    router.patch(
+      '/:projectId/status',
+      CheckPolicies(ProjectAction.EDIT, AbilitySubject.Project),
+      [
+        param('projectId').exists().isInt().toInt(),
+        check('status')
+          .exists()
+          .isIn([IProjectStatus.InProgress, IProjectStatus.Closed]),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.editProject.bind(this)),
+      this.catchServiceErrors
+    );
+    router.get(
+      '/:id',
+      CheckPolicies(ProjectAction.VIEW, AbilitySubject.Project),
+      [param('id').exists().isInt().toInt()],
+      this.validationResult,
+      asyncMiddleware(this.getProject.bind(this)),
+      this.catchServiceErrors
+    );
+    router.get(
+      '/:projectId/billable/entries',
+      CheckPolicies(ProjectAction.VIEW, AbilitySubject.Project),
+      [
+        param('projectId').exists().isInt().toInt(),
+        query('billable_type').optional().toArray(),
+        query('to_date').optional().isISO8601(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.projectBillableEntries.bind(this)),
+      this.catchServiceErrors
+    );
+    router.get(
+      '/',
+      CheckPolicies(ProjectAction.VIEW, AbilitySubject.Project),
+      [],
+      this.validationResult,
+      asyncMiddleware(this.getProjects.bind(this)),
+      this.catchServiceErrors
+    );
+    router.delete(
+      '/:id',
+      CheckPolicies(ProjectAction.DELETE, AbilitySubject.Project),
+      [param('id').exists().isInt().toInt()],
+      this.validationResult,
+      asyncMiddleware(this.deleteProject.bind(this)),
+      this.catchServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Creates a new project.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  private async createProject(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const projectDTO = this.matchedBodyData(req);
+
+    try {
+      const account = await this.projectsApplication.createProject(
+        tenantId,
+        projectDTO
+      );
+      return res.status(200).send({
+        id: account.id,
+        message: 'The project has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Edit project details.
+   * @param  {Request} req
+   * @param  {Response} res
+   * @return {Response}
+   */
+  private async editProject(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { projectId } = req.params;
+
+    const editProjectDTO = this.matchedBodyData(req);
+
+    try {
+      const account = await this.projectsApplication.editProjectStatus(
+        tenantId,
+        projectId,
+        editProjectDTO.status
+      );
+      return res.status(200).send({
+        id: account.id,
+        message: 'The project has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Get details of the given account.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  private async getProject(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: projectId } = req.params;
+
+    try {
+      const project = await this.projectsApplication.getProject(
+        tenantId,
+        projectId
+      );
+      return res.status(200).send({ project });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Delete the given account.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  private async deleteProject(req: Request, res: Response, next: NextFunction) {
+    const { id: accountId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      await this.projectsApplication.deleteProject(tenantId, accountId);
+
+      return res.status(200).send({
+        id: accountId,
+        message: 'The deleted project has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve accounts datatable list.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {Response}
+   */
+  private async getProjects(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+
+    // Filter query.
+    const filter = {
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      inactiveMode: false,
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const projects = await this.projectsApplication.getProjects(
+        tenantId,
+        filter
+      );
+      return res.status(200).send({
+        projects,
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieves the given billable entries of the given project.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @returns {Response}
+   */
+  private projectBillableEntries = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { projectId } = req.params;
+    const query = this.matchedQueryData(req);
+
+    try {
+      const billableEntries =
+        await this.projectsApplication.getProjectBillableEntries(
+          tenantId,
+          projectId,
+          query
+        );
+      return res.status(200).send({
+        billableEntries,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Transforms service errors to response.
+   * @param {Error}
+   * @param {Request} req
+   * @param {Response} res
+   * @param {ServiceError} error
+   */
+  private catchServiceErrors(
+    error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Projects/Tasks.ts b/packages/server/src/api/controllers/Projects/Tasks.ts
new file mode 100644
index 000000000..4c6551b18
--- /dev/null
+++ b/packages/server/src/api/controllers/Projects/Tasks.ts
@@ -0,0 +1,211 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query } from 'express-validator';
+import { Service, Inject } from 'typedi';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseController from '@/api/controllers/BaseController';
+import { AbilitySubject, AccountAction } from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { TasksApplication } from '@/services/Projects/Tasks/TasksApplication';
+import { ProjectTaskChargeType } from '@/services/Projects/Tasks/constants';
+
+@Service()
+export class ProjectTasksController extends BaseController {
+  @Inject()
+  private tasksApplication: TasksApplication;
+
+  /**
+   * Router constructor method.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/projects/:projectId/tasks',
+      CheckPolicies(AccountAction.CREATE, AbilitySubject.Project),
+      [
+        check('name').exists(),
+        check('charge_type')
+          .exists()
+          .trim()
+          .toUpperCase()
+          .isIn(Object.values(ProjectTaskChargeType)),
+        check('rate').exists(),
+        check('estimate_hours').exists(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.createTask.bind(this)),
+      this.catchServiceErrors
+    );
+    router.post(
+      '/tasks/:taskId',
+      CheckPolicies(AccountAction.EDIT, AbilitySubject.Project),
+      [
+        param('taskId').exists().isInt().toInt(),
+        check('name').exists(),
+        check('charge_type').exists().trim(),
+        check('rate').exists(),
+        check('estimate_hours').exists(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.editTask.bind(this)),
+      this.catchServiceErrors
+    );
+    router.get(
+      '/tasks/:taskId',
+      CheckPolicies(AccountAction.VIEW, AbilitySubject.Project),
+      [param('taskId').exists().isInt().toInt()],
+      this.validationResult,
+      asyncMiddleware(this.getTask.bind(this)),
+      this.catchServiceErrors
+    );
+    router.get(
+      '/projects/:projectId/tasks',
+      CheckPolicies(AccountAction.VIEW, AbilitySubject.Project),
+      [param('projectId').exists().isInt().toInt()],
+      this.validationResult,
+      asyncMiddleware(this.getTasks.bind(this)),
+      this.catchServiceErrors
+    );
+    router.delete(
+      '/tasks/:taskId',
+      CheckPolicies(AccountAction.DELETE, AbilitySubject.Project),
+      [param('taskId').exists().isInt().toInt()],
+      this.validationResult,
+      asyncMiddleware(this.deleteTask.bind(this)),
+      this.catchServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Creates a new project.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  async createTask(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { projectId } = req.params;
+    const taskDTO = this.matchedBodyData(req);
+
+    try {
+      const task = await this.tasksApplication.createTask(
+        tenantId,
+        projectId,
+        taskDTO
+      );
+      return res.status(200).send({
+        id: task.id,
+        message: 'The task has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Edit project details.
+   * @param  {Request} req
+   * @param  {Response} res
+   * @return {Response}
+   */
+  async editTask(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { taskId } = req.params;
+
+    const editTaskDTO = this.matchedBodyData(req);
+
+    try {
+      const task = await this.tasksApplication.editTask(
+        tenantId,
+        taskId,
+        editTaskDTO
+      );
+      return res.status(200).send({
+        id: task.id,
+        message: 'The task has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Get details of the given task.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async getTask(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { taskId } = req.params;
+
+    try {
+      const task = await this.tasksApplication.getTask(tenantId, taskId);
+
+      return res.status(200).send({ task });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Delete the given task.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async deleteTask(req: Request, res: Response, next: NextFunction) {
+    const { taskId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      await this.tasksApplication.deleteTask(tenantId, taskId);
+
+      return res.status(200).send({
+        id: taskId,
+        message: 'The deleted task has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve accounts datatable list.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {Response}
+   */
+  public async getTasks(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { projectId } = req.params;
+
+    try {
+      const tasks = await this.tasksApplication.getTasks(tenantId, projectId);
+
+      return res.status(200).send({ tasks });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Transforms service errors to response.
+   * @param {Error}
+   * @param {Request} req
+   * @param {Response} res
+   * @param {ServiceError} error
+   */
+  private catchServiceErrors(
+    error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Projects/Times.ts b/packages/server/src/api/controllers/Projects/Times.ts
new file mode 100644
index 000000000..a74edcf48
--- /dev/null
+++ b/packages/server/src/api/controllers/Projects/Times.ts
@@ -0,0 +1,253 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query } from 'express-validator';
+import { Service, Inject } from 'typedi';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseController from '@/api/controllers/BaseController';
+import { AbilitySubject, AccountAction } from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { TimesApplication } from '@/services/Projects/Times/TimesApplication';
+
+@Service()
+export class ProjectTimesController extends BaseController {
+  @Inject()
+  private timesApplication: TimesApplication;
+
+  /**
+   * Router constructor method.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/projects/tasks/:taskId/times',
+      CheckPolicies(AccountAction.CREATE, AbilitySubject.Project),
+      [
+        param('taskId').exists().isInt().toInt(),
+        check('duration').exists().isDecimal(),
+        check('description').exists().trim(),
+        check('date').exists().isISO8601(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.createTime.bind(this)),
+      this.catchServiceErrors
+    );
+    router.post(
+      '/projects/times/:timeId',
+      CheckPolicies(AccountAction.EDIT, AbilitySubject.Project),
+      [
+        param('timeId').exists().isInt().toInt(),
+        check('duration').exists().isDecimal(),
+        check('description').exists().trim(),
+        check('date').exists().isISO8601(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.editTime.bind(this)),
+      this.catchServiceErrors
+    );
+    router.get(
+      '/projects/times/:timeId',
+      CheckPolicies(AccountAction.VIEW, AbilitySubject.Project),
+      [
+        param('timeId').exists().isInt().toInt(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.getTime.bind(this)),
+      this.catchServiceErrors
+    );
+    router.get(
+      '/projects/:projectId/times',
+      CheckPolicies(AccountAction.VIEW, AbilitySubject.Project),
+      [
+        param('projectId').exists().isInt().toInt(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.getTimeline.bind(this)),
+      this.catchServiceErrors
+    );
+    router.delete(
+      '/projects/times/:timeId',
+      CheckPolicies(AccountAction.DELETE, AbilitySubject.Project),
+      [
+        param('timeId').exists().isInt().toInt(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.deleteTime.bind(this)),
+      this.catchServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Project create DTO Schema validation.
+   */
+  get createTimeDTOSchema() {
+    return [];
+  }
+
+  /**
+   * Project edit DTO Schema validation.
+   */
+  get editProjectDTOSchema() {
+    return [
+      check('contact_id').exists(),
+      check('name').exists().trim(),
+      check('deadline').exists({ nullable: true }).isISO8601(),
+      check('cost_estimate').exists().isDecimal(),
+    ];
+  }
+
+  get accountParamSchema() {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  /**
+   * Accounts list validation schema.
+   */
+  get accountsListSchema() {
+    return [
+      query('view_slug').optional({ nullable: true }).isString().trim(),
+      query('stringified_filter_roles').optional().isJSON(),
+
+      query('column_sort_by').optional(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+
+      query('inactive_mode').optional().isBoolean().toBoolean(),
+      query('search_keyword').optional({ nullable: true }).isString().trim(),
+    ];
+  }
+
+  /**
+   * Creates a new project.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  async createTime(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { taskId } = req.params;
+    const taskDTO = this.matchedBodyData(req);
+
+    try {
+      const task = await this.timesApplication.createTime(
+        tenantId,
+        taskId,
+        taskDTO
+      );
+      return res.status(200).send({
+        id: task.id,
+        message: 'The time entry has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Edit project details.
+   * @param  {Request} req
+   * @param  {Response} res
+   * @return {Response}
+   */
+  async editTime(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { timeId } = req.params;
+
+    const editTaskDTO = this.matchedBodyData(req);
+
+    try {
+      const task = await this.timesApplication.editTime(
+        tenantId,
+        timeId,
+        editTaskDTO
+      );
+      return res.status(200).send({
+        id: task.id,
+        message: 'The task has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Get details of the given task.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async getTime(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { timeId } = req.params;
+
+    try {
+      const timeEntry = await this.timesApplication.getTime(tenantId, timeId);
+
+      return res.status(200).send({ timeEntry });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Delete the given task.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async deleteTime(req: Request, res: Response, next: NextFunction) {
+    const { timeId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      await this.timesApplication.deleteTime(tenantId, timeId);
+
+      return res.status(200).send({
+        id: timeId,
+        message: 'The deleted task has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve accounts datatable list.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {Response}
+   */
+  public async getTimeline(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { projectId } = req.params;
+
+    try {
+      const timeline = await this.timesApplication.getTimeline(
+        tenantId,
+        projectId
+      );
+
+      return res.status(200).send({ timeline });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Transforms service errors to response.
+   * @param {Error}
+   * @param {Request} req
+   * @param {Response} res
+   * @param {ServiceError} error
+   */
+  private catchServiceErrors(
+    error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Purchases/Bills.ts b/packages/server/src/api/controllers/Purchases/Bills.ts
new file mode 100644
index 000000000..3c1ef0311
--- /dev/null
+++ b/packages/server/src/api/controllers/Purchases/Bills.ts
@@ -0,0 +1,547 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query } from 'express-validator';
+import { Service, Inject } from 'typedi';
+import { AbilitySubject, BillAction, IBillDTO, IBillEditDTO } from '@/interfaces';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BillsService from '@/services/Purchases/Bills';
+import BaseController from '@/api/controllers/BaseController';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { ServiceError } from '@/exceptions';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import BillPaymentsService from '@/services/Purchases/BillPaymentsService';
+
+@Service()
+export default class BillsController extends BaseController {
+  @Inject()
+  private billsService: BillsService;
+
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  @Inject()
+  private billPayments: BillPaymentsService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/',
+      CheckPolicies(BillAction.Create, AbilitySubject.Bill),
+      [...this.billValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.newBill.bind(this)),
+      this.handleServiceError
+    );
+    router.post(
+      '/:id/open',
+      CheckPolicies(BillAction.Edit, AbilitySubject.Bill),
+      [...this.specificBillValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.openBill.bind(this)),
+      this.handleServiceError
+    );
+    router.post(
+      '/:id',
+      CheckPolicies(BillAction.Edit, AbilitySubject.Bill),
+      [...this.billEditValidationSchema, ...this.specificBillValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.editBill.bind(this)),
+      this.handleServiceError
+    );
+    router.get(
+      '/due',
+      CheckPolicies(BillAction.View, AbilitySubject.Bill),
+      [...this.dueBillsListingValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.getDueBills.bind(this)),
+      this.handleServiceError
+    );
+    router.get(
+      '/:id',
+      CheckPolicies(BillAction.View, AbilitySubject.Bill),
+      [...this.specificBillValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.getBill.bind(this)),
+      this.handleServiceError
+    );
+    router.get(
+      '/:id/payment-transactions',
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.getBillPaymentsTransactions),
+      this.handleServiceError
+    );
+    router.get(
+      '/',
+      CheckPolicies(BillAction.View, AbilitySubject.Bill),
+      [...this.billsListingValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.billsList.bind(this)),
+      this.handleServiceError,
+      this.dynamicListService.handlerErrorsToResponse
+    );
+    router.delete(
+      '/:id',
+      CheckPolicies(BillAction.Delete, AbilitySubject.Bill),
+      [...this.specificBillValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.deleteBill.bind(this)),
+      this.handleServiceError
+    );
+    return router;
+  }
+
+  /**
+   * Common validation schema.
+   */
+  get billValidationSchema() {
+    return [
+      check('bill_number').exists().trim().escape(),
+      check('reference_no').optional().trim().escape(),
+      check('bill_date').exists().isISO8601(),
+      check('due_date').optional().isISO8601(),
+
+      check('vendor_id').exists().isNumeric().toInt(),
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+
+      check('warehouse_id').optional({ nullable: true }).isNumeric().toInt(),
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+      check('project_id').optional({ nullable: true }).isNumeric().toInt(),
+
+      check('note').optional().trim().escape(),
+      check('open').default(false).isBoolean().toBoolean(),
+
+      check('entries').isArray({ min: 1 }),
+
+      check('entries.*.index').exists().isNumeric().toInt(),
+      check('entries.*.item_id').exists().isNumeric().toInt(),
+      check('entries.*.rate').exists().isNumeric().toFloat(),
+      check('entries.*.quantity').exists().isNumeric().toFloat(),
+      check('entries.*.discount')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toFloat(),
+      check('entries.*.description')
+        .optional({ nullable: true })
+        .trim()
+        .escape(),
+      check('entries.*.landed_cost')
+        .optional({ nullable: true })
+        .isBoolean()
+        .toBoolean(),
+      check('entries.*.warehouse_id')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toInt(),
+    ];
+  }
+
+  /**
+   * Common validation schema.
+   */
+  get billEditValidationSchema() {
+    return [
+      check('bill_number').optional().trim().escape(),
+      check('reference_no').optional().trim().escape(),
+      check('bill_date').exists().isISO8601(),
+      check('due_date').optional().isISO8601(),
+
+      check('vendor_id').exists().isNumeric().toInt(),
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+
+      check('warehouse_id').optional({ nullable: true }).isNumeric().toInt(),
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+      check('project_id').optional({ nullable: true }).isNumeric().toInt(),
+
+      check('note').optional().trim().escape(),
+      check('open').default(false).isBoolean().toBoolean(),
+
+      check('entries').isArray({ min: 1 }),
+
+      check('entries.*.id').optional().isNumeric().toInt(),
+      check('entries.*.index').exists().isNumeric().toInt(),
+      check('entries.*.item_id').exists().isNumeric().toInt(),
+      check('entries.*.rate').exists().isNumeric().toFloat(),
+      check('entries.*.quantity').exists().isNumeric().toFloat(),
+      check('entries.*.discount')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toFloat(),
+      check('entries.*.description')
+        .optional({ nullable: true })
+        .trim()
+        .escape(),
+      check('entries.*.landed_cost')
+        .optional({ nullable: true })
+        .isBoolean()
+        .toBoolean(),
+    ];
+  }
+
+  /**
+   * Bill validation schema.
+   */
+  get specificBillValidationSchema() {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  /**
+   * Bills list validation schema.
+   */
+  get billsListingValidationSchema() {
+    return [
+      query('view_slug').optional().isString().trim(),
+      query('stringified_filter_roles').optional().isJSON(),
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+      query('column_sort_by').optional(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+      query('search_keyword').optional({ nullable: true }).isString().trim(),
+    ];
+  }
+
+  get dueBillsListingValidationSchema() {
+    return [
+      query('vendor_id').optional().trim().escape(),
+      query('payment_made_id').optional().trim().escape(),
+    ];
+  }
+
+  /**
+   * Creates a new bill and records journal transactions.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {Function} next
+   */
+  async newBill(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const billDTO: IBillDTO = this.matchedBodyData(req);
+
+    try {
+      const storedBill = await this.billsService.createBill(
+        tenantId,
+        billDTO,
+        user
+      );
+
+      return res.status(200).send({
+        id: storedBill.id,
+        message: 'The bill has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Edit bill details with associated entries and rewrites journal transactions.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async editBill(req: Request, res: Response, next: NextFunction) {
+    const { id: billId } = req.params;
+    const { tenantId, user } = req;
+    const billDTO: IBillEditDTO = this.matchedBodyData(req);
+
+    try {
+      await this.billsService.editBill(tenantId, billId, billDTO, user);
+
+      return res.status(200).send({
+        id: billId,
+        message: 'The bill has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Open the given bill.
+   * @param {Request} req -
+   * @param {Response} res -
+   */
+  async openBill(req: Request, res: Response, next: NextFunction) {
+    const { id: billId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      await this.billsService.openBill(tenantId, billId);
+
+      return res.status(200).send({
+        id: billId,
+        message: 'The bill has been opened successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve the given bill details with associated item entries.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async getBill(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: billId } = req.params;
+
+    try {
+      const bill = await this.billsService.getBill(tenantId, billId);
+
+      return res.status(200).send(this.transfromToResponse({ bill }));
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Deletes the given bill with associated entries and journal transactions.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @return {Response}
+   */
+  async deleteBill(req: Request, res: Response, next: NextFunction) {
+    const billId = req.params.id;
+    const { tenantId } = req;
+
+    try {
+      await this.billsService.deleteBill(tenantId, billId);
+
+      return res.status(200).send({
+        id: billId,
+        message: 'The given bill deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Listing bills with pagination meta.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @return {Response}
+   */
+  public async billsList(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const filter = {
+      page: 1,
+      pageSize: 12,
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const { bills, pagination, filterMeta } =
+        await this.billsService.getBills(tenantId, filter);
+
+      return res.status(200).send({
+        bills: this.transfromToResponse(bills),
+        pagination: this.transfromToResponse(pagination),
+        filter_meta: this.transfromToResponse(filterMeta),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Listing all due bills of the given vendor.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public async getDueBills(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { vendorId } = this.matchedQueryData(req);
+
+    try {
+      const bills = await this.billsService.getDueBills(tenantId, vendorId);
+      return res.status(200).send({ bills });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve payments transactions of specific bill.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public getBillPaymentsTransactions = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: billId } = req.params;
+
+    try {
+      const billPayments = await this.billPayments.getBillPayments(
+        tenantId,
+        billId
+      );
+      return res.status(200).send({
+        data: billPayments,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handleServiceError(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'BILL_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'BILL_NOT_FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'BILL_NUMBER_EXISTS') {
+        return res.status(400).send({
+          errors: [{ type: 'BILL.NUMBER.EXISTS', code: 500 }],
+        });
+      }
+      if (error.errorType === 'BILL_VENDOR_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'BILL_VENDOR_NOT_FOUND', code: 600 }],
+        });
+      }
+      if (error.errorType === 'BILL_ITEMS_NOT_PURCHASABLE') {
+        return res.status(400).send({
+          errors: [{ type: 'BILL_ITEMS_NOT_PURCHASABLE', code: 700 }],
+        });
+      }
+      if (error.errorType === 'NOT_PURCHASE_ABLE_ITEMS') {
+        return res.status(400).send({
+          errors: [{ type: 'NOT_PURCHASE_ABLE_ITEMS', code: 800 }],
+        });
+      }
+      if (error.errorType === 'BILL_ITEMS_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'ITEMS.IDS.NOT.FOUND', code: 400 }],
+        });
+      }
+      if (error.errorType === 'BILL_ENTRIES_IDS_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'BILL_ENTRIES_IDS_NOT_FOUND', code: 900 }],
+        });
+      }
+      if (error.errorType === 'ITEMS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ITEMS_NOT_FOUND', code: 1000 }],
+        });
+      }
+      if (error.errorType === 'BILL_ALREADY_OPEN') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'BILL_ALREADY_OPEN', code: 1100 }],
+        });
+      }
+      if (error.errorType === 'contact_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'VENDOR_NOT_FOUND',
+              message: 'Vendor not found.',
+              code: 1200,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'BILL_HAS_ASSOCIATED_PAYMENT_ENTRIES') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'BILL_HAS_ASSOCIATED_PAYMENT_ENTRIES',
+              message:
+                'Cannot delete bill that has associated payment transactions.',
+              code: 1200,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'BILL_HAS_ASSOCIATED_LANDED_COSTS') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'BILL_HAS_ASSOCIATED_LANDED_COSTS',
+              message:
+                'Cannot delete bill that has associated landed cost transactions.',
+              code: 1300,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'ENTRIES_ALLOCATED_COST_COULD_NOT_DELETED') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'ENTRIES_ALLOCATED_COST_COULD_NOT_DELETED',
+              code: 1400,
+              message:
+                'Bill entries that have landed cost type can not be deleted.',
+            },
+          ],
+        });
+      }
+      if (
+        error.errorType === 'LOCATED_COST_ENTRIES_SHOULD_BIGGE_THAN_NEW_ENTRIES'
+      ) {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'LOCATED_COST_ENTRIES_SHOULD_BIGGE_THAN_NEW_ENTRIES',
+              code: 1500,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'LANDED_COST_ENTRIES_SHOULD_BE_INVENTORY_ITEMS') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'LANDED_COST_ENTRIES_SHOULD_BE_INVENTORY_ITEMS',
+              message:
+                'Landed cost entries should be only with inventory items.',
+              code: 1600,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'BILL_HAS_APPLIED_TO_VENDOR_CREDIT') {
+        return res.status(400).send({
+          errors: [{ type: 'BILL_HAS_APPLIED_TO_VENDOR_CREDIT', code: 1700 }],
+        });
+      }
+      if (error.errorType === 'TRANSACTIONS_DATE_LOCKED') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'TRANSACTIONS_DATE_LOCKED',
+              code: 4000,
+              data: { ...error.payload },
+            },
+          ],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Purchases/BillsPayments.ts b/packages/server/src/api/controllers/Purchases/BillsPayments.ts
new file mode 100644
index 000000000..5af4010d4
--- /dev/null
+++ b/packages/server/src/api/controllers/Purchases/BillsPayments.ts
@@ -0,0 +1,455 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { Service, Inject } from 'typedi';
+import { check, param, query, ValidationChain } from 'express-validator';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import { ServiceError } from '@/exceptions';
+import BaseController from '@/api/controllers/BaseController';
+import BillPaymentsService from '@/services/Purchases/BillPayments/BillPayments';
+import BillPaymentsPages from '@/services/Purchases/BillPayments/BillPaymentsPages';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { AbilitySubject, IPaymentMadeAction } from '@/interfaces';
+
+/**
+ * Bills payments controller.
+ * @service
+ */
+@Service()
+export default class BillsPayments extends BaseController {
+  @Inject()
+  billPaymentService: BillPaymentsService;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  @Inject()
+  billPaymentsPages: BillPaymentsPages;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/',
+      CheckPolicies(IPaymentMadeAction.Create, AbilitySubject.PaymentMade),
+      [...this.billPaymentSchemaValidation],
+      this.validationResult,
+      asyncMiddleware(this.createBillPayment.bind(this)),
+      this.handleServiceError
+    );
+    router.post(
+      '/:id',
+      CheckPolicies(IPaymentMadeAction.Edit, AbilitySubject.PaymentMade),
+      [
+        ...this.billPaymentSchemaValidation,
+        ...this.specificBillPaymentValidateSchema,
+      ],
+      this.validationResult,
+      asyncMiddleware(this.editBillPayment.bind(this)),
+      this.handleServiceError
+    );
+    router.delete(
+      '/:id',
+      CheckPolicies(IPaymentMadeAction.Delete, AbilitySubject.PaymentMade),
+      [...this.specificBillPaymentValidateSchema],
+      this.validationResult,
+      asyncMiddleware(this.deleteBillPayment.bind(this)),
+      this.handleServiceError
+    );
+    router.get(
+      '/new-page/entries',
+      CheckPolicies(IPaymentMadeAction.View, AbilitySubject.PaymentMade),
+      [query('vendor_id').exists()],
+      this.validationResult,
+      asyncMiddleware(this.getBillPaymentNewPageEntries.bind(this)),
+      this.handleServiceError
+    );
+    router.get(
+      '/:id/edit-page',
+      CheckPolicies(IPaymentMadeAction.View, AbilitySubject.PaymentMade),
+      this.specificBillPaymentValidateSchema,
+      this.validationResult,
+      asyncMiddleware(this.getBillPaymentEditPage.bind(this)),
+      this.handleServiceError
+    );
+    router.get(
+      '/:id/bills',
+      CheckPolicies(IPaymentMadeAction.View, AbilitySubject.PaymentMade),
+      this.specificBillPaymentValidateSchema,
+      this.validationResult,
+      asyncMiddleware(this.getPaymentBills.bind(this)),
+      this.handleServiceError
+    );
+    router.get(
+      '/:id',
+      CheckPolicies(IPaymentMadeAction.View, AbilitySubject.PaymentMade),
+      this.specificBillPaymentValidateSchema,
+      this.validationResult,
+      asyncMiddleware(this.getBillPayment.bind(this)),
+      this.handleServiceError
+    );
+    router.get(
+      '/',
+      CheckPolicies(IPaymentMadeAction.View, AbilitySubject.PaymentMade),
+      this.listingValidationSchema,
+      this.validationResult,
+      asyncMiddleware(this.getBillsPayments.bind(this)),
+      this.handleServiceError,
+      this.dynamicListService.handlerErrorsToResponse
+    );
+    return router;
+  }
+
+  /**
+   * Bill payments schema validation.
+   * @return {ValidationChain[]}
+   */
+  get billPaymentSchemaValidation(): ValidationChain[] {
+    return [
+      check('vendor_id').exists().isNumeric().toInt(),
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+
+      check('payment_account_id').exists().isNumeric().toInt(),
+      check('payment_number').optional({ nullable: true }).trim().escape(),
+      check('payment_date').exists(),
+      check('statement').optional().trim().escape(),
+      check('reference').optional().trim().escape(),
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+
+      check('entries').exists().isArray({ min: 1 }),
+      check('entries.*.index').optional().isNumeric().toInt(),
+      check('entries.*.bill_id').exists().isNumeric().toInt(),
+      check('entries.*.payment_amount').exists().isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Specific bill payment schema validation.
+   * @returns {ValidationChain[]}
+   */
+  get specificBillPaymentValidateSchema(): ValidationChain[] {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  /**
+   * Bills payment list validation schema.
+   * @returns {ValidationChain[]}
+   */
+  get listingValidationSchema(): ValidationChain[] {
+    return [
+      query('custom_view_id').optional().isNumeric().toInt(),
+      query('stringified_filter_roles').optional().isJSON(),
+      query('column_sort_by').optional(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+      query('search_keyword').optional({ nullable: true }).isString().trim(),
+    ];
+  }
+
+  /**
+   * Retrieve bill payment new page entries.
+   * @param {Request} req -
+   * @param {Response} res -
+   */
+  async getBillPaymentNewPageEntries(req: Request, res: Response) {
+    const { tenantId } = req;
+    const { vendorId } = this.matchedQueryData(req);
+
+    try {
+      const entries = await this.billPaymentsPages.getNewPageEntries(
+        tenantId,
+        vendorId
+      );
+      return res.status(200).send({
+        entries: this.transfromToResponse(entries),
+      });
+    } catch (error) {}
+  }
+
+  /**
+   * Retrieve the bill payment edit page details.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async getBillPaymentEditPage(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+    const { id: paymentReceiveId } = req.params;
+
+    try {
+      const { billPayment, entries } =
+        await this.billPaymentsPages.getBillPaymentEditPage(
+          tenantId,
+          paymentReceiveId
+        );
+
+      return res.status(200).send({
+        bill_payment: this.transfromToResponse(billPayment),
+        entries: this.transfromToResponse(entries),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Creates a bill payment.
+   * @async
+   * @param {Request} req
+   * @param {Response} res
+   * @param {Response} res
+   */
+  async createBillPayment(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const billPaymentDTO = this.matchedBodyData(req);
+
+    try {
+      const billPayment = await this.billPaymentService.createBillPayment(
+        tenantId,
+        billPaymentDTO
+      );
+
+      return res.status(200).send({
+        id: billPayment.id,
+        message: 'Payment made has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Edits the given bill payment details.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async editBillPayment(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const billPaymentDTO = this.matchedBodyData(req);
+    const { id: billPaymentId } = req.params;
+
+    try {
+      const paymentMade = await this.billPaymentService.editBillPayment(
+        tenantId,
+        billPaymentId,
+        billPaymentDTO
+      );
+      return res.status(200).send({
+        id: paymentMade.id,
+        message: 'Payment made has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Deletes the bill payment and revert the journal
+   * transactions with accounts balance.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @return {Response} res -
+   */
+  async deleteBillPayment(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: billPaymentId } = req.params;
+
+    try {
+      await this.billPaymentService.deleteBillPayment(tenantId, billPaymentId);
+
+      return res.status(200).send({
+        id: billPaymentId,
+        message: 'Payment made has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve the bill payment.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async getBillPayment(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: billPaymentId } = req.params;
+
+    try {
+      const billPayment = await this.billPaymentService.getBillPayment(
+        tenantId,
+        billPaymentId
+      );
+
+      return res.status(200).send({
+        bill_payment: this.transfromToResponse(billPayment),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve associated bills for the given payment made.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async getPaymentBills(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: billPaymentId } = req.params;
+
+    try {
+      const bills = await this.billPaymentService.getPaymentBills(
+        tenantId,
+        billPaymentId
+      );
+      return res.status(200).send({ bills });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve bills payments listing with pagination metadata.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @return {Response}
+   */
+  async getBillsPayments(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const billPaymentsFilter = {
+      page: 1,
+      pageSize: 12,
+      filterRoles: [],
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const { billPayments, pagination, filterMeta } =
+        await this.billPaymentService.listBillPayments(
+          tenantId,
+          billPaymentsFilter
+        );
+
+      return res.status(200).send({
+        bill_payments: this.transfromToResponse(billPayments),
+        pagination: this.transfromToResponse(pagination),
+        filter_meta: this.transfromToResponse(filterMeta),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handle service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  handleServiceError(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'PAYMENT_MADE_NOT_FOUND') {
+        return res.status(404).send({
+          message: 'Payment made not found.',
+          errors: [{ type: 'BILL_NOT_FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'VENDOR_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'BILL.PAYMENT.VENDOR.NOT.FOUND', code: 200 }],
+        });
+      }
+      if (error.errorType === 'PAYMENT_ACCOUNT_NOT_CURRENT_ASSET_TYPE') {
+        return res.status(400).send({
+          errors: [
+            { type: 'PAYMENT_ACCOUNT.NOT.CURRENT_ASSET.TYPE', code: 300 },
+          ],
+        });
+      }
+      if (error.errorType === 'BILL_PAYMENT_NUMBER_NOT_UNQIUE') {
+        return res.status(400).send({
+          errors: [{ type: 'PAYMENT.NUMBER.NOT.UNIQUE', code: 400 }],
+        });
+      }
+      if (error.errorType === 'PAYMENT_ACCOUNT_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'PAYMENT.ACCOUNT.NOT.FOUND', code: 500 }],
+        });
+      }
+      if (error.errorType === 'PAYMENT_ACCOUNT_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'PAYMENT.ACCOUNT.NOT.FOUND', code: 600 }],
+        });
+      }
+      if (error.errorType === '') {
+        return res.status(400).send({
+          errors: [{ type: 'BILLS.IDS.NOT.EXISTS', code: 700 }],
+        });
+      }
+      if (error.errorType === 'BILL_PAYMENT_ENTRIES_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'ENTEIES.IDS.NOT.FOUND', code: 800 }],
+        });
+      }
+      if (error.errorType === 'INVALID_BILL_PAYMENT_AMOUNT') {
+        return res.status(400).send({
+          errors: [{ type: 'INVALID_BILL_PAYMENT_AMOUNT', code: 900 }],
+        });
+      }
+      if (error.errorType === 'BILL_ENTRIES_IDS_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'BILLS_NOT_FOUND', code: 1000 }],
+        });
+      }
+      if (error.errorType === 'PAYMENT_NUMBER_SHOULD_NOT_MODIFY') {
+        return res.status(400).send({
+          errors: [{ type: 'PAYMENT_NUMBER_SHOULD_NOT_MODIFY', code: 1100 }],
+        });
+      }
+      if (error.errorType === 'BILLS_NOT_OPENED_YET') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'BILLS_NOT_OPENED_YET',
+              message: 'The given bills are not opened yet.',
+              code: 1200,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'TRANSACTIONS_DATE_LOCKED') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'TRANSACTIONS_DATE_LOCKED',
+              code: 4000,
+              data: { ...error.payload },
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'WITHDRAWAL_ACCOUNT_CURRENCY_INVALID') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'WITHDRAWAL_ACCOUNT_CURRENCY_INVALID', code: 1300 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Purchases/LandedCost.ts b/packages/server/src/api/controllers/Purchases/LandedCost.ts
new file mode 100644
index 000000000..4cb086d6f
--- /dev/null
+++ b/packages/server/src/api/controllers/Purchases/LandedCost.ts
@@ -0,0 +1,305 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query } from 'express-validator';
+import { Service, Inject } from 'typedi';
+import { ServiceError } from '@/exceptions';
+import BillAllocatedCostTransactions from '@/services/Purchases/LandedCost/BillAllocatedLandedCostTransactions';
+import BaseController from '../BaseController';
+import AllocateLandedCost from '@/services/Purchases/LandedCost/AllocateLandedCost';
+import RevertAllocatedLandedCost from '@/services/Purchases/LandedCost/RevertAllocatedLandedCost';
+import LandedCostTranasctions from '@/services/Purchases/LandedCost/LandedCostTransactions';
+
+@Service()
+export default class BillAllocateLandedCost extends BaseController {
+  @Inject()
+  allocateLandedCost: AllocateLandedCost;
+
+  @Inject()
+  billAllocatedCostTransactions: BillAllocatedCostTransactions;
+
+  @Inject()
+  revertAllocatedLandedCost: RevertAllocatedLandedCost;
+
+  @Inject()
+  landedCostTranasctions: LandedCostTranasctions;
+
+  /**
+   * Router constructor.
+   */
+  public router() {
+    const router = Router();
+
+    router.post(
+      '/bills/:billId/allocate',
+      [
+        check('transaction_id').exists().isInt(),
+        check('transaction_type').exists().isIn(['Expense', 'Bill']),
+        check('transaction_entry_id').exists().isInt(),
+
+        check('allocation_method').exists().isIn(['value', 'quantity']),
+        check('description').optional({ nullable: true }),
+
+        check('items').isArray({ min: 1 }),
+        check('items.*.entry_id').isInt(),
+        check('items.*.cost').isDecimal(),
+      ],
+      this.validationResult,
+      this.calculateLandedCost,
+      this.handleServiceErrors
+    );
+    router.delete(
+      '/:allocatedLandedCostId',
+      [param('allocatedLandedCostId').exists().isInt()],
+      this.validationResult,
+      this.deleteAllocatedLandedCost,
+      this.handleServiceErrors
+    );
+    router.get(
+      '/transactions',
+      [query('transaction_type').exists().isIn(['Expense', 'Bill'])],
+      this.validationResult,
+      this.getLandedCostTransactions,
+      this.handleServiceErrors
+    );
+    router.get(
+      '/bills/:billId/transactions',
+      [param('billId').exists()],
+      this.validationResult,
+      this.getBillLandedCostTransactions,
+      this.handleServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Retrieve the landed cost transactions of the given query.
+   * @param {Request} req - Request
+   * @param {Response} res - Response.
+   * @param {NextFunction} next - Next function.
+   */
+  private getLandedCostTransactions = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const query = this.matchedQueryData(req);
+
+    try {
+      const transactions =
+        await this.landedCostTranasctions.getLandedCostTransactions(
+          tenantId,
+          query
+        );
+
+      return res.status(200).send({ transactions });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Allocate landed cost.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @returns {Response}
+   */
+  public calculateLandedCost = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { billId: purchaseInvoiceId } = req.params;
+    const landedCostDTO = this.matchedBodyData(req);
+
+    try {
+      const billLandedCost = await this.allocateLandedCost.allocateLandedCost(
+        tenantId,
+        landedCostDTO,
+        purchaseInvoiceId
+      );
+      return res.status(200).send({
+        id: billLandedCost.id,
+        message: 'The items cost are located successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Deletes the allocated landed cost.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @returns {Response}
+   */
+  public deleteAllocatedLandedCost = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ): Promise<Response> => {
+    const { tenantId } = req;
+    const { allocatedLandedCostId } = req.params;
+
+    try {
+      await this.revertAllocatedLandedCost.deleteAllocatedLandedCost(
+        tenantId,
+        allocatedLandedCostId
+      );
+
+      return res.status(200).send({
+        id: allocatedLandedCostId,
+        message: 'The allocated landed cost are delete successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve the list unlocated landed costs.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public listLandedCosts = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const query = this.matchedQueryData(req);
+    const { tenantId } = req;
+
+    try {
+      const transactions =
+        await this.landedCostTranasctions.getLandedCostTransactions(
+          tenantId,
+          query
+        );
+
+      return res.status(200).send({ transactions });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve the bill landed cost transactions.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public getBillLandedCostTransactions = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ): Promise<Response> => {
+    const { tenantId } = req;
+    const { billId } = req.params;
+
+    try {
+      const transactions =
+        await this.billAllocatedCostTransactions.getBillLandedCostTransactions(
+          tenantId,
+          billId
+        );
+
+      return res.status(200).send({
+        billId,
+        transactions: this.transfromToResponse(transactions),
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handle service errors.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @param {Error} error
+   */
+  public handleServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'BILL_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'BILL_NOT_FOUND',
+              message: 'The give bill id not found.',
+              code: 100,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'LANDED_COST_TRANSACTION_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'LANDED_COST_TRANSACTION_NOT_FOUND',
+              message: 'The given landed cost transaction id not found.',
+              code: 200,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'LANDED_COST_ENTRY_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'LANDED_COST_ENTRY_NOT_FOUND',
+              message: 'The given landed cost tranasction entry id not found.',
+              code: 300,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'COST_AMOUNT_BIGGER_THAN_UNALLOCATED_AMOUNT') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'COST_AMOUNT_BIGGER_THAN_UNALLOCATED_AMOUNT',
+              code: 400,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'LANDED_COST_ITEMS_IDS_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'LANDED_COST_ITEMS_IDS_NOT_FOUND',
+              message: 'The given entries ids of purchase invoice not found.',
+              code: 500,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'BILL_LANDED_COST_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'BILL_LANDED_COST_NOT_FOUND',
+              message: 'The given bill located landed cost not found.',
+              code: 600,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'COST_TRASNACTION_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'COST_TRASNACTION_NOT_FOUND', code: 500 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Purchases/VendorCredit.ts b/packages/server/src/api/controllers/Purchases/VendorCredit.ts
new file mode 100644
index 000000000..95405851c
--- /dev/null
+++ b/packages/server/src/api/controllers/Purchases/VendorCredit.ts
@@ -0,0 +1,660 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query } from 'express-validator';
+import { Service, Inject } from 'typedi';
+import {
+  AbilitySubject,
+  IVendorCreditCreateDTO,
+  IVendorCreditEditDTO,
+  VendorCreditAction,
+} from '@/interfaces';
+import BaseController from '@/api/controllers/BaseController';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { ServiceError } from '@/exceptions';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import CreateVendorCredit from '@/services/Purchases/VendorCredits/CreateVendorCredit';
+import EditVendorCredit from '@/services/Purchases/VendorCredits/EditVendorCredit';
+import DeleteVendorCredit from '@/services/Purchases/VendorCredits/DeleteVendorCredit';
+import GetVendorCredit from '@/services/Purchases/VendorCredits/GetVendorCredit';
+import ListVendorCredits from '@/services/Purchases/VendorCredits/ListVendorCredits';
+import CreateRefundVendorCredit from '@/services/Purchases/VendorCredits/RefundVendorCredits/CreateRefundVendorCredit';
+import DeleteRefundVendorCredit from '@/services/Purchases/VendorCredits/RefundVendorCredits/DeleteRefundVendorCredit';
+import ListVendorCreditRefunds from '@/services/Purchases/VendorCredits/RefundVendorCredits/ListRefundVendorCredits';
+import OpenVendorCredit from '@/services/Purchases/VendorCredits/OpenVendorCredit';
+import GetRefundVendorCredit from '@/services/Purchases/VendorCredits/RefundVendorCredits/GetRefundVendorCredit';
+
+@Service()
+export default class VendorCreditController extends BaseController {
+  @Inject()
+  createVendorCreditService: CreateVendorCredit;
+
+  @Inject()
+  editVendorCreditService: EditVendorCredit;
+
+  @Inject()
+  deleteVendorCreditService: DeleteVendorCredit;
+
+  @Inject()
+  getVendorCreditService: GetVendorCredit;
+
+  @Inject()
+  listCreditNotesService: ListVendorCredits;
+
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  @Inject()
+  createRefundCredit: CreateRefundVendorCredit;
+
+  @Inject()
+  deleteRefundCredit: DeleteRefundVendorCredit;
+
+  @Inject()
+  listRefundCredit: ListVendorCreditRefunds;
+
+  @Inject()
+  openVendorCreditService: OpenVendorCredit;
+
+  @Inject()
+  getRefundCredit: GetRefundVendorCredit;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/',
+      CheckPolicies(VendorCreditAction.Create, AbilitySubject.VendorCredit),
+      this.vendorCreditCreateDTOSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.newVendorCredit),
+      this.handleServiceError
+    );
+    router.post(
+      '/:id',
+      CheckPolicies(VendorCreditAction.Edit, AbilitySubject.VendorCredit),
+      this.vendorCreditEditDTOSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.editVendorCredit),
+      this.handleServiceError
+    );
+    router.get(
+      '/:id',
+      CheckPolicies(VendorCreditAction.View, AbilitySubject.VendorCredit),
+      [],
+      this.validationResult,
+      this.asyncMiddleware(this.getVendorCredit),
+      this.handleServiceError
+    );
+    router.get(
+      '/',
+      CheckPolicies(VendorCreditAction.View, AbilitySubject.VendorCredit),
+      this.billsListingValidationSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.getVendorCreditsList),
+      this.handleServiceError,
+      this.dynamicListService.handlerErrorsToResponse
+    );
+    router.delete(
+      '/:id',
+      CheckPolicies(VendorCreditAction.Delete, AbilitySubject.VendorCredit),
+      this.deleteDTOValidationSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.deleteVendorCredit),
+      this.handleServiceError
+    );
+    router.post(
+      '/:id/open',
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.openVendorCreditTransaction),
+      this.handleServiceError
+    );
+    router.get(
+      '/:id/refund',
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.vendorCreditRefundTransactions),
+      this.handleServiceError
+    );
+    router.post(
+      '/:id/refund',
+      CheckPolicies(VendorCreditAction.Refund, AbilitySubject.VendorCredit),
+      this.vendorCreditRefundValidationSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.refundVendorCredit),
+      this.handleServiceError
+    );
+    router.get(
+      '/refunds/:refundId',
+      this.getRefundCreditTransactionSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.getRefundCreditTransaction),
+      this.handleServiceError
+    );
+    router.delete(
+      '/refunds/:refundId',
+      CheckPolicies(VendorCreditAction.Refund, AbilitySubject.VendorCredit),
+      this.deleteRefundVendorCreditSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.deleteRefundVendorCredit),
+      this.handleServiceError
+    );
+    return router;
+  }
+
+  /**
+   * Common validation schema.
+   */
+  get vendorCreditCreateDTOSchema() {
+    return [
+      check('vendor_id').exists().isNumeric().toInt(),
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+
+      check('vendor_credit_number')
+        .optional({ nullable: true })
+        .trim()
+        .escape(),
+      check('reference_no').optional().trim().escape(),
+      check('vendor_credit_date').exists().isISO8601().toDate(),
+      check('note').optional().trim().escape(),
+      check('open').default(false).isBoolean().toBoolean(),
+
+      check('warehouse_id').optional({ nullable: true }).isNumeric().toInt(),
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+
+      check('entries').isArray({ min: 1 }),
+
+      check('entries.*.index').exists().isNumeric().toInt(),
+      check('entries.*.item_id').exists().isNumeric().toInt(),
+      check('entries.*.rate').exists().isNumeric().toFloat(),
+      check('entries.*.quantity').exists().isNumeric().toFloat(),
+      check('entries.*.discount')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toFloat(),
+      check('entries.*.description')
+        .optional({ nullable: true })
+        .trim()
+        .escape(),
+      check('entries.*.warehouse_id')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toInt(),
+    ];
+  }
+
+  /**
+   * Common validation schema.
+   */
+  get vendorCreditEditDTOSchema() {
+    return [
+      param('id').exists().isNumeric().toInt(),
+
+      check('vendor_id').exists().isNumeric().toInt(),
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+
+      check('vendor_credit_number')
+        .optional({ nullable: true })
+        .trim()
+        .escape(),
+      check('reference_no').optional().trim().escape(),
+      check('vendor_credit_date').exists().isISO8601().toDate(),
+      check('note').optional().trim().escape(),
+
+      check('warehouse_id').optional({ nullable: true }).isNumeric().toInt(),
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+
+      check('entries').isArray({ min: 1 }),
+
+      check('entries.*.id').optional().isNumeric().toInt(),
+      check('entries.*.index').exists().isNumeric().toInt(),
+      check('entries.*.item_id').exists().isNumeric().toInt(),
+      check('entries.*.rate').exists().isNumeric().toFloat(),
+      check('entries.*.quantity').exists().isNumeric().toFloat(),
+      check('entries.*.discount')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toFloat(),
+      check('entries.*.description')
+        .optional({ nullable: true })
+        .trim()
+        .escape(),
+      check('entries.*.warehouse_id')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toInt(),
+    ];
+  }
+
+  /**
+   * Bills list validation schema.
+   */
+  get billsListingValidationSchema() {
+    return [
+      query('view_slug').optional().isString().trim(),
+      query('stringified_filter_roles').optional().isJSON(),
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+      query('column_sort_by').optional(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+      query('search_keyword').optional({ nullable: true }).isString().trim(),
+    ];
+  }
+
+  /**
+   *
+   */
+  get deleteDTOValidationSchema() {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  get getRefundCreditTransactionSchema() {
+    return [param('refundId').exists().isNumeric().toInt()];
+  }
+
+  get deleteRefundVendorCreditSchema() {
+    return [];
+  }
+
+  /**
+   * Refund vendor credit validation schema.
+   */
+  get vendorCreditRefundValidationSchema() {
+    return [
+      check('deposit_account_id').exists().isNumeric().toInt(),
+      check('description').exists(),
+
+      check('amount').exists().isNumeric().toFloat(),
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+
+      check('reference_no').optional(),
+      check('date').exists().isISO8601().toDate(),
+
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Creates a new bill and records journal transactions.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {Function} next
+   */
+  private newVendorCredit = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId, user } = req;
+    const vendorCreditCreateDTO: IVendorCreditCreateDTO =
+      this.matchedBodyData(req);
+
+    try {
+      const vendorCredit = await this.createVendorCreditService.newVendorCredit(
+        tenantId,
+        vendorCreditCreateDTO,
+        user
+      );
+
+      return res.status(200).send({
+        id: vendorCredit.id,
+        message: 'The vendor credit has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Edit bill details with associated entries and rewrites journal transactions.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  private editVendorCredit = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { id: billId } = req.params;
+    const { tenantId, user } = req;
+    const vendorCreditEditDTO: IVendorCreditEditDTO = this.matchedBodyData(req);
+
+    try {
+      await this.editVendorCreditService.editVendorCredit(
+        tenantId,
+        billId,
+        vendorCreditEditDTO,
+        user
+      );
+
+      return res.status(200).send({
+        id: billId,
+        message: 'The vendor credit has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve the given bill details with associated item entries.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  private getVendorCredit = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: billId } = req.params;
+
+    try {
+      const data = await this.getVendorCreditService.getVendorCredit(
+        tenantId,
+        billId
+      );
+
+      return res.status(200).send({ data });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Deletes the given bill with associated entries and journal transactions.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @return {Response}
+   */
+  private deleteVendorCredit = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const vendorCreditId = req.params.id;
+    const { tenantId } = req;
+
+    try {
+      await this.deleteVendorCreditService.deleteVendorCredit(
+        tenantId,
+        vendorCreditId
+      );
+
+      return res.status(200).send({
+        id: vendorCreditId,
+        message: 'The given vendor credit has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve vendor credits list.
+   * @param req
+   * @param res
+   * @param next
+   * @returns
+   */
+  private getVendorCreditsList = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const filter = {
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      page: 1,
+      pageSize: 12,
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const { vendorCredits, pagination, filterMeta } =
+        await this.listCreditNotesService.getVendorCredits(tenantId, filter);
+
+      return res.status(200).send({ vendorCredits, pagination, filterMeta });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Refunds vendor credit.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @returns
+   */
+  private refundVendorCredit = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const refundDTO = this.matchedBodyData(req);
+    const { id: vendorCreditId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      const refundVendorCredit = await this.createRefundCredit.createRefund(
+        tenantId,
+        vendorCreditId,
+        refundDTO
+      );
+
+      return res.status(200).send({
+        id: refundVendorCredit.id,
+        message: 'The vendor credit refund has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Deletes refund vendor credit transaction.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private deleteRefundVendorCredit = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { refundId: vendorCreditId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      await this.deleteRefundCredit.deleteRefundVendorCreditRefund(
+        tenantId,
+        vendorCreditId
+      );
+
+      return res.status(200).send({
+        id: vendorCreditId,
+        message: 'The vendor credit refund has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve refunds transactions associated to vendor credit transaction.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private vendorCreditRefundTransactions = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { id: vendorCreditId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      const transactions = await this.listRefundCredit.getVendorCreditRefunds(
+        tenantId,
+        vendorCreditId
+      );
+      return res.status(200).send({ data: transactions });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Open vendor credit transaction.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   */
+  private openVendorCreditTransaction = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { id: vendorCreditId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      await this.openVendorCreditService.openVendorCredit(
+        tenantId,
+        vendorCreditId
+      );
+
+      return res.status(200).send({
+        id: vendorCreditId,
+        message: 'The vendor credit has been opened successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   *
+   * @param req
+   * @param res
+   * @param next
+   * @returns
+   */
+  private getRefundCreditTransaction = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { refundId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      const refundCredit =
+        await this.getRefundCredit.getRefundCreditTransaction(
+          tenantId,
+          refundId
+        );
+      return res.status(200).send({ refundCredit });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handleServiceError(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'ENTRIES_ITEMS_IDS_NOT_EXISTS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ENTRIES_ITEMS_IDS_NOT_EXISTS', code: 100 }],
+        });
+      }
+      if (error.errorType === 'ENTRIES_IDS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ENTRIES_IDS_NOT_FOUND', code: 200 }],
+        });
+      }
+      if (error.errorType === 'contact_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'VENDOR_NOT_FOUND', code: 300 }],
+        });
+      }
+      if (error.errorType === 'ITEMS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ITEMS_NOT_FOUND', code: 400 }],
+        });
+      }
+      if (error.errorType === 'VENDOR_CREDIT_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'VENDOR_CREDIT_NOT_FOUND', code: 500 }],
+        });
+      }
+      if (error.errorType === 'DEPOSIT_ACCOUNT_INVALID_TYPE') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'DEPOSIT_ACCOUNT_INVALID_TYPE', code: 600 }],
+        });
+      }
+      if (error.errorType === 'REFUND_VENDOR_CREDIT_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'REFUND_VENDOR_CREDIT_NOT_FOUND', code: 700 }],
+        });
+      }
+      if (error.errorType === 'VENDOR_CREDIT_HAS_NO_CREDITS_REMAINING') {
+        return res.boom.badRequest(null, {
+          errors: [
+            { type: 'VENDOR_CREDIT_HAS_NO_CREDITS_REMAINING', code: 800 },
+          ],
+        });
+      }
+      if (error.errorType === 'VENDOR_CREDIT_ALREADY_OPENED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'VENDOR_CREDIT_ALREADY_OPENED', code: 900 }],
+        });
+      }
+      if (error.errorType === 'VENDOR_CREDIT_HAS_APPLIED_BILLS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'VENDOR_CREDIT_HAS_APPLIED_BILLS', code: 1000 }],
+        });
+      }
+      if (error.errorType === 'VENDOR_CREDIT_HAS_REFUND_TRANSACTIONS') {
+        return res.boom.badRequest(null, {
+          errors: [
+            { type: 'VENDOR_CREDIT_HAS_REFUND_TRANSACTIONS', code: 1200 },
+          ],
+        });
+      }
+      if (error.errorType === 'TRANSACTIONS_DATE_LOCKED') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'TRANSACTIONS_DATE_LOCKED',
+              code: 4000,
+              data: { ...error.payload },
+            },
+          ],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Purchases/VendorCreditApplyToBills.ts b/packages/server/src/api/controllers/Purchases/VendorCreditApplyToBills.ts
new file mode 100644
index 000000000..b6276f911
--- /dev/null
+++ b/packages/server/src/api/controllers/Purchases/VendorCreditApplyToBills.ts
@@ -0,0 +1,226 @@
+import { Service, Inject } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import { param, check } from 'express-validator';
+import BaseController from '../BaseController';
+import ApplyVendorCreditToBills from '@/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditToBills';
+import DeleteApplyVendorCreditToBill from '@/services/Purchases/VendorCredits/ApplyVendorCreditToBills/DeleteApplyVendorCreditToBill';
+import { ServiceError } from '@/exceptions';
+import GetAppliedBillsToVendorCredit from '@/services/Purchases/VendorCredits/ApplyVendorCreditToBills/GetAppliedBillsToVendorCredit';
+import GetVendorCreditToApplyBills from '@/services/Purchases/VendorCredits/ApplyVendorCreditToBills/GetVendorCreditToApplyBills';
+
+@Service()
+export default class VendorCreditApplyToBills extends BaseController {
+  @Inject()
+  applyVendorCreditToBillsService: ApplyVendorCreditToBills;
+
+  @Inject()
+  deleteAppliedCreditToBillsService: DeleteApplyVendorCreditToBill;
+
+  @Inject()
+  getAppliedBillsToCreditService: GetAppliedBillsToVendorCredit;
+
+  @Inject()
+  getCreditToApplyBillsService: GetVendorCreditToApplyBills;
+
+  /**
+   *
+   * @returns
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/:id/apply-to-bills',
+      [
+        param('id').exists().isNumeric().toInt(),
+
+        check('entries').isArray({ min: 1 }),
+        check('entries.*.bill_id').exists().isInt().toInt(),
+        check('entries.*.amount').exists().isNumeric().toFloat(),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.applyVendorCreditToBills),
+      this.handleServiceErrors
+    );
+    router.delete(
+      '/applied-to-bills/:applyId',
+      [param('applyId').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.deleteApplyCreditToBill),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id/apply-to-bills',
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.getVendorCreditAssociatedBillsToApply),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id/applied-bills',
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.getVendorCreditAppliedBills),
+      this.handleServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Apply vendor credit to the given bills.
+   * @param {Request}
+   * @param {Response}
+   * @param {NextFunction}
+   */
+  public applyVendorCreditToBills = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: vendorCreditId } = req.params;
+    const applyCreditToBillsDTO = this.matchedBodyData(req);
+
+    try {
+      await this.applyVendorCreditToBillsService.applyVendorCreditToBills(
+        tenantId,
+        vendorCreditId,
+        applyCreditToBillsDTO
+      );
+      return res.status(200).send({
+        id: vendorCreditId,
+        message:
+          'The vendor credit has been applied to the given bills successfully',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Deletes vendor credit applied to bill transaction.
+   * @param {Request}
+   * @param {Response}
+   * @param {NextFunction}
+   */
+  public deleteApplyCreditToBill = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { applyId } = req.params;
+
+    try {
+      await this.deleteAppliedCreditToBillsService.deleteApplyVendorCreditToBills(
+        tenantId,
+        applyId
+      );
+      return res.status(200).send({
+        id: applyId,
+        message:
+          'The applied vendor credit to bill has been deleted successfully',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   *
+   */
+  public getVendorCreditAssociatedBillsToApply = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: vendorCreditId } = req.params;
+
+    try {
+      const bills =
+        await this.getCreditToApplyBillsService.getCreditToApplyBills(
+          tenantId,
+          vendorCreditId
+        );
+      return res.status(200).send({ data: bills });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   *
+   */
+  public getVendorCreditAppliedBills = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: vendorCreditId } = req.params;
+
+    try {
+      const appliedBills =
+        await this.getAppliedBillsToCreditService.getAppliedBills(
+          tenantId,
+          vendorCreditId
+        );
+      return res.status(200).send({ data: appliedBills });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param next
+   */
+  handleServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'VENDOR_CREDIT_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'VENDOR_CREDIT_NOT_FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'BILL_ENTRIES_IDS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'BILL_ENTRIES_IDS_NOT_FOUND', code: 200 }],
+        });
+      }
+      if (error.errorType === 'BILLS_NOT_OPENED_YET') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'BILLS_NOT_OPENED_YET', code: 300 }],
+        });
+      }
+      if (error.errorType === 'BILLS_HAS_NO_REMAINING_AMOUNT') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'BILLS_HAS_NO_REMAINING_AMOUNT', code: 400 }],
+        });
+      }
+      if (error.errorType === 'VENDOR_CREDIT_HAS_NO_REMAINING_AMOUNT') {
+        return res.boom.badRequest(null, {
+          errors: [
+            { type: 'VENDOR_CREDIT_HAS_NO_REMAINING_AMOUNT', code: 500 },
+          ],
+        });
+      }
+      if (error.errorType === 'VENDOR_CREDIT_APPLY_TO_BILLS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [
+            { type: 'VENDOR_CREDIT_APPLY_TO_BILLS_NOT_FOUND', code: 600 },
+          ],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Purchases/index.ts b/packages/server/src/api/controllers/Purchases/index.ts
new file mode 100644
index 000000000..3cb7a278f
--- /dev/null
+++ b/packages/server/src/api/controllers/Purchases/index.ts
@@ -0,0 +1,25 @@
+import { Router } from 'express';
+import { Container, Service } from 'typedi';
+import Bills from '@/api/controllers/Purchases/Bills';
+import BillPayments from '@/api/controllers/Purchases/BillsPayments';
+import BillAllocateLandedCost from './LandedCost';
+import VendorCredit from './VendorCredit';
+import VendorCreditApplyToBills from './VendorCreditApplyToBills';
+
+@Service()
+export default class PurchasesController {
+  router() {
+    const router = Router();
+
+    router.use('/bills', Container.get(Bills).router());
+    router.use('/bill_payments', Container.get(BillPayments).router());
+    router.use('/landed-cost', Container.get(BillAllocateLandedCost).router());
+    router.use('/vendor-credit', Container.get(VendorCredit).router());
+    router.use(
+      '/vendor-credit',
+      Container.get(VendorCreditApplyToBills).router()
+    );
+
+    return router;
+  }
+}
diff --git a/packages/server/src/api/controllers/Resources.ts b/packages/server/src/api/controllers/Resources.ts
new file mode 100644
index 000000000..9013a9a45
--- /dev/null
+++ b/packages/server/src/api/controllers/Resources.ts
@@ -0,0 +1,82 @@
+import { Service, Inject } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import { param } from 'express-validator';
+import BaseController from './BaseController';
+import { ServiceError } from '@/exceptions';
+import ResourceService from '@/services/Resource/ResourceService';
+
+@Service()
+export default class ResourceController extends BaseController {
+  @Inject()
+  resourcesService: ResourceService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/:resource_model/meta',
+      [
+        param('resource_model').exists().trim().escape()
+      ],
+      this.asyncMiddleware(this.resourceMeta.bind(this)),
+      this.handleServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Retrieve resource model meta.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   * @returns {Response}
+   */
+  public resourceMeta = (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ): Response => {
+    const { tenantId } = req;
+    const { resource_model: resourceModel } = req.params;
+
+    try {
+      const resourceMeta = this.resourcesService.getResourceMeta(
+        tenantId,
+        resourceModel
+      );
+      return res.status(200).send({
+        resource_meta: this.transfromToResponse(
+          resourceMeta,
+        ),
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handleServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'RESOURCE_MODEL_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'RESOURCE.MODEL.NOT.FOUND', code: 100 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Roles/PermissionsSchema.ts b/packages/server/src/api/controllers/Roles/PermissionsSchema.ts
new file mode 100644
index 000000000..b09df1555
--- /dev/null
+++ b/packages/server/src/api/controllers/Roles/PermissionsSchema.ts
@@ -0,0 +1,41 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import RolePermissionsSchema from '@/services/Roles/RolePermissionsSchema';
+import { Service, Inject } from 'typedi';
+import BaseController from '../BaseController';
+
+@Service()
+export default class RolePermissionsSchemaController extends BaseController {
+  @Inject()
+  rolePermissionSchema: RolePermissionsSchema;
+
+  router() {
+    const router = Router();
+
+    router.get('/permissions/schema', this.getPermissionsSchema);
+
+    return router;
+  }
+
+  /**
+   * Retrieve the role permissions schema.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private getPermissionsSchema = (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+
+    try {
+      const permissionsSchema =
+        this.rolePermissionSchema.getRolePermissionsSchema(tenantId);
+
+      return res.status(200).send({ data: permissionsSchema });
+    } catch (error) {
+      next(error);
+    }
+  };
+}
diff --git a/packages/server/src/api/controllers/Roles/Roles.ts b/packages/server/src/api/controllers/Roles/Roles.ts
new file mode 100644
index 000000000..297b10902
--- /dev/null
+++ b/packages/server/src/api/controllers/Roles/Roles.ts
@@ -0,0 +1,254 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query, ValidationChain } from 'express-validator';
+import BaseController from '../BaseController';
+import { Service, Inject } from 'typedi';
+import { ServiceError } from '@/exceptions';
+import RolesService from '@/services/Roles/RolesService';
+
+@Service()
+export default class RolesController extends BaseController {
+  @Inject()
+  rolesService: RolesService;
+
+  router() {
+    const router = Router();
+
+    router.post(
+      '/',
+      [
+        check('role_name').exists().trim(),
+        check('role_description').optional(),
+        check('permissions').exists().isArray({ min: 1 }),
+        check('permissions.*.subject').exists().trim(),
+        check('permissions.*.ability').exists().trim(),
+        check('permissions.*.value').exists().isBoolean().toBoolean(),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.createRole),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id',
+      [
+        check('role_name').exists().trim(),
+        check('role_description').optional(),
+        check('permissions').isArray({ min: 1 }),
+        check('permissions.*.permission_id'),
+        check('permissions.*.subject').exists().trim(),
+        check('permissions.*.ability').exists().trim(),
+        check('permissions.*.value').exists().isBoolean().toBoolean(),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.editRole),
+      this.handleServiceErrors
+    );
+    router.delete(
+      '/:id',
+      [param('id').exists().isInt().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.deleteRole),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id',
+      [param('id').exists().isInt().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.getRole),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/',
+      [],
+      this.validationResult,
+      this.asyncMiddleware(this.listRoles),
+      this.handleServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Creates a new role on the authenticated tenant.
+   * @param req
+   * @param res
+   * @param next
+   */
+  private createRole = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const newRoleDTO = this.matchedBodyData(req);
+
+    try {
+      const role = await this.rolesService.createRole(tenantId, newRoleDTO);
+
+      return res.status(200).send({
+        data: { roleId: role.id },
+        message: 'The role has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Deletes the given role from the storage.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  private deleteRole = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: roleId } = req.params;
+
+    try {
+      const role = await this.rolesService.deleteRole(tenantId, roleId);
+
+      return res.status(200).send({
+        data: { roleId },
+        message: 'The given role has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Edits the given role details on the storage.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  private editRole = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: roleId } = req.params;
+    const editRoleDTO = this.matchedBodyData(req);
+
+    try {
+      const role = await this.rolesService.editRole(tenantId, roleId, editRoleDTO);
+
+      return res.status(200).send({
+        data: { roleId },
+        message: 'The given role hsa been updated successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve the roles list.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  private listRoles = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+
+    try {
+      const roles = await this.rolesService.listRoles(tenantId);
+
+      return res.status(200).send({
+        roles,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve the specific role details.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  private getRole = async (req: Request, res: Response, next: NextFunction) => {
+    const { tenantId } = req;
+    const { id: roleId } = req.params;
+
+    try {
+      const role = await this.rolesService.getRole(tenantId, roleId);
+
+      return res.status(200).send({
+        role,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handles the service errors.
+   * @param error
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  private handleServiceErrors = (
+    error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'ROLE_PREFINED') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'ROLE_PREFINED',
+              message: 'Role is predefined, you cannot modify predefined roles',
+              code: 100,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'ROLE_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'ROLE_NOT_FOUND',
+              message: 'Role is not found',
+              code: 200,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'INVALIDATE_PERMISSIONS') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'INVALIDATE_PERMISSIONS',
+              message: 'The submit role has invalid permissions.',
+              code: 300,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'CANNT_DELETE_ROLE_ASSOCIATED_TO_USERS') {
+        return res.status(400).send({
+          errors: [
+            {
+              type: 'CANNOT_DELETE_ROLE_ASSOCIATED_TO_USERS',
+              message: 'Cannot delete role associated to users.',
+              code: 400
+            },
+          ],
+        });
+      }
+      next(error);
+    }
+  };
+}
diff --git a/packages/server/src/api/controllers/Roles/index.ts b/packages/server/src/api/controllers/Roles/index.ts
new file mode 100644
index 000000000..f13918979
--- /dev/null
+++ b/packages/server/src/api/controllers/Roles/index.ts
@@ -0,0 +1,22 @@
+import { Router, Request, Response, NextFunction } from 'express';
+
+import BaseController from '../BaseController';
+import { Container, Service, Inject } from 'typedi';
+
+import RolesService from '@/services/Roles/RolesService';
+import PermissionsSchema from './PermissionsSchema';
+import RolesController from './Roles';
+@Service()
+export default class RolesBaseController extends BaseController {
+  @Inject()
+  rolesService: RolesService;
+
+  router() {
+    const router = Router();
+
+    router.use('/', Container.get(PermissionsSchema).router());
+    router.use('/', Container.get(RolesController).router());
+
+    return router;
+  }
+}
diff --git a/packages/server/src/api/controllers/Sales/CreditNoteApplyToBills.ts b/packages/server/src/api/controllers/Sales/CreditNoteApplyToBills.ts
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/server/src/api/controllers/Sales/CreditNotes.ts b/packages/server/src/api/controllers/Sales/CreditNotes.ts
new file mode 100644
index 000000000..29bcae2fb
--- /dev/null
+++ b/packages/server/src/api/controllers/Sales/CreditNotes.ts
@@ -0,0 +1,846 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query, ValidationChain } from 'express-validator';
+import { Inject, Service } from 'typedi';
+import {
+  AbilitySubject,
+  CreditNoteAction,
+  ICreditNoteEditDTO,
+  ICreditNoteNewDTO,
+} from '@/interfaces';
+import BaseController from '@/api/controllers/BaseController';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { ServiceError } from '@/exceptions';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import CreateCreditNote from '@/services/CreditNotes/CreateCreditNote';
+import EditCreditNote from '@/services/CreditNotes/EditCreditNote';
+import DeleteCreditNote from '@/services/CreditNotes/DeleteCreditNote';
+import GetCreditNote from '@/services/CreditNotes/GetCreditNote';
+import ListCreditNotes from '@/services/CreditNotes/ListCreditNotes';
+import DeleteRefundCreditNote from '@/services/CreditNotes/DeleteRefundCreditNote';
+import ListCreditNoteRefunds from '@/services/CreditNotes/ListCreditNoteRefunds';
+import OpenCreditNote from '@/services/CreditNotes/OpenCreditNote';
+import CreateRefundCreditNote from '@/services/CreditNotes/CreateRefundCreditNote';
+import CreditNoteApplyToInvoices from '@/services/CreditNotes/CreditNoteApplyToInvoices';
+import DeletreCreditNoteApplyToInvoices from '@/services/CreditNotes/DeleteCreditNoteApplyToInvoices';
+import GetCreditNoteAssociatedInvoicesToApply from '@/services/CreditNotes/GetCreditNoteAssociatedInvoicesToApply';
+import GetCreditNoteAssociatedAppliedInvoices from '@/services/CreditNotes/GetCreditNoteAssociatedAppliedInvoices';
+import GetRefundCreditTransaction from '@/services/CreditNotes/GetRefundCreditNoteTransaction';
+import GetCreditNotePdf from '../../../services/CreditNotes/GetCreditNotePdf';
+/**
+ * Credit notes controller.
+ * @service
+ */
+@Service()
+export default class PaymentReceivesController extends BaseController {
+  @Inject()
+  createCreditNoteService: CreateCreditNote;
+
+  @Inject()
+  editCreditNoteService: EditCreditNote;
+
+  @Inject()
+  deleteCreditNoteService: DeleteCreditNote;
+
+  @Inject()
+  getCreditNoteService: GetCreditNote;
+
+  @Inject()
+  listCreditNotesService: ListCreditNotes;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  @Inject()
+  createCreditNoteRefund: CreateRefundCreditNote;
+
+  @Inject()
+  deleteRefundCredit: DeleteRefundCreditNote;
+
+  @Inject()
+  listCreditRefunds: ListCreditNoteRefunds;
+
+  @Inject()
+  openCreditNote: OpenCreditNote;
+
+  @Inject()
+  applyCreditNoteToInvoicesService: CreditNoteApplyToInvoices;
+
+  @Inject()
+  deleteApplyCreditToInvoicesService: DeletreCreditNoteApplyToInvoices;
+
+  @Inject()
+  getCreditAssociatedInvoicesToApply: GetCreditNoteAssociatedInvoicesToApply;
+
+  @Inject()
+  getCreditAssociatedAppliedInvoices: GetCreditNoteAssociatedAppliedInvoices;
+
+  @Inject()
+  getRefundCreditService: GetRefundCreditTransaction;
+
+  @Inject()
+  creditNotePdf: GetCreditNotePdf;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    // Edit credit note.
+    router.post(
+      '/:id',
+      CheckPolicies(CreditNoteAction.Edit, AbilitySubject.CreditNote),
+      this.editCreditNoteDTOShema,
+      this.validationResult,
+      this.asyncMiddleware(this.editCreditNote),
+      this.handleServiceErrors
+    );
+    // New credit note.
+    router.post(
+      '/',
+      CheckPolicies(CreditNoteAction.Create, AbilitySubject.CreditNote),
+      [...this.newCreditNoteDTOSchema],
+      this.validationResult,
+      this.asyncMiddleware(this.newCreditNote),
+      this.handleServiceErrors
+    );
+    // Get specific credit note.
+    router.get(
+      '/:id',
+      CheckPolicies(CreditNoteAction.View, AbilitySubject.CreditNote),
+      this.getCreditNoteSchema,
+      this.asyncMiddleware(this.getCreditNote),
+      this.handleServiceErrors
+    );
+    // Get credit note list.
+    router.get(
+      '/',
+      CheckPolicies(CreditNoteAction.View, AbilitySubject.CreditNote),
+      this.validatePaymentReceiveList,
+      this.validationResult,
+      this.asyncMiddleware(this.getCreditNotesList),
+      this.handleServiceErrors,
+      this.dynamicListService.handlerErrorsToResponse
+    );
+    // Get specific credit note.
+    router.delete(
+      '/:id',
+      CheckPolicies(CreditNoteAction.Delete, AbilitySubject.CreditNote),
+      this.deleteCreditNoteSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.deleteCreditNote),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id/open',
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.openCreditNoteTransaction),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id/refund',
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.creditNoteRefundTransactions),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id/refund',
+      CheckPolicies(CreditNoteAction.Refund, AbilitySubject.CreditNote),
+      this.creditNoteRefundSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.refundCreditNote),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id/apply-to-invoices',
+      this.creditNoteApplyToInvoices,
+      this.validationResult,
+      this.asyncMiddleware(this.applyCreditNoteToInvoices),
+      this.handleServiceErrors
+    );
+    router.delete(
+      '/refunds/:refundId',
+      this.deleteRefundCreditSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.deleteCreditNoteRefund),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/refunds/:refundId',
+      this.getRefundCreditTransactionSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.getRefundCreditTransaction),
+      this.handleServiceErrors
+    );
+    router.delete(
+      '/applied-to-invoices/:applyId',
+      [param('applyId').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.deleteApplyCreditToInvoices),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id/apply-to-invoices',
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.getCreditNoteInvoicesToApply),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id/applied-invoices',
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.getCreditNoteAppliedInvoices),
+      this.handleServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Payment receive schema.
+   * @return {Array}
+   */
+  get creditNoteDTOSchema(): ValidationChain[] {
+    return [
+      check('customer_id').exists().isNumeric().toInt(),
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+
+      check('credit_note_date').exists().isISO8601().toDate(),
+      check('reference_no').optional(),
+      check('credit_note_number').optional({ nullable: true }).trim().escape(),
+      check('note').optional().trim().escape(),
+      check('terms_conditions').optional().trim().escape(),
+      check('open').default(false).isBoolean().toBoolean(),
+
+      check('warehouse_id').optional({ nullable: true }).isNumeric().toInt(),
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+
+      check('entries').isArray({ min: 1 }),
+
+      check('entries.*.index').exists().isNumeric().toInt(),
+      check('entries.*.item_id').exists().isNumeric().toInt(),
+      check('entries.*.rate').exists().isNumeric().toFloat(),
+      check('entries.*.quantity').exists().isNumeric().toFloat(),
+      check('entries.*.discount')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toFloat(),
+      check('entries.*.description')
+        .optional({ nullable: true })
+        .trim()
+        .escape(),
+      check('entries.*.warehouse_id')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toInt(),
+    ];
+  }
+
+  /**
+   * Payment receive list validation schema.
+   */
+  get validatePaymentReceiveList(): ValidationChain[] {
+    return [
+      query('stringified_filter_roles').optional().isJSON(),
+
+      query('view_slug').optional({ nullable: true }).isString().trim(),
+
+      query('column_sort_by').optional(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+
+      query('search_keyword').optional({ nullable: true }).isString().trim(),
+    ];
+  }
+
+  /**
+   * Validate payment receive parameters.
+   */
+  get deleteCreditNoteSchema() {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  /**
+   * New credit note DTO validation schema.
+   * @return {Array}
+   */
+  get newCreditNoteDTOSchema() {
+    return [...this.creditNoteDTOSchema];
+  }
+
+  /**
+   * Geet credit note validation schema.
+   */
+  get getCreditNoteSchema() {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  /**
+   * Edit credit note DTO validation schema.
+   */
+  get editCreditNoteDTOShema() {
+    return [
+      param('id').exists().isNumeric().toInt(),
+      ...this.creditNoteDTOSchema,
+    ];
+  }
+
+  get creditNoteRefundSchema() {
+    return [
+      check('from_account_id').exists().isNumeric().toInt(),
+      check('description').optional(),
+      
+      check('amount').exists().isNumeric().toFloat(),
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+
+      check('reference_no').optional(),
+      check('date').exists().isISO8601().toDate(),
+
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+    ];
+  }
+
+  get creditNoteApplyToInvoices() {
+    return [
+      check('entries').isArray({ min: 1 }),
+      check('entries.*.invoice_id').exists().isInt().toInt(),
+      check('entries.*.amount').exists().isNumeric().toFloat(),
+    ];
+  }
+
+  get deleteRefundCreditSchema() {
+    return [check('refundId').exists().isNumeric().toInt()];
+  }
+
+  get getRefundCreditTransactionSchema() {
+    return [check('refundId').exists().isNumeric().toInt()];
+  }
+
+  /**
+   * Records payment receive to the given customer with associated invoices.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  private newCreditNote = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId, user } = req;
+    const creditNoteDTO: ICreditNoteNewDTO = this.matchedBodyData(req);
+
+    try {
+      const creditNote = await this.createCreditNoteService.newCreditNote(
+        tenantId,
+        creditNoteDTO,
+        user
+      );
+      return res.status(200).send({
+        id: creditNote.id,
+        message: 'The credit note has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Edit the given payment receive.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  private editCreditNote = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: creditNoteId } = req.params;
+
+    const creditNoteDTO: ICreditNoteEditDTO = this.matchedBodyData(req);
+
+    try {
+      await this.editCreditNoteService.editCreditNote(
+        tenantId,
+        creditNoteId,
+        creditNoteDTO
+      );
+      return res.status(200).send({
+        id: creditNoteId,
+        message: 'The credit note has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Delets the given payment receive id.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  private deleteCreditNote = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId, user } = req;
+    const { id: creditNoteId } = req.params;
+
+    try {
+      await this.deleteCreditNoteService.deleteCreditNote(
+        tenantId,
+        creditNoteId
+      );
+      return res.status(200).send({
+        id: creditNoteId,
+        message: 'The credit note has been deleted successfully',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve payment receive list with pagination metadata.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  private getCreditNotesList = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const filter = {
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      page: 1,
+      pageSize: 12,
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const { creditNotes, pagination, filterMeta } =
+        await this.listCreditNotesService.getCreditNotesList(tenantId, filter);
+
+      return res.status(200).send({ creditNotes, pagination, filterMeta });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve the payment receive details.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private getCreditNote = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: creditNoteId } = req.params;
+
+    try {
+      const creditNote = await this.getCreditNoteService.getCreditNote(
+        tenantId,
+        creditNoteId
+      );
+      const ACCEPT_TYPE = {
+        APPLICATION_PDF: 'application/pdf',
+        APPLICATION_JSON: 'application/json',
+      };
+      // Response formatter.
+      res.format({
+        // Json content type.
+        [ACCEPT_TYPE.APPLICATION_JSON]: () => {
+          return res
+            .status(200)
+            .send({ credit_note: this.transfromToResponse(creditNote) });
+        },
+        // Pdf content type.
+        [ACCEPT_TYPE.APPLICATION_PDF]: async () => {
+          const pdfContent = await this.creditNotePdf.getCreditNotePdf(
+            tenantId,
+            creditNote
+          );
+          res.set({
+            'Content-Type': 'application/pdf',
+            'Content-Length': pdfContent.length,
+          });
+          res.send(pdfContent);
+        },
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Refunds the credit note.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @returns
+   */
+  private refundCreditNote = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: creditNoteId } = req.params;
+    const creditNoteRefundDTO = this.matchedBodyData(req);
+
+    try {
+      const creditNoteRefund =
+        await this.createCreditNoteRefund.createCreditNoteRefund(
+          tenantId,
+          creditNoteId,
+          creditNoteRefundDTO
+        );
+      return res.status(200).send({
+        id: creditNoteRefund.id,
+        message:
+          'The customer credit note refund has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Apply credit note to the given invoices.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private applyCreditNoteToInvoices = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: creditNoteId } = req.params;
+    const applyCreditNoteToInvoicesDTO = this.matchedBodyData(req);
+
+    try {
+      await this.applyCreditNoteToInvoicesService.applyCreditNoteToInvoices(
+        tenantId,
+        creditNoteId,
+        applyCreditNoteToInvoicesDTO
+      );
+      return res.status(200).send({
+        id: creditNoteId,
+        message:
+          'The credit note has been applied the given invoices successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Deletes the credit note refund transaction.
+   * @param req
+   * @param res
+   * @param next
+   * @returns
+   */
+  private deleteCreditNoteRefund = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { refundId: creditRefundId } = req.params;
+
+    try {
+      await this.deleteRefundCredit.deleteCreditNoteRefund(
+        tenantId,
+        creditRefundId
+      );
+      return res.status(200).send({
+        id: creditRefundId,
+        message: 'The credit note refund has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve get refund credit note transaction.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @returns {Promise<Response>}
+   */
+  private getRefundCreditTransaction = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { refundId: creditRefundId } = req.params;
+
+    try {
+      const refundCredit =
+        await this.getRefundCreditService.getRefundCreditTransaction(
+          tenantId,
+          creditRefundId
+        );
+      return res.status(200).send({ refundCredit });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve refund transactions associated to the given credit note.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  private creditNoteRefundTransactions = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { id: creditNoteId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      const transactions = await this.listCreditRefunds.getCreditNoteRefunds(
+        tenantId,
+        creditNoteId
+      );
+      return res.status(200).send({ data: transactions });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   *
+   * @param req
+   * @param res
+   * @param next
+   * @returns
+   */
+  private openCreditNoteTransaction = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { id: creditNoteId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      const creditNote = await this.openCreditNote.openCreditNote(
+        tenantId,
+        creditNoteId
+      );
+      return res.status(200).send({
+        message: 'The credit note has been opened successfully',
+        id: creditNote.id,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   *
+   * @param req
+   * @param res
+   * @param next
+   * @returns
+   */
+  private deleteApplyCreditToInvoices = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { applyId: creditAppliedToInvoicesId } = req.params;
+
+    try {
+      await this.deleteApplyCreditToInvoicesService.deleteApplyCreditNoteToInvoices(
+        tenantId,
+        creditAppliedToInvoicesId
+      );
+      return res.status(200).send({
+        id: creditAppliedToInvoicesId,
+        message:
+          'The applied credit to invoices has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve the credit note associated invoices to apply.
+   * @param req
+   * @param res
+   * @param next
+   */
+  private getCreditNoteInvoicesToApply = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: creditNoteId } = req.params;
+
+    try {
+      const saleInvoices =
+        await this.getCreditAssociatedInvoicesToApply.getCreditAssociatedInvoicesToApply(
+          tenantId,
+          creditNoteId
+        );
+      return res.status(200).send({ data: saleInvoices });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   *
+   * @param req
+   * @param res
+   * @param next
+   * @returns
+   */
+  private getCreditNoteAppliedInvoices = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: creditNoteId } = req.params;
+
+    try {
+      const appliedInvoices =
+        await this.getCreditAssociatedAppliedInvoices.getCreditAssociatedAppliedInvoices(
+          tenantId,
+          creditNoteId
+        );
+      return res.status(200).send({ data: appliedInvoices });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param next
+   */
+  handleServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'ENTRIES_ITEMS_IDS_NOT_EXISTS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ENTRIES_ITEMS_IDS_NOT_EXISTS', code: 100 }],
+        });
+      }
+      if (error.errorType === 'ENTRIES_IDS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ENTRIES_IDS_NOT_FOUND', code: 200 }],
+        });
+      }
+      if (error.errorType === 'contact_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER_NOT_FOUND', code: 300 }],
+        });
+      }
+      if (error.errorType === 'ITEMS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ITEMS_NOT_FOUND', code: 400 }],
+        });
+      }
+      if (error.errorType === 'CREDIT_NOTE_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CREDIT_NOTE_NOT_FOUND', code: 500 }],
+        });
+      }
+      if (error.errorType === 'CREDIT_NOTE_ALREADY_OPENED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CREDIT_NOTE_ALREADY_OPENED', code: 600 }],
+        });
+      }
+      if (
+        error.errorType === 'INVOICES_IDS_NOT_FOUND' ||
+        error.errorType === 'INVOICES_NOT_DELIVERED_YET'
+      ) {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'APPLIED_INVOICES_IDS_NOT_FOUND', code: 700 }],
+        });
+      }
+      if (error.errorType === 'CREDIT_NOTE_HAS_NO_REMAINING_AMOUNT') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CREDIT_NOTE_HAS_NO_REMAINING_AMOUNT', code: 800 }],
+        });
+      }
+      if (error.errorType === 'CREDIT_NOTE_APPLY_TO_INVOICES_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [
+            { type: 'CREDIT_NOTE_APPLY_TO_INVOICES_NOT_FOUND', code: 900 },
+          ],
+        });
+      }
+      if (error.errorType === 'INVOICES_HAS_NO_REMAINING_AMOUNT') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'INVOICES_HAS_NO_REMAINING_AMOUNT', code: 1000 }],
+        });
+      }
+      if (error.errorType === 'CREDIT_NOTE_HAS_REFUNDS_TRANSACTIONS') {
+        return res.boom.badRequest(null, {
+          errors: [
+            { type: 'CREDIT_NOTE_HAS_REFUNDS_TRANSACTIONS', code: 1100 },
+          ],
+        });
+      }
+      if (error.errorType === 'CREDIT_NOTE_HAS_APPLIED_INVOICES') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CREDIT_NOTE_HAS_APPLIED_INVOICES', code: 1200 }],
+        });
+      }
+      if (error.errorType === 'REFUND_CREDIT_NOTE_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'REFUND_CREDIT_NOTE_NOT_FOUND', code: 1300 }],
+        });
+      }
+      if (error.errorType === 'TRANSACTIONS_DATE_LOCKED') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'TRANSACTIONS_DATE_LOCKED',
+              code: 4900,
+              data: { ...error.payload },
+            },
+          ],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Sales/PaymentReceives.ts b/packages/server/src/api/controllers/Sales/PaymentReceives.ts
new file mode 100644
index 000000000..3af447e9c
--- /dev/null
+++ b/packages/server/src/api/controllers/Sales/PaymentReceives.ts
@@ -0,0 +1,616 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query, ValidationChain } from 'express-validator';
+import { Inject, Service } from 'typedi';
+import {
+  AbilitySubject,
+  IPaymentReceiveDTO,
+  PaymentReceiveAction,
+  SaleInvoiceAction,
+} from '@/interfaces';
+import BaseController from '@/api/controllers/BaseController';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import PaymentReceiveService from '@/services/Sales/PaymentReceives/PaymentsReceives';
+import PaymentReceivesPages from '@/services/Sales/PaymentReceives/PaymentReceivesPages';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { ServiceError } from '@/exceptions';
+import PaymentReceiveNotifyBySms from '@/services/Sales/PaymentReceives/PaymentReceiveSmsNotify';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import GetPaymentReceivePdf from '@/services/Sales/PaymentReceives/GetPaymentReeceivePdf';
+
+/**
+ * Payments receives controller.
+ * @service
+ */
+@Service()
+export default class PaymentReceivesController extends BaseController {
+  @Inject()
+  paymentReceiveService: PaymentReceiveService;
+
+  @Inject()
+  PaymentReceivesPages: PaymentReceivesPages;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  @Inject()
+  paymentReceiveSmsNotify: PaymentReceiveNotifyBySms;
+
+  @Inject()
+  paymentReceivePdf: GetPaymentReceivePdf;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/:id',
+      CheckPolicies(PaymentReceiveAction.Edit, AbilitySubject.PaymentReceive),
+      this.editPaymentReceiveValidation,
+      this.validationResult,
+      asyncMiddleware(this.editPaymentReceive.bind(this)),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id/notify-by-sms',
+      CheckPolicies(
+        PaymentReceiveAction.NotifyBySms,
+        AbilitySubject.PaymentReceive
+      ),
+      [param('id').exists().isInt().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.paymentReceiveNotifyBySms),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id/sms-details',
+      CheckPolicies(
+        PaymentReceiveAction.NotifyBySms,
+        AbilitySubject.PaymentReceive
+      ),
+      [param('id').exists().isInt().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.paymentReceiveSmsDetails),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/',
+      CheckPolicies(PaymentReceiveAction.Create, AbilitySubject.PaymentReceive),
+      [...this.newPaymentReceiveValidation],
+      this.validationResult,
+      asyncMiddleware(this.newPaymentReceive.bind(this)),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id/edit-page',
+      CheckPolicies(PaymentReceiveAction.Edit, AbilitySubject.PaymentReceive),
+      this.paymentReceiveValidation,
+      this.validationResult,
+      asyncMiddleware(this.getPaymentReceiveEditPage.bind(this)),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/new-page/entries',
+      CheckPolicies(PaymentReceiveAction.View, AbilitySubject.PaymentReceive),
+      [query('customer_id').exists().isNumeric().toInt()],
+      this.validationResult,
+      asyncMiddleware(this.getPaymentReceiveNewPageEntries.bind(this)),
+      this.getPaymentReceiveNewPageEntries.bind(this)
+    );
+    router.get(
+      '/:id/invoices',
+      CheckPolicies(PaymentReceiveAction.View, AbilitySubject.PaymentReceive),
+      this.paymentReceiveValidation,
+      this.validationResult,
+      asyncMiddleware(this.getPaymentReceiveInvoices.bind(this)),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id',
+      CheckPolicies(PaymentReceiveAction.View, AbilitySubject.PaymentReceive),
+      this.paymentReceiveValidation,
+      this.asyncMiddleware(this.getPaymentReceive.bind(this)),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/',
+      CheckPolicies(PaymentReceiveAction.View, AbilitySubject.PaymentReceive),
+      this.validatePaymentReceiveList,
+      this.validationResult,
+      asyncMiddleware(this.getPaymentReceiveList.bind(this)),
+      this.handleServiceErrors,
+      this.dynamicListService.handlerErrorsToResponse
+    );
+    router.delete(
+      '/:id',
+      CheckPolicies(PaymentReceiveAction.Delete, AbilitySubject.PaymentReceive),
+      this.paymentReceiveValidation,
+      this.validationResult,
+      asyncMiddleware(this.deletePaymentReceive.bind(this)),
+      this.handleServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Payment receive schema.
+   * @return {Array}
+   */
+  get paymentReceiveSchema(): ValidationChain[] {
+    return [
+      check('customer_id').exists().isNumeric().toInt(),
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+
+      check('payment_date').exists(),
+      check('reference_no').optional(),
+      check('deposit_account_id').exists().isNumeric().toInt(),
+      check('payment_receive_no').optional({ nullable: true }).trim().escape(),
+      check('statement').optional().trim().escape(),
+
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+
+      check('entries').isArray({ min: 1 }),
+
+      check('entries.*.id').optional({ nullable: true }).isNumeric().toInt(),
+      check('entries.*.index').optional().isNumeric().toInt(),
+      check('entries.*.invoice_id').exists().isNumeric().toInt(),
+      check('entries.*.payment_amount').exists().isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Payment receive list validation schema.
+   */
+  get validatePaymentReceiveList(): ValidationChain[] {
+    return [
+      query('stringified_filter_roles').optional().isJSON(),
+
+      query('view_slug').optional({ nullable: true }).isString().trim(),
+
+      query('column_sort_by').optional(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+
+      query('search_keyword').optional({ nullable: true }).isString().trim(),
+    ];
+  }
+
+  /**
+   * Validate payment receive parameters.
+   */
+  get paymentReceiveValidation() {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  /**
+   * New payment receive validation schema.
+   * @return {Array}
+   */
+  get newPaymentReceiveValidation() {
+    return [...this.paymentReceiveSchema];
+  }
+
+  /**
+   * Edit payment receive validation.
+   */
+  get editPaymentReceiveValidation() {
+    return [
+      param('id').exists().isNumeric().toInt(),
+      ...this.paymentReceiveSchema,
+    ];
+  }
+
+  /**
+   * Records payment receive to the given customer with associated invoices.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async newPaymentReceive(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const paymentReceive: IPaymentReceiveDTO = this.matchedBodyData(req);
+
+    try {
+      const storedPaymentReceive =
+        await this.paymentReceiveService.createPaymentReceive(
+          tenantId,
+          paymentReceive,
+          user
+        );
+      return res.status(200).send({
+        id: storedPaymentReceive.id,
+        message: 'The payment receive has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Edit the given payment receive.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async editPaymentReceive(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const { id: paymentReceiveId } = req.params;
+
+    const paymentReceive: IPaymentReceiveDTO = this.matchedBodyData(req);
+
+    try {
+      await this.paymentReceiveService.editPaymentReceive(
+        tenantId,
+        paymentReceiveId,
+        paymentReceive,
+        user
+      );
+      return res.status(200).send({
+        id: paymentReceiveId,
+        message: 'The payment receive has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Delets the given payment receive id.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async deletePaymentReceive(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const { id: paymentReceiveId } = req.params;
+
+    try {
+      await this.paymentReceiveService.deletePaymentReceive(
+        tenantId,
+        paymentReceiveId,
+        user
+      );
+
+      return res.status(200).send({
+        id: paymentReceiveId,
+        message: 'The payment receive has been deleted successfully',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve sale invoices that associated with the given payment receive.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async getPaymentReceiveInvoices(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+    const { id: paymentReceiveId } = req.params;
+
+    try {
+      const saleInvoices =
+        await this.paymentReceiveService.getPaymentReceiveInvoices(
+          tenantId,
+          paymentReceiveId
+        );
+
+      return res.status(200).send(this.transfromToResponse({ saleInvoices }));
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve payment receive list with pagination metadata.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async getPaymentReceiveList(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const filter = {
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      page: 1,
+      pageSize: 12,
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const { paymentReceives, pagination, filterMeta } =
+        await this.paymentReceiveService.listPaymentReceives(tenantId, filter);
+
+      return res.status(200).send({
+        payment_receives: this.transfromToResponse(paymentReceives),
+        pagination: this.transfromToResponse(pagination),
+        filter_meta: this.transfromToResponse(filterMeta),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve payment receive new page receivable entries.
+   * @param {Request} req - Request.
+   * @param {Response} res - Response.
+   */
+  async getPaymentReceiveNewPageEntries(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+    const { customerId } = this.matchedQueryData(req);
+
+    try {
+      const entries = await this.PaymentReceivesPages.getNewPageEntries(
+        tenantId,
+        customerId
+      );
+      return res.status(200).send({
+        entries: this.transfromToResponse(entries),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve the given payment receive details.
+   * @asycn
+   * @param {Request} req -
+   * @param {Response} res -
+   */
+  async getPaymentReceiveEditPage(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId, user } = req;
+    const { id: paymentReceiveId } = req.params;
+
+    try {
+      const { paymentReceive, entries } =
+        await this.PaymentReceivesPages.getPaymentReceiveEditPage(
+          tenantId,
+          paymentReceiveId,
+          user
+        );
+
+      return res.status(200).send({
+        payment_receive: this.transfromToResponse({ ...paymentReceive }),
+        entries: this.transfromToResponse([...entries]),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve the payment receive details.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async getPaymentReceive(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: paymentReceiveId } = req.params;
+
+    try {
+      const paymentReceive = await this.paymentReceiveService.getPaymentReceive(
+        tenantId,
+        paymentReceiveId
+      );
+
+      const ACCEPT_TYPE = {
+        APPLICATION_PDF: 'application/pdf',
+        APPLICATION_JSON: 'application/json',
+      };
+      res.format({
+        [ACCEPT_TYPE.APPLICATION_JSON]: () => {
+          return res.status(200).send({
+            payment_receive: this.transfromToResponse(paymentReceive),
+          });
+        },
+        [ACCEPT_TYPE.APPLICATION_PDF]: async () => {
+          const pdfContent = await this.paymentReceivePdf.getPaymentReceivePdf(
+            tenantId,
+            paymentReceive
+          );
+          res.set({
+            'Content-Type': 'application/pdf',
+            'Content-Length': pdfContent.length,
+          });
+          res.send(pdfContent);
+        },
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Payment receive notfiy customer by sms.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public paymentReceiveNotifyBySms = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: paymentReceiveId } = req.params;
+
+    try {
+      const paymentReceive = await this.paymentReceiveSmsNotify.notifyBySms(
+        tenantId,
+        paymentReceiveId
+      );
+      return res.status(200).send({
+        id: paymentReceive.id,
+        message: 'The payment notification has been sent successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   *
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public paymentReceiveSmsDetails = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: paymentReceiveId } = req.params;
+
+    try {
+      const smsDetails = await this.paymentReceiveSmsNotify.smsDetails(
+        tenantId,
+        paymentReceiveId
+      );
+      return res.status(200).send({
+        data: smsDetails,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handles service errors.
+   * @param error
+   * @param req
+   * @param res
+   * @param next
+   */
+  handleServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'DEPOSIT_ACCOUNT_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'DEPOSIT.ACCOUNT.NOT.EXISTS', code: 300 }],
+        });
+      }
+      if (error.errorType === 'PAYMENT_RECEIVE_NO_EXISTS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'PAYMENT_RECEIVE_NO_EXISTS', code: 300 }],
+        });
+      }
+      if (error.errorType === 'PAYMENT_RECEIVE_NOT_EXISTS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'PAYMENT_RECEIVE_NOT_EXISTS', code: 300 }],
+        });
+      }
+      if (error.errorType === 'DEPOSIT_ACCOUNT_INVALID_TYPE') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'DEPOSIT_ACCOUNT_INVALID_TYPE', code: 300 }],
+        });
+      }
+      if (error.errorType === 'INVALID_PAYMENT_AMOUNT_INVALID') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'INVALID_PAYMENT_AMOUNT', code: 300 }],
+        });
+      }
+      if (error.errorType === 'INVOICES_IDS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'INVOICES_IDS_NOT_FOUND', code: 300 }],
+        });
+      }
+      if (error.errorType === 'ENTRIES_IDS_NOT_EXISTS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ENTRIES_IDS_NOT_FOUND', code: 300 }],
+        });
+      }
+      if (error.errorType === 'contact_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER_NOT_FOUND', code: 300 }],
+        });
+      }
+      if (error.errorType === 'INVALID_PAYMENT_AMOUNT') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'INVALID_PAYMENT_AMOUNT', code: 1000 }],
+        });
+      }
+      if (error.errorType === 'INVOICES_NOT_DELIVERED_YET') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'INVOICES_NOT_DELIVERED_YET',
+              code: 200,
+              data: {
+                not_delivered_invoices_ids:
+                  error.payload.notDeliveredInvoices.map(
+                    (invoice) => invoice.id
+                  ),
+              },
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'PAYMENT_RECEIVE_NO_IS_REQUIRED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'PAYMENT_RECEIVE_NO_IS_REQUIRED', code: 1100 }],
+        });
+      }
+      if (error.errorType === 'PAYMENT_CUSTOMER_SHOULD_NOT_UPDATE') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'PAYMENT_CUSTOMER_SHOULD_NOT_UPDATE', code: 1200 }],
+        });
+      }
+      if (error.errorType === 'PAYMENT_RECEIVE_NO_REQUIRED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'PAYMENT_RECEIVE_NO_REQUIRED', code: 1300 }],
+        });
+      }
+      if (error.errorType === 'CUSTOMER_HAS_NO_PHONE_NUMBER') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER_HAS_NO_PHONE_NUMBER', code: 1800 }],
+        });
+      }
+      if (error.errorType === 'CUSTOMER_SMS_NOTIFY_PHONE_INVALID') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER_SMS_NOTIFY_PHONE_INVALID', code: 1900 }],
+        });
+      }
+      if (error.errorType === 'TRANSACTIONS_DATE_LOCKED') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'TRANSACTIONS_DATE_LOCKED',
+              code: 4000,
+              data: { ...error.payload },
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'PAYMENT_ACCOUNT_CURRENCY_INVALID') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'PAYMENT_ACCOUNT_CURRENCY_INVALID', code: 2000 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Sales/SalesEstimates.ts b/packages/server/src/api/controllers/Sales/SalesEstimates.ts
new file mode 100644
index 000000000..613186c90
--- /dev/null
+++ b/packages/server/src/api/controllers/Sales/SalesEstimates.ts
@@ -0,0 +1,589 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query, matchedData } from 'express-validator';
+import { Inject, Service } from 'typedi';
+import {
+  AbilitySubject,
+  ISaleEstimateDTO,
+  SaleEstimateAction,
+  SaleInvoiceAction,
+} from '@/interfaces';
+import BaseController from '@/api/controllers/BaseController';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import SaleEstimateService from '@/services/Sales/SalesEstimate';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { ServiceError } from '@/exceptions';
+import SaleEstimatesPdfService from '@/services/Sales/Estimates/SaleEstimatesPdf';
+import SaleEstimateNotifyBySms from '@/services/Sales/Estimates/SaleEstimateSmsNotify';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+const ACCEPT_TYPE = {
+  APPLICATION_PDF: 'application/pdf',
+  APPLICATION_JSON: 'application/json',
+};
+@Service()
+export default class SalesEstimatesController extends BaseController {
+  @Inject()
+  saleEstimateService: SaleEstimateService;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  @Inject()
+  saleEstimatesPdf: SaleEstimatesPdfService;
+
+  @Inject()
+  saleEstimateNotifySms: SaleEstimateNotifyBySms;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/',
+      CheckPolicies(SaleEstimateAction.Create, AbilitySubject.SaleEstimate),
+      [...this.estimateValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.newEstimate.bind(this)),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id/deliver',
+      CheckPolicies(SaleEstimateAction.Edit, AbilitySubject.SaleEstimate),
+      [...this.validateSpecificEstimateSchema],
+      this.validationResult,
+      asyncMiddleware(this.deliverSaleEstimate.bind(this)),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id/approve',
+      CheckPolicies(SaleEstimateAction.Edit, AbilitySubject.SaleEstimate),
+      [this.validateSpecificEstimateSchema],
+      this.validationResult,
+      asyncMiddleware(this.approveSaleEstimate.bind(this)),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id/reject',
+      CheckPolicies(SaleEstimateAction.Edit, AbilitySubject.SaleEstimate),
+      [this.validateSpecificEstimateSchema],
+      this.validationResult,
+      asyncMiddleware(this.rejectSaleEstimate.bind(this)),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id/sms-details',
+      CheckPolicies(
+        SaleEstimateAction.NotifyBySms,
+        AbilitySubject.SaleEstimate
+      ),
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.saleEstimateSmsDetails),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id/notify-by-sms',
+      CheckPolicies(
+        SaleEstimateAction.NotifyBySms,
+        AbilitySubject.SaleEstimate
+      ),
+      [param('id').exists().isNumeric().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.saleEstimateNotifyBySms),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id',
+      CheckPolicies(SaleEstimateAction.Edit, AbilitySubject.SaleEstimate),
+      [
+        ...this.validateSpecificEstimateSchema,
+        ...this.estimateValidationSchema,
+      ],
+      this.validationResult,
+      asyncMiddleware(this.editEstimate.bind(this)),
+      this.handleServiceErrors
+    );
+    router.delete(
+      '/:id',
+      CheckPolicies(SaleEstimateAction.Delete, AbilitySubject.SaleEstimate),
+      [this.validateSpecificEstimateSchema],
+      this.validationResult,
+      asyncMiddleware(this.deleteEstimate.bind(this)),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id',
+      CheckPolicies(SaleEstimateAction.View, AbilitySubject.SaleEstimate),
+      this.validateSpecificEstimateSchema,
+      this.validationResult,
+      asyncMiddleware(this.getEstimate.bind(this)),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/',
+      CheckPolicies(SaleEstimateAction.View, AbilitySubject.SaleEstimate),
+      this.validateEstimateListSchema,
+      this.validationResult,
+      asyncMiddleware(this.getEstimates.bind(this)),
+      this.handleServiceErrors,
+      this.dynamicListService.handlerErrorsToResponse
+    );
+    return router;
+  }
+
+  /**
+   * Estimate validation schema.
+   */
+  get estimateValidationSchema() {
+    return [
+      check('customer_id').exists().isNumeric().toInt(),
+      check('estimate_date').exists().isISO8601().toDate(),
+      check('expiration_date').exists().isISO8601().toDate(),
+      check('reference').optional(),
+      check('estimate_number').optional().trim().escape(),
+      check('delivered').default(false).isBoolean().toBoolean(),
+
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+
+      check('warehouse_id').optional({ nullable: true }).isNumeric().toInt(),
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+
+      check('entries').exists().isArray({ min: 1 }),
+      check('entries.*.index').exists().isNumeric().toInt(),
+      check('entries.*.item_id').exists().isNumeric().toInt(),
+      check('entries.*.quantity').exists().isNumeric().toInt(),
+      check('entries.*.rate').exists().isNumeric().toFloat(),
+      check('entries.*.description')
+        .optional({ nullable: true })
+        .trim()
+        .escape(),
+      check('entries.*.discount')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toFloat(),
+      check('entries.*.warehouse_id')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toInt(),
+
+      check('note').optional().trim().escape(),
+      check('terms_conditions').optional().trim().escape(),
+      check('send_to_email').optional().trim().escape(),
+    ];
+  }
+
+  /**
+   * Specific sale estimate validation schema.
+   */
+  get validateSpecificEstimateSchema() {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  /**
+   * Sales estimates list validation schema.
+   */
+  get validateEstimateListSchema() {
+    return [
+      query('view_slug').optional().isString().trim(),
+      query('stringified_filter_roles').optional().isJSON(),
+      query('column_sort_by').optional(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+      query('search_keyword').optional({ nullable: true }).isString().trim(),
+    ];
+  }
+
+  /**
+   * Handle create a new estimate with associated entries.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @return {Response} res -
+   */
+  async newEstimate(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const estimateDTO: ISaleEstimateDTO = this.matchedBodyData(req);
+
+    try {
+      const storedEstimate = await this.saleEstimateService.createEstimate(
+        tenantId,
+        estimateDTO
+      );
+
+      return res.status(200).send({
+        id: storedEstimate.id,
+        message: 'The sale estimate has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handle update estimate details with associated entries.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async editEstimate(req: Request, res: Response, next: NextFunction) {
+    const { id: estimateId } = req.params;
+    const { tenantId } = req;
+    const estimateDTO: ISaleEstimateDTO = this.matchedBodyData(req);
+
+    try {
+      // Update estimate with associated estimate entries.
+      await this.saleEstimateService.editEstimate(
+        tenantId,
+        estimateId,
+        estimateDTO
+      );
+
+      return res.status(200).send({
+        id: estimateId,
+        message: 'The sale estimate has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Deletes the given estimate with associated entries.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async deleteEstimate(req: Request, res: Response, next: NextFunction) {
+    const { id: estimateId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      await this.saleEstimateService.deleteEstimate(tenantId, estimateId);
+
+      return res.status(200).send({
+        id: estimateId,
+        message: 'The sale estimate has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Deliver the given sale estimate.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async deliverSaleEstimate(req: Request, res: Response, next: NextFunction) {
+    const { id: estimateId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      await this.saleEstimateService.deliverSaleEstimate(tenantId, estimateId);
+
+      return res.status(200).send({
+        id: estimateId,
+        message: 'The sale estimate has been delivered successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Marks the sale estimate as approved.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async approveSaleEstimate(req: Request, res: Response, next: NextFunction) {
+    const { id: estimateId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      await this.saleEstimateService.approveSaleEstimate(tenantId, estimateId);
+
+      return res.status(200).send({
+        id: estimateId,
+        message: 'The sale estimate has been approved successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Marks the sale estimate as rejected.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async rejectSaleEstimate(req: Request, res: Response, next: NextFunction) {
+    const { id: estimateId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      await this.saleEstimateService.rejectSaleEstimate(tenantId, estimateId);
+
+      return res.status(200).send({
+        id: estimateId,
+        message: 'The sale estimate has been rejected successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve the given estimate with associated entries.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async getEstimate(req: Request, res: Response, next: NextFunction) {
+    const { id: estimateId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      const estimate = await this.saleEstimateService.getEstimate(
+        tenantId,
+        estimateId
+      );
+      // Response formatter.
+      res.format({
+        // JSON content type.
+        [ACCEPT_TYPE.APPLICATION_JSON]: () => {
+          return res.status(200).send(this.transfromToResponse({ estimate }));
+        },
+        // PDF content type.
+        [ACCEPT_TYPE.APPLICATION_PDF]: async () => {
+          const pdfContent = await this.saleEstimatesPdf.saleEstimatePdf(
+            tenantId,
+            estimate
+          );
+          res.set({
+            'Content-Type': 'application/pdf',
+            'Content-Length': pdfContent.length,
+          });
+          res.send(pdfContent);
+        },
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve estimates with pagination metadata.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async getEstimates(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const filter = {
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      page: 1,
+      pageSize: 12,
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const { salesEstimates, pagination, filterMeta } =
+        await this.saleEstimateService.estimatesList(tenantId, filter);
+
+      res.format({
+        [ACCEPT_TYPE.APPLICATION_JSON]: () => {
+          return res.status(200).send(
+            this.transfromToResponse({
+              salesEstimates,
+              pagination,
+              filterMeta,
+            })
+          );
+        },
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  public saleEstimateNotifyBySms = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: estimateId } = req.params;
+
+    try {
+      const saleEstimate = await this.saleEstimateNotifySms.notifyBySms(
+        tenantId,
+        estimateId
+      );
+      return res.status(200).send({
+        id: saleEstimate.id,
+        message:
+          'The sale estimate sms notification has been sent successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve the sale estimate sms notification message details.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public saleEstimateSmsDetails = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: estimateId } = req.params;
+
+    try {
+      const estimateSmsDetails = await this.saleEstimateNotifySms.smsDetails(
+        tenantId,
+        estimateId
+      );
+      return res.status(200).send({
+        data: estimateSmsDetails,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handleServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'ITEMS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ITEMS.IDS.NOT.EXISTS', code: 100 }],
+        });
+      }
+      if (error.errorType === 'ENTRIES_IDS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ENTRIES.IDS.NOT.EXISTS', code: 200 }],
+        });
+      }
+      if (error.errorType === 'ITEMS_IDS_NOT_EXISTS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ITEMS.IDS.NOT.EXISTS', code: 300 }],
+        });
+      }
+      if (error.errorType === 'NOT_PURCHASE_ABLE_ITEMS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'NOT_PURCHASABLE_ITEMS', code: 400 }],
+        });
+      }
+      if (error.errorType === 'SALE_ESTIMATE_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE_ESTIMATE_NOT_FOUND', code: 500 }],
+        });
+      }
+      if (error.errorType === 'CUSTOMER_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER_NOT_FOUND', code: 600 }],
+        });
+      }
+      if (error.errorType === 'SALE_ESTIMATE_NUMBER_EXISTANCE') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ESTIMATE.NUMBER.IS.NOT.UNQIUE', code: 700 }],
+        });
+      }
+      if (error.errorType === 'NOT_SELL_ABLE_ITEMS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'NOT_SELL_ABLE_ITEMS', code: 800 }],
+        });
+      }
+      if (error.errorType === 'SALE_ESTIMATE_ALREADY_APPROVED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER_NOT_FOUND', code: 1000 }],
+        });
+      }
+      if (error.errorType === 'SALE_ESTIMATE_NOT_DELIVERED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE_ESTIMATE_NOT_DELIVERED', code: 1100 }],
+        });
+      }
+      if (error.errorType === 'SALE_ESTIMATE_ALREADY_REJECTED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE_ESTIMATE_ALREADY_REJECTED', code: 1200 }],
+        });
+      }
+      if (error.errorType === 'contact_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER_NOT_FOUND', code: 1300 }],
+        });
+      }
+      if (error.errorType === 'SALE_ESTIMATE_NO_IS_REQUIRED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE_ESTIMATE_NO_IS_REQUIRED', code: 1400 }],
+        });
+      }
+      if (error.errorType === 'SALE_ESTIMATE_CONVERTED_TO_INVOICE') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE_ESTIMATE_CONVERTED_TO_INVOICE', code: 1500 }],
+        });
+      }
+      if (error.errorType === 'SALE_ESTIMATE_ALREADY_DELIVERED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE_ESTIMATE_ALREADY_DELIVERED', code: 1600 }],
+        });
+      }
+      if (error.errorType === 'CUSTOMER_HAS_NO_PHONE_NUMBER') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER_HAS_NO_PHONE_NUMBER', code: 1800 }],
+        });
+      }
+      if (error.errorType === 'CUSTOMER_SMS_NOTIFY_PHONE_INVALID') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER_SMS_NOTIFY_PHONE_INVALID', code: 1900 }],
+        });
+      }
+      if (error.errorType === 'TRANSACTIONS_DATE_LOCKED') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'TRANSACTIONS_DATE_LOCKED',
+              code: 4000,
+              data: { ...error.payload },
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'WAREHOUSE_ID_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'WAREHOUSE_ID_NOT_FOUND', code: 5000 }],
+        });
+      }
+      if (error.errorType === 'BRANCH_ID_REQUIRED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'BRANCH_ID_REQUIRED', code: 5100 }],
+        });
+      }
+      if (error.errorType === 'BRANCH_ID_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'BRANCH_ID_NOT_FOUND', code: 5300 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Sales/SalesInvoices.ts b/packages/server/src/api/controllers/Sales/SalesInvoices.ts
new file mode 100644
index 000000000..209f7e848
--- /dev/null
+++ b/packages/server/src/api/controllers/Sales/SalesInvoices.ts
@@ -0,0 +1,754 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query } from 'express-validator';
+import { Service, Inject } from 'typedi';
+import BaseController from '../BaseController';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import SaleInvoiceService from '@/services/Sales/SalesInvoices';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { ServiceError } from '@/exceptions';
+import {
+  ISaleInvoiceDTO,
+  ISaleInvoiceCreateDTO,
+  SaleInvoiceAction,
+  AbilitySubject,
+} from '@/interfaces';
+import SaleInvoicePdf from '@/services/Sales/SaleInvoicePdf';
+import SaleInvoiceWriteoff from '@/services/Sales/SaleInvoiceWriteoff';
+import SaleInvoiceNotifyBySms from '@/services/Sales/SaleInvoiceNotifyBySms';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import InvoicePaymentsService from '@/services/Sales/Invoices/InvoicePaymentsService';
+
+const ACCEPT_TYPE = {
+  APPLICATION_PDF: 'application/pdf',
+  APPLICATION_JSON: 'application/json',
+};
+@Service()
+export default class SaleInvoicesController extends BaseController {
+  @Inject()
+  saleInvoiceService: SaleInvoiceService;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  @Inject()
+  saleInvoicePdf: SaleInvoicePdf;
+
+  @Inject()
+  saleInvoiceWriteoff: SaleInvoiceWriteoff;
+
+  @Inject()
+  saleInvoiceSmsNotify: SaleInvoiceNotifyBySms;
+
+  @Inject()
+  invoicePaymentsSerivce: InvoicePaymentsService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/',
+      CheckPolicies(SaleInvoiceAction.Create, AbilitySubject.SaleInvoice),
+      [
+        ...this.saleInvoiceValidationSchema,
+        check('from_estimate_id').optional().isNumeric().toInt(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.newSaleInvoice.bind(this)),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id/deliver',
+      CheckPolicies(SaleInvoiceAction.Edit, AbilitySubject.SaleInvoice),
+      [...this.specificSaleInvoiceValidation],
+      this.validationResult,
+      asyncMiddleware(this.deliverSaleInvoice.bind(this)),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id/writeoff',
+      CheckPolicies(SaleInvoiceAction.Writeoff, AbilitySubject.SaleInvoice),
+      [
+        param('id').exists().isInt().toInt(),
+
+        check('expense_account_id').exists().isInt().toInt(),
+        check('reason').exists().trim(),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.writeoffSaleInvoice),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id/writeoff/cancel',
+      CheckPolicies(SaleInvoiceAction.Writeoff, AbilitySubject.SaleInvoice),
+      [param('id').exists().isInt().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.cancelWrittenoffSaleInvoice),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id/notify-by-sms',
+      CheckPolicies(SaleInvoiceAction.NotifyBySms, AbilitySubject.SaleInvoice),
+      [
+        param('id').exists().isInt().toInt(),
+        check('notification_key').exists().isIn(['details', 'reminder']),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.saleInvoiceNotifyBySms),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id/sms-details',
+      CheckPolicies(SaleInvoiceAction.NotifyBySms, AbilitySubject.SaleInvoice),
+      [
+        param('id').exists().isInt().toInt(),
+        query('notification_key').exists().isIn(['details', 'reminder']),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.saleInvoiceSmsDetails),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id',
+      CheckPolicies(SaleInvoiceAction.Edit, AbilitySubject.SaleInvoice),
+      [
+        ...this.saleInvoiceValidationSchema,
+        ...this.specificSaleInvoiceValidation,
+      ],
+      this.validationResult,
+      asyncMiddleware(this.editSaleInvoice.bind(this)),
+      this.handleServiceErrors
+    );
+    router.delete(
+      '/:id',
+      CheckPolicies(SaleInvoiceAction.Delete, AbilitySubject.SaleInvoice),
+      this.specificSaleInvoiceValidation,
+      this.validationResult,
+      asyncMiddleware(this.deleteSaleInvoice.bind(this)),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/payable',
+      CheckPolicies(SaleInvoiceAction.View, AbilitySubject.SaleInvoice),
+      [...this.dueSalesInvoicesListValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.getPayableInvoices.bind(this)),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id/payment-transactions',
+      [param('id').exists().isString()],
+      this.validationResult,
+      this.asyncMiddleware(this.getInvoicePaymentTransactions),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id',
+      CheckPolicies(SaleInvoiceAction.View, AbilitySubject.SaleInvoice),
+      this.specificSaleInvoiceValidation,
+      this.validationResult,
+      asyncMiddleware(this.getSaleInvoice.bind(this)),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/',
+      CheckPolicies(SaleInvoiceAction.View, AbilitySubject.SaleInvoice),
+      this.saleInvoiceListValidationSchema,
+      this.validationResult,
+      asyncMiddleware(this.getSalesInvoices.bind(this)),
+      this.handleServiceErrors,
+      this.dynamicListService.handlerErrorsToResponse
+    );
+    return router;
+  }
+
+  /**
+   * Sale invoice validation schema.
+   */
+  get saleInvoiceValidationSchema() {
+    return [
+      check('customer_id').exists().isNumeric().toInt(),
+      check('invoice_date').exists().isISO8601().toDate(),
+      check('due_date').exists().isISO8601().toDate(),
+      check('invoice_no').optional().trim().escape(),
+      check('reference_no').optional().trim().escape(),
+      check('delivered').default(false).isBoolean().toBoolean(),
+
+      check('invoice_message').optional().trim().escape(),
+      check('terms_conditions').optional().trim().escape(),
+
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+
+      check('warehouse_id').optional({ nullable: true }).isNumeric().toInt(),
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+      check('project_id').optional({ nullable: true }).isNumeric().toInt(),
+
+      check('entries').exists().isArray({ min: 1 }),
+
+      check('entries.*.index').exists().isNumeric().toInt(),
+      check('entries.*.item_id').exists().isNumeric().toInt(),
+      check('entries.*.rate').exists().isNumeric().toFloat(),
+      check('entries.*.quantity').exists().isNumeric().toFloat(),
+      check('entries.*.discount')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toFloat(),
+      check('entries.*.description')
+        .optional({ nullable: true })
+        .trim()
+        .escape(),
+      check('entries.*.warehouse_id')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toInt(),
+      check('entries.*.project_id')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toInt(),
+
+      check('entries.*.project_ref_id')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toInt(),
+      check('entries.*.project_ref_type')
+        .optional({ nullable: true })
+        .isString()
+        .toUpperCase()
+        .isIn(['TASK', 'BILL', 'EXPENSE']),
+      check('entries.*.project_ref_invoiced_amount')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toFloat(),
+    ];
+  }
+
+  /**
+   * Specific sale invoice validation schema.
+   */
+  get specificSaleInvoiceValidation() {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  /**
+   * Sales invoices list validation schema.
+   */
+  get saleInvoiceListValidationSchema() {
+    return [
+      query('view_slug').optional({ nullable: true }).isString().trim(),
+      query('stringified_filter_roles').optional().isJSON(),
+      query('column_sort_by').optional(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+      query('search_keyword').optional({ nullable: true }).isString().trim(),
+    ];
+  }
+
+  /**
+   * Due sale invoice list validation schema.
+   */
+  get dueSalesInvoicesListValidationSchema() {
+    return [query('customer_id').optional().isNumeric().toInt()];
+  }
+
+  /**
+   * Creates a new sale invoice.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {Function} next
+   */
+  async newSaleInvoice(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const saleInvoiceDTO: ISaleInvoiceCreateDTO = this.matchedBodyData(req);
+
+    try {
+      // Creates a new sale invoice with associated entries.
+      const storedSaleInvoice = await this.saleInvoiceService.createSaleInvoice(
+        tenantId,
+        saleInvoiceDTO,
+        user
+      );
+      return res.status(200).send({
+        id: storedSaleInvoice.id,
+        message: 'The sale invoice has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Edit sale invoice details.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {Function} next
+   */
+  async editSaleInvoice(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const { id: saleInvoiceId } = req.params;
+    const saleInvoiceOTD: ISaleInvoiceDTO = this.matchedBodyData(req);
+
+    try {
+      // Update the given sale invoice details.
+      await this.saleInvoiceService.editSaleInvoice(
+        tenantId,
+        saleInvoiceId,
+        saleInvoiceOTD,
+        user
+      );
+      return res.status(200).send({
+        id: saleInvoiceId,
+        message: 'The sale invoice has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Deliver the given sale invoice.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  async deliverSaleInvoice(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const { id: saleInvoiceId } = req.params;
+
+    try {
+      await this.saleInvoiceService.deliverSaleInvoice(
+        tenantId,
+        saleInvoiceId,
+        user
+      );
+      return res.status(200).send({
+        id: saleInvoiceId,
+        message: 'The given sale invoice has been delivered successfully',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Deletes the sale invoice with associated entries and journal transactions.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {Function} next
+   */
+  async deleteSaleInvoice(req: Request, res: Response, next: NextFunction) {
+    const { id: saleInvoiceId } = req.params;
+    const { tenantId, user } = req;
+
+    try {
+      // Deletes the sale invoice with associated entries and journal transaction.
+      await this.saleInvoiceService.deleteSaleInvoice(
+        tenantId,
+        saleInvoiceId,
+        user
+      );
+
+      return res.status(200).send({
+        id: saleInvoiceId,
+        message: 'The sale invoice has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve the sale invoice with associated entries.
+   * @param {Request} req - Request object.
+   * @param {Response} res - Response object.
+   */
+  async getSaleInvoice(req: Request, res: Response, next: NextFunction) {
+    const { id: saleInvoiceId } = req.params;
+    const { tenantId, user } = req;
+
+    try {
+      const saleInvoice = await this.saleInvoiceService.getSaleInvoice(
+        tenantId,
+        saleInvoiceId,
+        user
+      );
+      // Response formatter.
+      res.format({
+        // JSON content type.
+        [ACCEPT_TYPE.APPLICATION_JSON]: () => {
+          return res
+            .status(200)
+            .send(this.transfromToResponse({ saleInvoice }));
+        },
+        // PDF content type.
+        [ACCEPT_TYPE.APPLICATION_PDF]: async () => {
+          const pdfContent = await this.saleInvoicePdf.saleInvoicePdf(
+            tenantId,
+            saleInvoice
+          );
+          res.set({
+            'Content-Type': 'application/pdf',
+            'Content-Length': pdfContent.length,
+          });
+          res.send(pdfContent);
+        },
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  /**
+   * Retrieve paginated sales invoices with custom view metadata.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {Function} next
+   */
+  public async getSalesInvoices(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+    const filter = {
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      page: 1,
+      pageSize: 12,
+      ...this.matchedQueryData(req),
+    };
+    try {
+      const { salesInvoices, filterMeta, pagination } =
+        await this.saleInvoiceService.salesInvoicesList(tenantId, filter);
+
+      return res.status(200).send({
+        sales_invoices: this.transfromToResponse(salesInvoices),
+        pagination: this.transfromToResponse(pagination),
+        filter_meta: this.transfromToResponse(filterMeta),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve due sales invoices.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   * @return {Response|void}
+   */
+  public async getPayableInvoices(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+    const { customerId } = this.matchedQueryData(req);
+
+    try {
+      const salesInvoices = await this.saleInvoiceService.getPayableInvoices(
+        tenantId,
+        customerId
+      );
+      return res.status(200).send({
+        sales_invoices: this.transfromToResponse(salesInvoices),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Written-off sale invoice.
+   * @param {Request} req
+   * @param {Response} res
+   * @param next
+   */
+  public writeoffSaleInvoice = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: invoiceId } = req.params;
+
+    const writeoffDTO = this.matchedBodyData(req);
+
+    try {
+      const saleInvoice = await this.saleInvoiceWriteoff.writeOff(
+        tenantId,
+        invoiceId,
+        writeoffDTO
+      );
+
+      return res.status(200).send({
+        id: saleInvoice.id,
+        message: 'The given sale invoice has been writte-off successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Cancel the written-off sale invoice.
+   * @param {Request} req
+   * @param {Response} res
+   * @param next
+   */
+  public cancelWrittenoffSaleInvoice = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: invoiceId } = req.params;
+
+    try {
+      const saleInvoice = await this.saleInvoiceWriteoff.cancelWrittenoff(
+        tenantId,
+        invoiceId
+      );
+      return res.status(200).send({
+        id: saleInvoice.id,
+        message:
+          'The given sale invoice has been canceled write-off successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Sale invoice notfiy customer by sms.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public saleInvoiceNotifyBySms = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: invoiceId } = req.params;
+
+    const invoiceNotifySmsDTO = this.matchedBodyData(req);
+
+    try {
+      const saleInvoice = await this.saleInvoiceSmsNotify.notifyBySms(
+        tenantId,
+        invoiceId,
+        invoiceNotifySmsDTO.notificationKey
+      );
+      return res.status(200).send({
+        id: saleInvoice.id,
+        message:
+          'The sale invoice sms notification has been sent successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Sale invoice SMS details.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public saleInvoiceSmsDetails = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: invoiceId } = req.params;
+    const smsDetailsDTO = this.matchedQueryData(req);
+
+    try {
+      const invoiceSmsDetails = await this.saleInvoiceSmsNotify.smsDetails(
+        tenantId,
+        invoiceId,
+        smsDetailsDTO
+      );
+      return res.status(200).send({
+        data: invoiceSmsDetails,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve the invoice payment transactions.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @returns
+   */
+  public getInvoicePaymentTransactions = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: invoiceId } = req.params;
+
+    try {
+      const invoicePayments =
+        await this.invoicePaymentsSerivce.getInvoicePayments(
+          tenantId,
+          invoiceId
+        );
+
+      return res.status(200).send({
+        data: invoicePayments,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handleServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'INVOICE_NUMBER_NOT_UNIQUE') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE.INVOICE.NUMBER.IS.EXISTS', code: 100 }],
+        });
+      }
+      if (error.errorType === 'SALE_INVOICE_NOT_FOUND') {
+        return res.status(404).send({
+          errors: [{ type: 'SALE.INVOICE.NOT.FOUND', code: 200 }],
+        });
+      }
+      if (error.errorType === 'ENTRIES_ITEMS_IDS_NOT_EXISTS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ENTRIES_ITEMS_IDS_NOT_EXISTS', code: 300 }],
+        });
+      }
+      if (error.errorType === 'NOT_SELLABLE_ITEMS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'NOT_SELLABLE_ITEMS', code: 400 }],
+        });
+      }
+      if (error.errorType === 'SALE_INVOICE_NO_NOT_UNIQUE') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE_INVOICE_NO_NOT_UNIQUE', code: 500 }],
+        });
+      }
+      if (error.errorType === 'ITEMS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ITEMS_NOT_FOUND', code: 600 }],
+        });
+      }
+      if (error.errorType === 'ENTRIES_IDS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ENTRIES_IDS_NOT_FOUND', code: 700 }],
+        });
+      }
+      if (error.errorType === 'NOT_SELL_ABLE_ITEMS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'NOT_SELL_ABLE_ITEMS', code: 800 }],
+        });
+      }
+      if (error.errorType === 'contact_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER_NOT_FOUND', code: 900 }],
+        });
+      }
+      if (error.errorType === 'SALE_INVOICE_ALREADY_DELIVERED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE_INVOICE_ALREADY_DELIVERED', code: 1000 }],
+        });
+      }
+      if (error.errorType === 'INVOICE_HAS_ASSOCIATED_PAYMENT_ENTRIES') {
+        return res.boom.badRequest(null, {
+          errors: [
+            { type: 'INVOICE_HAS_ASSOCIATED_PAYMENT_ENTRIES', code: 1100 },
+          ],
+        });
+      }
+      if (error.errorType === 'SALE_ESTIMATE_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'FROM_SALE_ESTIMATE_NOT_FOUND', code: 1200 }],
+        });
+      }
+      if (error.errorType === 'SALE_ESTIMATE_CONVERTED_TO_INVOICE') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'SALE_ESTIMATE_IS_ALREADY_CONVERTED_TO_INVOICE',
+              code: 1300,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'INVOICE_AMOUNT_SMALLER_THAN_PAYMENT_AMOUNT') {
+        return res.boom.badRequest(null, {
+          errors: [
+            { type: 'INVOICE_AMOUNT_SMALLER_THAN_PAYMENT_AMOUNT', code: 1400 },
+          ],
+        });
+      }
+      if (error.errorType === 'SALE_INVOICE_NO_IS_REQUIRED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE_INVOICE_NO_IS_REQUIRED', code: 1500 }],
+        });
+      }
+      if (error.errorType === 'SALE_INVOICE_NOT_WRITTEN_OFF') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE_INVOICE_NOT_WRITTEN_OFF', code: 1600 }],
+        });
+      }
+      if (error.errorType === 'SALE_INVOICE_ALREADY_WRITTEN_OFF') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE_INVOICE_ALREADY_WRITTEN_OFF', code: 1700 }],
+        });
+      }
+      if (error.errorType === 'CUSTOMER_HAS_NO_PHONE_NUMBER') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER_HAS_NO_PHONE_NUMBER', code: 1800 }],
+        });
+      }
+      if (error.errorType === 'CUSTOMER_SMS_NOTIFY_PHONE_INVALID') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER_SMS_NOTIFY_PHONE_INVALID', code: 1800 }],
+        });
+      }
+      if (error.errorType === 'SALE_INVOICE_HAS_APPLIED_TO_CREDIT_NOTES') {
+        return res.boom.badRequest(null, {
+          errors: [
+            { type: 'SALE_INVOICE_HAS_APPLIED_TO_CREDIT_NOTES', code: 1900 },
+          ],
+        });
+      }
+      if (error.errorType === 'TRANSACTIONS_DATE_LOCKED') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'TRANSACTIONS_DATE_LOCKED',
+              code: 4900,
+              data: { ...error.payload },
+            },
+          ],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Sales/SalesReceipts.ts b/packages/server/src/api/controllers/Sales/SalesReceipts.ts
new file mode 100644
index 000000000..bed4c2d93
--- /dev/null
+++ b/packages/server/src/api/controllers/Sales/SalesReceipts.ts
@@ -0,0 +1,502 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, param, query } from 'express-validator';
+import { Inject, Service } from 'typedi';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import SaleReceiptService from '@/services/Sales/SalesReceipts';
+import SaleReceiptsPdfService from '@/services/Sales/Receipts/SaleReceiptsPdfService';
+import BaseController from '../BaseController';
+import { ISaleReceiptDTO } from '@/interfaces/SaleReceipt';
+import { ServiceError } from '@/exceptions';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import SaleReceiptNotifyBySms from '@/services/Sales/SaleReceiptNotifyBySms';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { AbilitySubject, SaleReceiptAction } from '@/interfaces';
+
+@Service()
+export default class SalesReceiptsController extends BaseController {
+  @Inject()
+  saleReceiptService: SaleReceiptService;
+
+  @Inject()
+  saleReceiptsPdf: SaleReceiptsPdfService;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  @Inject()
+  saleReceiptSmsNotify: SaleReceiptNotifyBySms;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/:id/close',
+      CheckPolicies(SaleReceiptAction.Edit, AbilitySubject.SaleReceipt),
+      [...this.specificReceiptValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.closeSaleReceipt.bind(this)),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id/notify-by-sms',
+      CheckPolicies(SaleReceiptAction.NotifyBySms, AbilitySubject.SaleReceipt),
+      [param('id').exists().isInt().toInt()],
+      this.asyncMiddleware(this.saleReceiptNotifyBySms),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:id/sms-details',
+      CheckPolicies(SaleReceiptAction.NotifyBySms, AbilitySubject.SaleReceipt),
+      [param('id').exists().isInt().toInt()],
+      this.saleReceiptSmsDetails,
+      this.handleServiceErrors
+    );
+    router.post(
+      '/:id',
+      CheckPolicies(SaleReceiptAction.Edit, AbilitySubject.SaleReceipt),
+      [
+        ...this.specificReceiptValidationSchema,
+        ...this.salesReceiptsValidationSchema,
+      ],
+      this.validationResult,
+      asyncMiddleware(this.editSaleReceipt.bind(this)),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/',
+      CheckPolicies(SaleReceiptAction.Create, AbilitySubject.SaleReceipt),
+      this.salesReceiptsValidationSchema,
+      this.validationResult,
+      asyncMiddleware(this.newSaleReceipt.bind(this)),
+      this.handleServiceErrors
+    );
+    router.delete(
+      '/:id',
+      CheckPolicies(SaleReceiptAction.Delete, AbilitySubject.SaleReceipt),
+      this.specificReceiptValidationSchema,
+      this.validationResult,
+      asyncMiddleware(this.deleteSaleReceipt.bind(this)),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/',
+      CheckPolicies(SaleReceiptAction.View, AbilitySubject.SaleReceipt),
+      this.listSalesReceiptsValidationSchema,
+      this.validationResult,
+      asyncMiddleware(this.getSalesReceipts.bind(this)),
+      this.handleServiceErrors,
+      this.dynamicListService.handlerErrorsToResponse
+    );
+    router.get(
+      '/:id',
+      CheckPolicies(SaleReceiptAction.View, AbilitySubject.SaleReceipt),
+      [...this.specificReceiptValidationSchema],
+      this.validationResult,
+      asyncMiddleware(this.getSaleReceipt.bind(this)),
+      this.handleServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Sales receipt validation schema.
+   * @return {Array}
+   */
+  get salesReceiptsValidationSchema() {
+    return [
+      check('customer_id').exists().isNumeric().toInt(),
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+
+      check('deposit_account_id').exists().isNumeric().toInt(),
+      check('receipt_date').exists().isISO8601(),
+      check('receipt_number').optional().trim().escape(),
+      check('reference_no').optional().trim().escape(),
+      check('closed').default(false).isBoolean().toBoolean(),
+
+      check('warehouse_id').optional({ nullable: true }).isNumeric().toInt(),
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+
+      check('entries').exists().isArray({ min: 1 }),
+
+      check('entries.*.id').optional({ nullable: true }).isNumeric().toInt(),
+      check('entries.*.index').exists().isNumeric().toInt(),
+      check('entries.*.item_id').exists().isNumeric().toInt(),
+      check('entries.*.quantity').exists().isNumeric().toInt(),
+      check('entries.*.rate').exists().isNumeric().toInt(),
+      check('entries.*.discount')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toInt(),
+      check('entries.*.description')
+        .optional({ nullable: true })
+        .trim()
+        .escape(),
+      check('entries.*.warehouse_id')
+        .optional({ nullable: true })
+        .isNumeric()
+        .toInt(),
+      check('receipt_message').optional().trim().escape(),
+      check('statement').optional().trim().escape(),
+    ];
+  }
+
+  /**
+   * Specific sale receipt validation schema.
+   */
+  get specificReceiptValidationSchema() {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  /**
+   * List sales receipts validation schema.
+   */
+  get listSalesReceiptsValidationSchema() {
+    return [
+      query('view_slug').optional().isString().trim(),
+      query('stringified_filter_roles').optional().isJSON(),
+      query('column_sort_by').optional(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+      query('search_keyword').optional({ nullable: true }).isString().trim(),
+    ];
+  }
+
+  /**
+   * Creates a new receipt.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async newSaleReceipt(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const saleReceiptDTO: ISaleReceiptDTO = this.matchedBodyData(req);
+
+    try {
+      // Store the given sale receipt details with associated entries.
+      const storedSaleReceipt = await this.saleReceiptService.createSaleReceipt(
+        tenantId,
+        saleReceiptDTO
+      );
+      return res.status(200).send({
+        id: storedSaleReceipt.id,
+        message: 'Sale receipt has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Deletes the sale receipt with associated entries and journal transactions.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async deleteSaleReceipt(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: saleReceiptId } = req.params;
+
+    try {
+      // Deletes the sale receipt.
+      await this.saleReceiptService.deleteSaleReceipt(tenantId, saleReceiptId);
+
+      return res.status(200).send({
+        id: saleReceiptId,
+        message: 'Sale receipt has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Edit the sale receipt details with associated entries and re-write
+   * journal transaction on the same date.
+   * @param {Request} req -
+   * @param {Response} res -
+   */
+  async editSaleReceipt(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: saleReceiptId } = req.params;
+    const saleReceipt = this.matchedBodyData(req);
+
+    try {
+      // Update the given sale receipt details.
+      await this.saleReceiptService.editSaleReceipt(
+        tenantId,
+        saleReceiptId,
+        saleReceipt
+      );
+      return res.status(200).send({
+        id: saleReceiptId,
+        message: 'Sale receipt has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Marks the given the sale receipt as closed.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async closeSaleReceipt(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { id: saleReceiptId } = req.params;
+
+    try {
+      // Update the given sale receipt details.
+      await this.saleReceiptService.closeSaleReceipt(tenantId, saleReceiptId);
+      return res.status(200).send({
+        id: saleReceiptId,
+        message: 'Sale receipt has been closed successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Listing sales receipts.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async getSalesReceipts(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const filter = {
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      page: 1,
+      pageSize: 12,
+      ...this.matchedQueryData(req),
+    };
+
+    try {
+      const { data, pagination, filterMeta } =
+        await this.saleReceiptService.salesReceiptsList(tenantId, filter);
+
+      const response = this.transfromToResponse({
+        data,
+        pagination,
+        filterMeta,
+      });
+      return res.status(200).send(response);
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve the sale receipt with associated entries.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async getSaleReceipt(req: Request, res: Response, next: NextFunction) {
+    const { id: saleReceiptId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      const saleReceipt = await this.saleReceiptService.getSaleReceipt(
+        tenantId,
+        saleReceiptId
+      );
+
+      res.format({
+        'application/json': () => {
+          return res
+            .status(200)
+            .send(this.transfromToResponse({ saleReceipt }));
+        },
+        'application/pdf': async () => {
+          const pdfContent = await this.saleReceiptsPdf.saleReceiptPdf(
+            tenantId,
+            saleReceipt
+          );
+          res.set({
+            'Content-Type': 'application/pdf',
+            'Content-Length': pdfContent.length,
+          });
+          res.send(pdfContent);
+        },
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Sale receipt notification via SMS.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public saleReceiptNotifyBySms = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: receiptId } = req.params;
+
+    try {
+      const saleReceipt = await this.saleReceiptSmsNotify.notifyBySms(
+        tenantId,
+        receiptId
+      );
+      return res.status(200).send({
+        id: saleReceipt.id,
+        message:
+          'The sale receipt notification via sms has been sent successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Sale receipt sms details.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public saleReceiptSmsDetails = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: receiptId } = req.params;
+
+    try {
+      const smsDetails = await this.saleReceiptSmsNotify.smsDetails(
+        tenantId,
+        receiptId
+      );
+      return res.status(200).send({
+        data: smsDetails,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  handleServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'SALE_RECEIPT_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE_RECEIPT_NOT_FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'DEPOSIT_ACCOUNT_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'DEPOSIT_ACCOUNT_NOT_FOUND', code: 200 }],
+        });
+      }
+      if (error.errorType === 'DEPOSIT_ACCOUNT_NOT_CURRENT_ASSET') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'DEPOSIT_ACCOUNT_NOT_CURRENT_ASSET', code: 300 }],
+        });
+      }
+      if (error.errorType === 'ITEMS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ITEMS_NOT_FOUND', code: 400 }],
+        });
+      }
+      if (error.errorType === 'ENTRIES_IDS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'ENTRIES_IDS_NOT_FOUND', code: 500 }],
+        });
+      }
+      if (error.errorType === 'NOT_SELL_ABLE_ITEMS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'NOT_SELL_ABLE_ITEMS', code: 600 }],
+        });
+      }
+      if (error.errorType === 'SALE.RECEIPT.NOT.FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE.RECEIPT.NOT.FOUND', code: 700 }],
+        });
+      }
+      if (error.errorType === 'DEPOSIT.ACCOUNT.NOT.EXISTS') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'DEPOSIT.ACCOUNT.NOT.EXISTS', code: 800 }],
+        });
+      }
+      if (error.errorType === 'SALE_RECEIPT_NUMBER_NOT_UNIQUE') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE_RECEIPT_NUMBER_NOT_UNIQUE', code: 900 }],
+        });
+      }
+      if (error.errorType === 'SALE_RECEIPT_IS_ALREADY_CLOSED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SALE_RECEIPT_IS_ALREADY_CLOSED', code: 1000 }],
+        });
+      }
+      if (error.errorType === 'SALE_RECEIPT_NO_IS_REQUIRED') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'SALE_RECEIPT_NO_IS_REQUIRED',
+              message: 'The sale receipt number is required.',
+              code: 1100,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'CUSTOMER_HAS_NO_PHONE_NUMBER') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER_HAS_NO_PHONE_NUMBER', code: 1800 }],
+        });
+      }
+      if (error.errorType === 'CUSTOMER_SMS_NOTIFY_PHONE_INVALID') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'CUSTOMER_SMS_NOTIFY_PHONE_INVALID', code: 1900 }],
+        });
+      }
+      if (error.errorType === 'TRANSACTIONS_DATE_LOCKED') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'TRANSACTIONS_DATE_LOCKED',
+              code: 4000,
+              data: { ...error.payload },
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'WAREHOUSE_ID_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'WAREHOUSE_ID_NOT_FOUND', code: 5000 }],
+        });
+      }
+      if (error.errorType === 'BRANCH_ID_REQUIRED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'BRANCH_ID_REQUIRED', code: 5100 }],
+        });
+      }
+      if (error.errorType === 'BRANCH_ID_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'BRANCH_ID_NOT_FOUND', code: 5300 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Sales/index.ts b/packages/server/src/api/controllers/Sales/index.ts
new file mode 100644
index 000000000..46306b54f
--- /dev/null
+++ b/packages/server/src/api/controllers/Sales/index.ts
@@ -0,0 +1,24 @@
+import { Router } from 'express';
+import { Container, Service } from 'typedi';
+import SalesEstimates from './SalesEstimates';
+import SalesReceipts from './SalesReceipts';
+import SalesInvoices from './SalesInvoices'
+import PaymentReceives from './PaymentReceives';
+import CreditNotes from './CreditNotes';
+@Service()
+export default class SalesController {
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.use('/invoices', Container.get(SalesInvoices).router());
+    router.use('/estimates', Container.get(SalesEstimates).router());
+    router.use('/receipts', Container.get(SalesReceipts).router());
+    router.use('/payment_receives', Container.get(PaymentReceives).router());
+    router.use('/credit_notes', Container.get(CreditNotes).router())
+
+    return router;
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/api/controllers/Settings/EasySmsIntegration.ts b/packages/server/src/api/controllers/Settings/EasySmsIntegration.ts
new file mode 100644
index 000000000..d62f34b0f
--- /dev/null
+++ b/packages/server/src/api/controllers/Settings/EasySmsIntegration.ts
@@ -0,0 +1,110 @@
+import { Inject, Service } from 'typedi';
+import { Router, NextFunction, Response } from 'express';
+import { check } from 'express-validator';
+import { Request } from 'express-validator/src/base';
+import EasySmsIntegration from '@/services/SmsIntegration/EasySmsIntegration';
+import BaseController from '../BaseController';
+
+@Service()
+export default class EasySmsIntegrationController extends BaseController {
+  @Inject()
+  easySmsIntegrationService: EasySmsIntegration;
+
+  /**
+   * Controller router.
+   */
+  public router = () => {
+    const router = Router();
+
+    router.post(
+      '/easysms/integrate',
+      [check('token').exists()],
+      this.integrationEasySms
+    );
+    router.post(
+      '/easysms/disconnect',
+      this.disconnectEasysms
+    )
+    router.get('/easysms', this.getIntegrationMeta);
+
+    return router;
+  };
+
+  /**
+   * Easysms integration API.
+   * @param {Request} req - Request object.
+   * @param {Response} res - Response object.
+   * @param {NextFunction} next - Next function.
+   */
+  private integrationEasySms = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const easysmsIntegrateDTO = this.matchedBodyData(req);
+
+    try {
+      await this.easySmsIntegrationService.integrate(
+        tenantId,
+        easysmsIntegrateDTO
+      );
+      return res.status(200).send({
+        message:
+          'The system has been integrated with Easysms sms gateway successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve the Easysms integration meta.
+   * @param req
+   * @param res
+   * @param next
+   * @returns
+   */
+  private getIntegrationMeta = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+
+    try {
+      const data = await this.easySmsIntegrationService.getIntegrationMeta(
+        tenantId
+      );
+      return res.status(200).send({ data });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * 
+   * @param req 
+   * @param res 
+   * @param next 
+   * @returns 
+   */
+  private disconnectEasysms = async (
+    req: Request,
+    res: Response,
+    next: NextFunction    
+  ) => {
+    const { tenantId } = req;
+
+    try {
+      await this.easySmsIntegrationService.disconnect(
+        tenantId,
+      );
+      return res.status(200).send({
+        message: 'The sms gateway integration has been disconnected successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/Settings/Settings.ts b/packages/server/src/api/controllers/Settings/Settings.ts
new file mode 100644
index 000000000..998257cf9
--- /dev/null
+++ b/packages/server/src/api/controllers/Settings/Settings.ts
@@ -0,0 +1,114 @@
+import { Inject, Service } from 'typedi';
+import { Router, Request, Response } from 'express';
+import { body, query } from 'express-validator';
+import { pick } from 'lodash';
+import { IOptionDTO, IOptionsDTO } from '@/interfaces';
+import BaseController from '@/api/controllers/BaseController';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import { AbilitySubject, PreferencesAction } from '@/interfaces';
+import SettingsService from '@/services/Settings/SettingsService';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+@Service()
+export default class SettingsController extends BaseController {
+  @Inject()
+  settingsService: SettingsService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/',
+      CheckPolicies(PreferencesAction.Mutate, AbilitySubject.Preferences),
+      this.saveSettingsValidationSchema,
+      this.validationResult,
+      asyncMiddleware(this.saveSettings.bind(this))
+    );
+    router.get(
+      '/',
+      this.getSettingsSchema,
+      this.validationResult,
+      asyncMiddleware(this.getSettings.bind(this))
+    );
+    return router;
+  }
+
+  /**
+   * Save settings validation schema.
+   */
+  private get saveSettingsValidationSchema() {
+    return [
+      body('options').isArray({ min: 1 }),
+      body('options.*.key').exists().trim().isLength({ min: 1 }),
+      body('options.*.value').exists().trim(),
+      body('options.*.group').exists().trim().isLength({ min: 1 }),
+    ];
+  }
+
+  /**
+   * Retrieve the application options from the storage.
+   */
+  private get getSettingsSchema() {
+    return [
+      query('key').optional().trim().escape(),
+      query('group').optional().trim().escape(),
+    ];
+  }
+
+  /**
+   * Saves the given options to the storage.
+   * @param {Request} req -
+   * @param {Response} res -
+   */
+  public async saveSettings(req: Request, res: Response, next) {
+    const { tenantId } = req;
+    const optionsDTO: IOptionsDTO = this.matchedBodyData(req);
+    const { settings } = req;
+
+    const errorReasons: { type: string; code: number; keys: [] }[] = [];
+    const notDefinedOptions = this.settingsService.validateNotDefinedSettings(
+      tenantId,
+      optionsDTO.options
+    );
+
+    if (notDefinedOptions.length) {
+      errorReasons.push({
+        type: 'OPTIONS.KEY.NOT.DEFINED',
+        code: 200,
+        keys: notDefinedOptions.map((o) => ({ ...pick(o, ['key', 'group']) })),
+      });
+    }
+    if (errorReasons.length) {
+      return res.status(400).send({ errors: errorReasons });
+    }
+    optionsDTO.options.forEach((option: IOptionDTO) => {
+      settings.set({ ...option });
+    });
+    try {
+      await settings.save();
+
+      return res.status(200).send({
+        type: 'success',
+        code: 'OPTIONS.SAVED.SUCCESSFULLY',
+        message: 'Options have been saved successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve settings.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  public getSettings(req: Request, res: Response) {
+    const { settings } = req;
+    const allSettings = settings.all();
+
+    return res.status(200).send({ settings: allSettings });
+  }
+}
diff --git a/packages/server/src/api/controllers/Settings/SmsNotificationsSettings.ts b/packages/server/src/api/controllers/Settings/SmsNotificationsSettings.ts
new file mode 100644
index 000000000..40d396ce1
--- /dev/null
+++ b/packages/server/src/api/controllers/Settings/SmsNotificationsSettings.ts
@@ -0,0 +1,168 @@
+import { Inject, Service } from 'typedi';
+import { check, oneOf, param } from 'express-validator';
+import { Router, Response, Request, NextFunction } from 'express';
+
+import SmsNotificationsSettingsService from '@/services/Settings/SmsNotificationsSettings';
+import BaseController from '../BaseController';
+
+import { ServiceError } from '@/exceptions';
+import {
+  AbilitySubject,
+  PreferencesAction,
+  IEditSmsNotificationDTO,
+} from '@/interfaces';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+@Service()
+export default class SettingsController extends BaseController {
+  @Inject()
+  smsNotificationsSettings: SmsNotificationsSettingsService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/sms-notifications',
+      [],
+      this.validationResult,
+      this.asyncMiddleware(this.smsNotifications),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/sms-notification/:notification_key',
+      [param('notification_key').exists().isString()],
+      this.validationResult,
+      this.asyncMiddleware(this.smsNotification),
+      this.handleServiceErrors
+    );
+    router.post(
+      '/sms-notification',
+      CheckPolicies(PreferencesAction.Mutate, AbilitySubject.Preferences),
+      [
+        check('notification_key').exists(),
+        oneOf([
+          check('message_text').exists(),
+          check('is_notification_enabled').exists().isBoolean().toBoolean(),
+        ]),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.updateSmsNotification),
+      this.handleServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Retrieve the sms notifications.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  private smsNotifications = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+
+    try {
+      const notifications =
+        await this.smsNotificationsSettings.smsNotificationsList(tenantId);
+
+      return res.status(200).send({ notifications });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve the sms notification details from the given notification key.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  private smsNotification = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { notification_key: notificationKey } = req.params;
+
+    try {
+      const notification =
+        await this.smsNotificationsSettings.getSmsNotificationMeta(
+          tenantId,
+          notificationKey
+        );
+
+      return res.status(200).send({ notification });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Update the given sms notification key.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  private updateSmsNotification = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const editDTO: IEditSmsNotificationDTO = this.matchedBodyData(req);
+
+    try {
+      await this.smsNotificationsSettings.editSmsNotificationMessage(
+        tenantId,
+        editDTO
+      );
+      return res.status(200).send({
+        message: 'Sms notification settings has been updated successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handleServiceErrors = (
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'SMS_NOTIFICATION_KEY_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'SMS_NOTIFICATION_KEY_NOT_FOUND', code: 1000 }],
+        });
+      }
+      if (error.errorType === 'UNSUPPORTED_SMS_MESSAGE_VARIABLES') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'UNSUPPORTED_SMS_MESSAGE_VARIABLES',
+              code: 1100,
+              data: { ...error.payload },
+            },
+          ],
+        });
+      }
+    }
+    next(error);
+  };
+}
diff --git a/packages/server/src/api/controllers/Settings/index.ts b/packages/server/src/api/controllers/Settings/index.ts
new file mode 100644
index 000000000..6a625bf76
--- /dev/null
+++ b/packages/server/src/api/controllers/Settings/index.ts
@@ -0,0 +1,23 @@
+import { Router } from 'express';
+import { Container, Service } from 'typedi';
+import SmsNotificationSettings from './SmsNotificationsSettings';
+import Settings from './Settings';
+import EasySmsIntegrationController from './EasySmsIntegration';
+import { AbilitySubject, PreferencesAction } from '@/interfaces';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+
+@Service()
+export default class SettingsController {
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.use('/', Container.get(EasySmsIntegrationController).router());
+    router.use('/', Container.get(SmsNotificationSettings).router());
+    router.use('/', Container.get(Settings).router());
+
+    return router;
+  }
+}
diff --git a/packages/server/src/api/controllers/Setup.ts b/packages/server/src/api/controllers/Setup.ts
new file mode 100644
index 000000000..256d0bc47
--- /dev/null
+++ b/packages/server/src/api/controllers/Setup.ts
@@ -0,0 +1,102 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, ValidationChain } from 'express-validator';
+import BaseController from './BaseController';
+import SetupService from '@/services/Setup/SetupService';
+import { Inject, Service } from 'typedi';
+import { IOrganizationSetupDTO } from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+// Middlewares
+import JWTAuth from '@/api/middleware/jwtAuth';
+import AttachCurrentTenantUser from '@/api/middleware/AttachCurrentTenantUser';
+import SubscriptionMiddleware from '@/api/middleware/SubscriptionMiddleware';
+import TenancyMiddleware from '@/api/middleware/TenancyMiddleware';
+import EnsureTenantIsInitialized from '@/api/middleware/EnsureTenantIsInitialized';
+import SettingsMiddleware from '@/api/middleware/SettingsMiddleware';
+
+@Service()
+export default class SetupController extends BaseController {
+  @Inject()
+  setupService: SetupService;
+
+  router() {
+    const router = Router('/setup');
+
+    router.use(JWTAuth);
+    router.use(AttachCurrentTenantUser);
+    router.use(TenancyMiddleware);
+    router.use(SubscriptionMiddleware('main'));
+    router.use(EnsureTenantIsInitialized);
+    router.use(SettingsMiddleware);
+    router.post(
+      '/organization',
+      this.organizationSetupSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.organizationSetup.bind(this)),
+      this.handleServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Organization setup schema.
+   */
+  private get organizationSetupSchema(): ValidationChain[] {
+    return [
+      check('organization_name').exists().trim(),
+      check('base_currency').exists(),
+      check('time_zone').exists(),
+      check('fiscal_year').exists(),
+      check('industry').optional(),
+    ];
+  }
+
+  /**
+   * Organization setup.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @returns
+   */
+  async organizationSetup(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const setupDTO: IOrganizationSetupDTO = this.matchedBodyData(req);
+
+    try {
+      await this.setupService.organizationSetup(tenantId, setupDTO);
+
+      return res.status(200).send({
+        message: 'The setup settings set successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  handleServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'TENANT_IS_ALREADY_SETUPED') {
+        return res.status(400).send({
+          errors: [{ type: 'TENANT_IS_ALREADY_SETUPED', code: 1000 }],
+        });
+      }
+      if (error.errorType === 'BASE_CURRENCY_INVALID') {
+        return res.status(400).send({
+          errors: [{ type: 'BASE_CURRENCY_INVALID', code: 110 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Subscription/Licenses.ts b/packages/server/src/api/controllers/Subscription/Licenses.ts
new file mode 100644
index 000000000..cf483f1a1
--- /dev/null
+++ b/packages/server/src/api/controllers/Subscription/Licenses.ts
@@ -0,0 +1,250 @@
+import { Service, Inject } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import { check, oneOf, ValidationChain } from 'express-validator';
+import basicAuth from 'express-basic-auth';
+import config from '@/config';
+import { License } from '@/system/models';
+import { ServiceError } from '@/exceptions';
+import BaseController from '@/api/controllers/BaseController';
+import LicenseService from '@/services/Payment/License';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import { ILicensesFilter, ISendLicenseDTO } from '@/interfaces';
+
+@Service()
+export default class LicensesController extends BaseController {
+  @Inject()
+  licenseService: LicenseService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.use(
+      basicAuth({
+        users: {
+          [config.licensesAuth.user]: config.licensesAuth.password,
+        },
+        challenge: true,
+      })
+    );
+    router.post(
+      '/generate',
+      this.generateLicenseSchema,
+      this.validationResult,
+      asyncMiddleware(this.generateLicense.bind(this)),
+      this.catchServiceErrors,
+    );
+    router.post(
+      '/disable/:licenseId',
+      this.validationResult,
+      asyncMiddleware(this.disableLicense.bind(this)),
+      this.catchServiceErrors,
+    );
+    router.post(
+      '/send',
+      this.sendLicenseSchemaValidation,
+      this.validationResult,
+      asyncMiddleware(this.sendLicense.bind(this)),
+      this.catchServiceErrors,
+    );
+    router.delete(
+      '/:licenseId',
+      asyncMiddleware(this.deleteLicense.bind(this)),
+      this.catchServiceErrors,
+    );
+    router.get('/', asyncMiddleware(this.listLicenses.bind(this)));
+    return router;
+  }
+
+  /**
+   * Generate license validation schema.
+   */
+  get generateLicenseSchema(): ValidationChain[] {
+    return [
+      check('loop').exists().isNumeric().toInt(),
+      check('period').exists().isNumeric().toInt(),
+      check('period_interval')
+        .exists()
+        .isIn(['month', 'months', 'year', 'years', 'day', 'days']),
+      check('plan_slug').exists().trim().escape(),
+    ];
+  }
+
+  /**
+   * Specific license validation schema.
+   */
+  get specificLicenseSchema(): ValidationChain[] {
+    return [
+      oneOf(
+        [check('license_id').exists().isNumeric().toInt()],
+        [check('license_code').exists().isNumeric().toInt()]
+      ),
+    ];
+  }
+
+  /**
+   * Send license validation schema.
+   */
+  get sendLicenseSchemaValidation(): ValidationChain[] {
+    return [
+      check('period').exists().isNumeric(),
+      check('period_interval').exists().trim().escape(),
+      check('plan_slug').exists().trim().escape(),
+      oneOf([
+        check('phone_number').exists().trim().escape(),
+        check('email').exists().trim().escape(),
+      ]),
+    ];
+  }
+
+  /**
+   * Generate licenses codes with given period in bulk.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async generateLicense(req: Request, res: Response, next: Function) {
+    const { loop = 10, period, periodInterval, planSlug } = this.matchedBodyData(
+      req
+    );
+
+    try {
+      await this.licenseService.generateLicenses(
+        loop,
+        period,
+        periodInterval,
+        planSlug
+      );
+      return res.status(200).send({
+        code: 100,
+        type: 'LICENSEES.GENERATED.SUCCESSFULLY',
+        message: 'The licenses have been generated successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Disable the given license on the storage.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async disableLicense(req: Request, res: Response, next: Function) {
+    const { licenseId } = req.params;
+
+    try {
+      await this.licenseService.disableLicense(licenseId);
+
+      return res.status(200).send({ license_id: licenseId });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Deletes the given license code on the storage.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async deleteLicense(req: Request, res: Response, next: Function) {
+    const { licenseId } = req.params;
+
+    try {
+      await this.licenseService.deleteLicense(licenseId);
+
+      return res.status(200).send({ license_id: licenseId });
+    } catch (error) {
+      next(error)
+    }
+  }
+
+  /**
+   * Send license code in the given period to the customer via email or phone number
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async sendLicense(req: Request, res: Response, next: Function) {
+    const sendLicenseDTO: ISendLicenseDTO = this.matchedBodyData(req);
+
+    try {
+      await this.licenseService.sendLicenseToCustomer(sendLicenseDTO);
+
+      return res.status(200).send({
+        status: 100,
+        code: 'LICENSE.CODE.SENT',
+        message: 'The license has been sent to the given customer.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Listing licenses.
+   * @param {Request} req
+   * @param {Response} res
+   */
+  async listLicenses(req: Request, res: Response) {
+    const filter: ILicensesFilter = {
+      disabled: false,
+      used: false,
+      sent: false,
+      active: false,
+      ...req.query,
+    };
+    const licenses = await License.query().onBuild((builder) => {
+      builder.modify('filter', filter);
+      builder.orderBy('createdAt', 'ASC');
+    });
+    return res.status(200).send({ licenses });
+  }
+
+  /**
+   * Catches all service errors.
+   */
+  catchServiceErrors(error, req: Request, res: Response, next: NextFunction) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'PLAN_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{
+            type: 'PLAN.NOT.FOUND',
+            code: 100,
+            message: 'The given plan not found.',
+        }],
+        });
+      }
+      if (error.errorType === 'LICENSE_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{
+            type: 'LICENSE_NOT_FOUND',
+            code: 200,
+            message: 'The given license id not found.'
+          }],
+        });
+      }
+      if (error.errorType === 'LICENSE_ALREADY_DISABLED') {
+        return res.status(400).send({
+          errors: [{
+            type: 'LICENSE.ALREADY.DISABLED',
+            code: 200, 
+            message: 'License is already disabled.'
+          }],
+        });
+      }
+      if (error.errorType === 'NO_AVALIABLE_LICENSE_CODE') {
+        return res.status(400).send({
+          status: 110,
+          message: 'There is no licenses availiable right now with the given period and plan.',
+          code: 'NO.AVALIABLE.LICENSE.CODE',
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Subscription/PaymentMethod.ts b/packages/server/src/api/controllers/Subscription/PaymentMethod.ts
new file mode 100644
index 000000000..2c954c307
--- /dev/null
+++ b/packages/server/src/api/controllers/Subscription/PaymentMethod.ts
@@ -0,0 +1,31 @@
+import { Inject } from 'typedi';
+import { Request, Response } from 'express';
+import { Plan } from '@/system/models';
+import BaseController from '@/api/controllers/BaseController';
+import SubscriptionService from '@/services/Subscription/SubscriptionService';
+
+export default class PaymentMethodController extends BaseController {
+  @Inject()
+  subscriptionService: SubscriptionService;
+
+  /**
+   * Validate the given plan slug exists on the storage.
+   * 
+   * @param {Request} req 
+   * @param {Response} res 
+   * @param {NextFunction} next
+   * 
+   * @return {Response|void}
+   */
+  async validatePlanSlugExistance(req: Request, res: Response, next: Function) {
+    const { planSlug } = this.matchedBodyData(req);
+    const foundPlan = await Plan.query().where('slug', planSlug).first();
+
+    if (!foundPlan) {
+      return res.status(400).send({
+        errors: [{ type: 'PLAN.SLUG.NOT.EXISTS', code: 110 }],
+      });
+    }
+    next();
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/api/controllers/Subscription/PaymentViaLicense.ts b/packages/server/src/api/controllers/Subscription/PaymentViaLicense.ts
new file mode 100644
index 000000000..7cf07c656
--- /dev/null
+++ b/packages/server/src/api/controllers/Subscription/PaymentViaLicense.ts
@@ -0,0 +1,125 @@
+import { Inject, Service } from 'typedi';
+import { NextFunction, Router, Request, Response } from 'express';
+import { check } from 'express-validator';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import PaymentMethodController from '@/api/controllers/Subscription/PaymentMethod';
+import {
+  NotAllowedChangeSubscriptionPlan,
+  NoPaymentModelWithPricedPlan,
+  PaymentAmountInvalidWithPlan,
+  PaymentInputInvalid,
+  VoucherCodeRequired,
+} from '@/exceptions';
+import { ILicensePaymentModel } from '@/interfaces';
+import instance from 'tsyringe/dist/typings/dependency-container';
+
+@Service()
+export default class PaymentViaLicenseController extends PaymentMethodController {
+  @Inject('logger')
+  logger: any;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/payment',
+      this.paymentViaLicenseSchema,
+      this.validationResult,
+      asyncMiddleware(this.validatePlanSlugExistance.bind(this)),
+      asyncMiddleware(this.paymentViaLicense.bind(this)),
+      this.handleErrors,
+    );
+    return router;
+  }
+
+  /**
+   * Payment via license validation schema.
+   */
+  get paymentViaLicenseSchema() {
+    return [
+      check('plan_slug').exists().trim().escape(),
+      check('license_code').exists().trim().escape(),
+    ];
+  }
+
+  /**
+   * Handle the subscription payment via license code.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  async paymentViaLicense(req: Request, res: Response, next: Function) {
+    const { planSlug, licenseCode } = this.matchedBodyData(req);
+    const { tenant } = req;
+
+    try {
+      const licenseModel: ILicensePaymentModel = { licenseCode };
+
+      await this.subscriptionService.subscriptionViaLicense(
+        tenant.id,
+        planSlug,
+        licenseModel
+      );
+
+      return res.status(200).send({
+        type: 'success',
+        code: 'PAYMENT.SUCCESSFULLY.MADE',
+        message: 'Payment via license has been made successfully.',
+      });
+    } catch (exception) {
+      next(exception);
+    }
+  }
+
+  /**
+   * Handle service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handleErrors(
+    exception: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const errorReasons = [];
+
+    if (exception instanceof VoucherCodeRequired) {
+      errorReasons.push({
+        type: 'VOUCHER_CODE_REQUIRED',
+        code: 100,
+      });
+    }
+    if (exception instanceof NoPaymentModelWithPricedPlan) {
+      errorReasons.push({
+        type: 'NO_PAYMENT_WITH_PRICED_PLAN',
+        code: 140,
+      });
+    }
+    if (exception instanceof NotAllowedChangeSubscriptionPlan) {
+      errorReasons.push({
+        type: 'NOT.ALLOWED.RENEW.SUBSCRIPTION.WHILE.ACTIVE',
+        code: 120,
+      });
+    }
+    if (errorReasons.length > 0) {
+      return res.status(400).send({ errors: errorReasons });
+    }
+    if (exception instanceof PaymentInputInvalid) {
+      return res.status(400).send({
+        errors: [{ type: 'LICENSE.CODE.IS.INVALID', code: 120 }],
+      });
+    }
+    if (exception instanceof PaymentAmountInvalidWithPlan) {
+      return res.status(400).send({
+        errors: [{ type: 'LICENSE.NOT.FOR.GIVEN.PLAN' }],
+      });
+    }
+    next(exception);
+  }
+}
diff --git a/packages/server/src/api/controllers/Subscription/index.ts b/packages/server/src/api/controllers/Subscription/index.ts
new file mode 100644
index 000000000..6145e7551
--- /dev/null
+++ b/packages/server/src/api/controllers/Subscription/index.ts
@@ -0,0 +1,49 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { Container, Service, Inject } from 'typedi';
+import JWTAuth from '@/api/middleware/jwtAuth';
+import TenancyMiddleware from '@/api/middleware/TenancyMiddleware';
+import AttachCurrentTenantUser from '@/api/middleware/AttachCurrentTenantUser';
+import PaymentViaLicenseController from '@/api/controllers/Subscription/PaymentViaLicense';
+import SubscriptionService from '@/services/Subscription/SubscriptionService';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+
+@Service()
+export default class SubscriptionController {
+  @Inject()
+  subscriptionService: SubscriptionService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.use(JWTAuth);
+    router.use(AttachCurrentTenantUser);
+    router.use(TenancyMiddleware);
+
+    router.use('/license', Container.get(PaymentViaLicenseController).router());
+    router.get('/', asyncMiddleware(this.getSubscriptions.bind(this)));
+
+    return router;
+  }
+
+  /**
+   * Retrieve all subscriptions of the authenticated user's tenant.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async getSubscriptions(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+
+    try {
+      const subscriptions = await this.subscriptionService.getSubscriptions(
+        tenantId
+      );
+      return res.status(200).send({ subscriptions });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
diff --git a/packages/server/src/api/controllers/TransactionsLocking/index.ts b/packages/server/src/api/controllers/TransactionsLocking/index.ts
new file mode 100644
index 000000000..300c4e81e
--- /dev/null
+++ b/packages/server/src/api/controllers/TransactionsLocking/index.ts
@@ -0,0 +1,284 @@
+import { Service, Inject } from 'typedi';
+import { Request, Response, Router, NextFunction } from 'express';
+import { check, param } from 'express-validator';
+import BaseController from '@/api/controllers/BaseController';
+import TransactionsLockingService from '@/services/TransactionsLocking/CommandTransactionsLockingService';
+import CheckPolicies from '@/api/middleware/CheckPolicies';
+import { AbilitySubject, AccountAction } from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import QueryTransactionsLocking from '@/services/TransactionsLocking/QueryTransactionsLocking';
+
+@Service()
+export default class TransactionsLockingController extends BaseController {
+  @Inject()
+  private transactionsLockingService: TransactionsLockingService;
+
+  @Inject()
+  private queryTransactionsLocking: QueryTransactionsLocking;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.put(
+      '/lock',
+      CheckPolicies(AccountAction.TransactionsLocking, AbilitySubject.Account),
+      [
+        check('module')
+          .exists()
+          .isIn(['all', 'sales', 'purchases', 'financial']),
+        check('lock_to_date').exists().isISO8601().toDate(),
+        check('reason').exists().trim(),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.commandTransactionsLocking),
+      this.handleServiceErrors
+    );
+    router.put(
+      '/cancel-lock',
+      CheckPolicies(AccountAction.TransactionsLocking, AbilitySubject.Account),
+      [check('module').exists(), check('reason').exists().trim()],
+      this.validationResult,
+      this.asyncMiddleware(this.cancelTransactionsLocking),
+      this.handleServiceErrors
+    );
+    router.put(
+      '/unlock-partial',
+      CheckPolicies(AccountAction.TransactionsLocking, AbilitySubject.Account),
+      [
+        check('module').exists(),
+        check('unlock_from_date').exists().isISO8601().toDate(),
+        check('unlock_to_date').exists().isISO8601().toDate(),
+        check('reason').exists().trim(),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.unlockTransactionsLockingBetweenPeriod),
+      this.handleServiceErrors
+    );
+    router.put(
+      '/cancel-unlock-partial',
+      CheckPolicies(AccountAction.TransactionsLocking, AbilitySubject.Account),
+      [
+        check('module').exists(),
+        check('reason').optional({ nullable: true }).trim(),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.cancelPartialUnlocking),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/',
+      this.validationResult,
+      this.asyncMiddleware(this.getTransactionLockingMetaList),
+      this.handleServiceErrors
+    );
+    router.get(
+      '/:module',
+      [param('module').exists()],
+      this.validationResult,
+      this.asyncMiddleware(this.getTransactionLockingMeta),
+      this.handleServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Retrieve accounts types list.
+   * @param {Request} req - Request.
+   * @param {Response} res - Response.
+   * @return {Response}
+   */
+  private commandTransactionsLocking = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { module, ...allTransactionsDTO } = this.matchedBodyData(req);
+
+    try {
+      const transactionMeta =
+        await this.transactionsLockingService.commandTransactionsLocking(
+          tenantId,
+          module,
+          allTransactionsDTO
+        );
+      return res.status(200).send({
+        message: 'All transactions locking has been submit successfully.',
+        data: transactionMeta,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Unlock transactions locking between the given periods.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private unlockTransactionsLockingBetweenPeriod = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { module, ...unlockDTO } = this.matchedBodyData(req);
+
+    try {
+      const transactionMeta =
+        await this.transactionsLockingService.unlockTransactionsLockingPartially(
+          tenantId,
+          module,
+          unlockDTO
+        );
+      return res.status(200).send({
+        message:
+          'Transactions locking haas been unlocked partially successfully.',
+        data: transactionMeta,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Cancel full transactions locking of the given module.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private cancelTransactionsLocking = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { module, ...cancelLockingDTO } = this.matchedBodyData(req);
+
+    try {
+      const data =
+        await this.transactionsLockingService.cancelTransactionLocking(
+          tenantId,
+          module,
+          cancelLockingDTO
+        );
+      return res.status(200).send({
+        message: 'Transactions locking has been canceled successfully.',
+        data,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Cancel transaction partial unlocking.
+   * @param req
+   * @param res
+   * @param next
+   * @returns
+   */
+  private cancelPartialUnlocking = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { module } = this.matchedBodyData(req);
+
+    try {
+      const transactionMeta =
+        await this.transactionsLockingService.cancelPartialTransactionsUnlock(
+          tenantId,
+          module
+        );
+      return res.status(200).send({
+        message:
+          'Partial transaction unlocking has been canceled successfully.',
+        data: transactionMeta,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  private getTransactionLockingMeta = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { module } = req.params;
+    const { tenantId } = req;
+
+    try {
+      const data =
+        await this.queryTransactionsLocking.getTransactionsLockingModuleMeta(
+          tenantId,
+          module
+        );
+      return res.status(200).send({ data });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieve transactions locking meta list.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private getTransactionLockingMetaList = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { module } = req.params;
+    const { tenantId } = req;
+
+    try {
+      const data =
+        await this.queryTransactionsLocking.getTransactionsLockingList(
+          tenantId
+        );
+
+      return res.status(200).send({ data });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handle the service errors.
+   * @param {Error} error -
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {NextFunction} next -
+   */
+  private handleServiceErrors = (
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'TRANSACTION_LOCKING_ALL') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'TRANSACTION_LOCKING_ALL', code: 100 }],
+        });
+      }
+      if (error.errorType === 'TRANSACTIONS_LOCKING_MODULE_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [
+            { type: 'TRANSACTIONS_LOCKING_MODULE_NOT_FOUND', code: 100 },
+          ],
+        });
+      }
+    }
+    next(error);
+  };
+}
diff --git a/packages/server/src/api/controllers/TransactionsLocking/utils.ts b/packages/server/src/api/controllers/TransactionsLocking/utils.ts
new file mode 100644
index 000000000..5f518daed
--- /dev/null
+++ b/packages/server/src/api/controllers/TransactionsLocking/utils.ts
@@ -0,0 +1,24 @@
+import { chain, mapKeys } from 'lodash';
+
+export const getTransactionsLockingSettingsSchema = (modules: string[]) => {
+  const moduleSchema = {
+    active: { type: 'boolean' },
+    lock_to_date: { type: 'date' },
+    unlock_from_date: { type: 'date' },
+    unlock_to_date: { type: 'date' },
+    lock_reason: { type: 'string' },
+    unlock_reason: { type: 'string' },
+  };
+  return chain(modules)
+    .map((module: string) => {
+      return mapKeys(moduleSchema, (value, key: string) => `${module}.${key}`);
+    })
+    .flattenDeep()
+    .reduce((result, value) => {
+      return {
+        ...result,
+        ...value,
+      };
+    }, {})
+    .value();
+};
diff --git a/packages/server/src/api/controllers/Users.ts b/packages/server/src/api/controllers/Users.ts
new file mode 100644
index 000000000..543a7080d
--- /dev/null
+++ b/packages/server/src/api/controllers/Users.ts
@@ -0,0 +1,289 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { Service, Inject } from 'typedi';
+import { check, query, param } from 'express-validator';
+import JWTAuth from '@/api/middleware/jwtAuth';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import BaseController from '@/api/controllers/BaseController';
+import UsersService from '@/services/Users/UsersService';
+import TenancyMiddleware from '@/api/middleware/TenancyMiddleware';
+import AttachCurrentTenantUser from '@/api/middleware/AttachCurrentTenantUser';
+import { ServiceError, ServiceErrors } from '@/exceptions';
+import { IEditUserDTO, ISystemUserDTO } from '@/interfaces';
+
+@Service()
+export default class UsersController extends BaseController {
+  @Inject()
+  usersService: UsersService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.use(JWTAuth);
+    router.use(AttachCurrentTenantUser);
+    router.use(TenancyMiddleware);
+
+    router.put(
+      '/:id/inactivate',
+      [...this.specificUserSchema],
+      this.validationResult,
+      asyncMiddleware(this.inactivateUser.bind(this)),
+      this.catchServiceErrors
+    );
+    router.put(
+      '/:id/activate',
+      [...this.specificUserSchema],
+      this.validationResult,
+      asyncMiddleware(this.activateUser.bind(this)),
+      this.catchServiceErrors
+    );
+    router.post(
+      '/:id',
+      [
+        param('id').exists().isNumeric().toInt(),
+
+        check('first_name').exists(),
+        check('last_name').exists(),
+        check('email').exists().isEmail(),
+        check('phone_number').optional().isMobilePhone(),
+        check('role_id').exists().isNumeric().toInt(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.editUser.bind(this)),
+      this.catchServiceErrors
+    );
+    router.get(
+      '/',
+      this.listUsersSchema,
+      this.validationResult,
+      asyncMiddleware(this.listUsers.bind(this))
+    );
+    router.get(
+      '/:id',
+      [...this.specificUserSchema],
+      this.validationResult,
+      asyncMiddleware(this.getUser.bind(this)),
+      this.catchServiceErrors
+    );
+    router.delete(
+      '/:id',
+      [...this.specificUserSchema],
+      this.validationResult,
+      asyncMiddleware(this.deleteUser.bind(this)),
+      this.catchServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * User DTO Schema.
+   */
+  get userDTOSchema() {
+    return [];
+  }
+
+  get specificUserSchema() {
+    return [param('id').exists().isNumeric().toInt()];
+  }
+
+  get listUsersSchema() {
+    return [
+      query('page_size').optional().isNumeric().toInt(),
+      query('page').optional().isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Edit details of the given user.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response|void}
+   */
+  async editUser(req: Request, res: Response, next: NextFunction) {
+    const editUserDTO: IEditUserDTO = this.matchedBodyData(req);
+    const { tenantId, user: authorizedUser } = req;
+    const { id: userId } = req.params;
+
+    try {
+      await this.usersService.editUser(
+        tenantId,
+        userId,
+        editUserDTO,
+        authorizedUser
+      );
+      return res.status(200).send({
+        id: userId,
+        message: 'The user has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Soft deleting the given user.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response|void}
+   */
+  async deleteUser(req: Request, res: Response, next: Function) {
+    const { id } = req.params;
+    const { tenantId } = req;
+
+    try {
+      await this.usersService.deleteUser(tenantId, id);
+
+      return res.status(200).send({
+        id,
+        message: 'The user has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve user details of the given user id.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response|void}
+   */
+  async getUser(req: Request, res: Response, next: NextFunction) {
+    const { id: userId } = req.params;
+    const { tenantId } = req;
+
+    try {
+      const user = await this.usersService.getUser(tenantId, userId);
+      return res.status(200).send({ user });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieve the list of users.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response|void}
+   */
+  async listUsers(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    try {
+      const users = await this.usersService.getList(tenantId);
+
+      return res.status(200).send({ users });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Activate the given user.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  async activateUser(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const { id: userId } = req.params;
+
+    try {
+      await this.usersService.activateUser(tenantId, userId, user);
+
+      return res.status(200).send({
+        id: userId,
+        message: 'The user has been activated successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Inactivate the given user.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response|void}
+   */
+  async inactivateUser(req: Request, res: Response, next: NextFunction) {
+    const { tenantId, user } = req;
+    const { id: userId } = req.params;
+
+    try {
+      await this.usersService.inactivateUser(tenantId, userId, user);
+
+      return res.status(200).send({
+        id: userId,
+        message: 'The user has been inactivated successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Catches all users service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  catchServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'USER_NOT_FOUND') {
+        return res.boom.badRequest('User not found.', {
+          errors: [{ type: 'USER.NOT.FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'USER_ALREADY_ACTIVE') {
+        return res.boom.badRequest('User is already active.', {
+          errors: [{ type: 'USER.ALREADY.ACTIVE', code: 200 }],
+        });
+      }
+      if (error.errorType === 'USER_ALREADY_INACTIVE') {
+        return res.boom.badRequest('User is already inactive.', {
+          errors: [{ type: 'USER.ALREADY.INACTIVE', code: 200 }],
+        });
+      }
+      if (error.errorType === 'USER_SAME_THE_AUTHORIZED_USER') {
+        return res.boom.badRequest(
+          'You could not activate/inactivate the same authorized user.',
+          {
+            errors: [
+              { type: 'CANNOT.TOGGLE.ACTIVATE.AUTHORIZED.USER', code: 300 },
+            ],
+          }
+        );
+      }
+      if (error.errorType === 'CANNOT_DELETE_LAST_USER') {
+        return res.boom.badRequest(
+          'Cannot delete last user in the organization.',
+          { errors: [{ type: 'CANNOT_DELETE_LAST_USER', code: 400 }] }
+        );
+      }
+      if (error.errorType === 'EMAIL_ALREADY_EXISTS') {
+        return res.boom.badRequest('Exmail is already exists.', {
+          errors: [{ type: 'EMAIL_ALREADY_EXISTS', code: 500 }],
+        });
+      }
+      if (error.errorType === 'PHONE_NUMBER_ALREADY_EXIST') {
+        return res.boom.badRequest('Phone number is already exists.', {
+          errors: [{ type: 'PHONE_NUMBER_ALREADY_EXIST', code: 600 }],
+        });
+      }
+      if (error.errorType === 'CANNOT_AUTHORIZED_USER_MUTATE_ROLE') {
+        return res.boom.badRequest('Cannout mutate authorized user role.', {
+          errors: [{ type: 'CANNOT_AUTHORIZED_USER_MUTATE_ROLE', code: 700 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Views.ts b/packages/server/src/api/controllers/Views.ts
new file mode 100644
index 000000000..91c62e76a
--- /dev/null
+++ b/packages/server/src/api/controllers/Views.ts
@@ -0,0 +1,123 @@
+import { Inject, Service } from 'typedi';
+import { Router, Request, NextFunction, Response } from 'express';
+import { check, param } from 'express-validator';
+import asyncMiddleware from '@/api/middleware/asyncMiddleware';
+import ViewsService from '@/services/Views/ViewsService';
+import BaseController from '@/api/controllers/BaseController';
+import { IViewDTO, IViewEditDTO } from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+
+@Service()
+export default class ViewsController extends BaseController {
+  @Inject()
+  viewsService: ViewsService;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.get(
+      '/resource/:resource_model',
+      [...this.viewsListSchemaValidation],
+      this.validationResult,
+      asyncMiddleware(this.listResourceViews.bind(this)),
+      this.handlerServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Custom views list validation schema.
+   */
+  get viewsListSchemaValidation() {
+    return [param('resource_model').exists().trim().escape()];
+  }
+
+  /**
+   * List all views that associated with the given resource.
+   * @param {Request} req - Request object.
+   * @param {Response} res - Response object.
+   * @param {NextFunction} next  - Next function.
+   */
+  async listResourceViews(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const { resource_model: resourceModel } = req.params;
+
+    try {
+      const views = await this.viewsService.listResourceViews(
+        tenantId,
+        resourceModel
+      );
+      return res.status(200).send({
+        views: this.transfromToResponse(views, ['name', 'columns.label'], req),
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  handlerServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'VIEW_NAME_NOT_UNIQUE') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'VIEW_NAME_NOT_UNIQUE', code: 110 }],
+        });
+      }
+      if (error.errorType === 'RESOURCE_MODEL_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'RESOURCE_MODEL_NOT_FOUND', code: 150 }],
+        });
+      }
+      if (error.errorType === 'INVALID_LOGIC_EXPRESSION') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'VIEW.ROLES.LOGIC.EXPRESSION.INVALID', code: 400 }],
+        });
+      }
+      if (error.errorType === '') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'RESOURCE_FIELDS_NOT_EXIST', code: 100 }],
+        });
+      }
+      if (error.errorType === '') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'COLUMNS_NOT_EXIST', code: 200 }],
+        });
+      }
+      if (error.errorType === 'VIEW_NOT_FOUND') {
+        return res.boom.notFound(null, {
+          errors: [{ type: 'VIEW_NOT_FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'VIEW_PREDEFINED') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'PREDEFINED_VIEW', code: 200 }],
+        });
+      }
+      if (error.errorType === 'RESOURCE_FIELDS_KEYS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'RESOURCE_FIELDS_KEYS_NOT_FOUND', code: 300 }],
+        });
+      }
+      if (error.errorType === 'RESOURCE_COLUMNS_KEYS_NOT_FOUND') {
+        return res.boom.badRequest(null, {
+          errors: [{ type: 'RESOURCE_COLUMNS_KEYS_NOT_FOUND', code: 310 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Warehouses/WarehouseTransfers.ts b/packages/server/src/api/controllers/Warehouses/WarehouseTransfers.ts
new file mode 100644
index 000000000..de7385786
--- /dev/null
+++ b/packages/server/src/api/controllers/Warehouses/WarehouseTransfers.ts
@@ -0,0 +1,407 @@
+import { Service, Inject } from 'typedi';
+import { Request, Response, Router, NextFunction } from 'express';
+import { query, check, param } from 'express-validator';
+import BaseController from '@/api/controllers/BaseController';
+import { WarehouseTransferApplication } from '@/services/Warehouses/WarehousesTransfers/WarehouseTransferApplication';
+import {
+  Features,
+  ICreateWarehouseTransferDTO,
+  IEditWarehouseTransferDTO,
+} from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import { FeatureActivationGuard } from '@/api/middleware/FeatureActivationGuard';
+
+@Service()
+export class WarehousesTransfers extends BaseController {
+  @Inject()
+  private warehouseTransferApplication: WarehouseTransferApplication;
+
+  /**
+   *
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/',
+      FeatureActivationGuard(Features.WAREHOUSES),
+      [
+        check('from_warehouse_id').exists().isInt().toInt(),
+        check('to_warehouse_id').exists().isInt().toInt(),
+
+        check('date').exists().isISO8601(),
+        check('transaction_number').optional(),
+
+        check('transfer_initiated').default(false).isBoolean().toBoolean(),
+        check('transfer_delivered').default(false).isBoolean().toBoolean(),
+
+        check('entries').exists().isArray({ min: 1 }),
+        check('entries.*.index').exists(),
+        check('entries.*.item_id').exists(),
+        check('entries.*.description').optional(),
+        check('entries.*.quantity').exists().isInt().toInt(),
+        check('entries.*.cost').optional().isDecimal().toFloat(),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.createWarehouseTransfer),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/:id',
+      FeatureActivationGuard(Features.WAREHOUSES),
+      [
+        param('id').exists().isInt().toInt(),
+
+        check('from_warehouse_id').exists().isInt().toInt(),
+        check('to_warehouse_id').exists().isInt().toInt(),
+
+        check('date').exists().isISO8601(),
+        check('transaction_number').optional(),
+
+        check('transfer_initiated').default(false).isBoolean().toBoolean(),
+        check('transfer_delivered').default(false).isBoolean().toBoolean(),
+
+        check('entries').exists().isArray({ min: 1 }),
+        check('entries.*.id').optional().isInt().toInt(),
+        check('entries.*.index').exists(),
+        check('entries.*.item_id').exists().isInt().toInt(),
+        check('entries.*.description').optional(),
+        check('entries.*.quantity').exists().isInt({ min: 1 }).toInt(),
+        check('entries.*.cost').optional().isDecimal().toFloat(),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.editWarehouseTransfer),
+      this.handlerServiceErrors
+    );
+    router.put(
+      '/:id/initiate',
+      FeatureActivationGuard(Features.WAREHOUSES),
+      [param('id').exists().isInt().toInt()],
+      this.asyncMiddleware(this.initiateTransfer),
+      this.handlerServiceErrors
+    );
+    router.put(
+      '/:id/transferred',
+      FeatureActivationGuard(Features.WAREHOUSES),
+      [param('id').exists().isInt().toInt()],
+      this.asyncMiddleware(this.deliverTransfer),
+      this.handlerServiceErrors
+    );
+    router.get(
+      '/',
+      FeatureActivationGuard(Features.WAREHOUSES),
+      [
+        query('view_slug').optional({ nullable: true }).isString().trim(),
+
+        query('stringified_filter_roles').optional().isJSON(),
+        query('column_sort_by').optional(),
+        query('sort_order').optional().isIn(['desc', 'asc']),
+
+        query('page').optional().isNumeric().toInt(),
+        query('page_size').optional().isNumeric().toInt(),
+
+        query('search_keyword').optional({ nullable: true }).isString().trim(),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.getWarehousesTransfers),
+      this.handlerServiceErrors
+    );
+    router.get(
+      '/:id',
+      [param('id').exists().isInt().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.getWarehouseTransfer),
+      this.handlerServiceErrors
+    );
+    router.delete(
+      '/:id',
+      FeatureActivationGuard(Features.WAREHOUSES),
+      [param('id').exists().isInt().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.deleteWarehouseTransfer),
+      this.handlerServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Creates a new warehouse transfer transaction.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  private createWarehouseTransfer = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const createWareouseTransfer: ICreateWarehouseTransferDTO =
+      this.matchedBodyData(req);
+
+    try {
+      const warehouse =
+        await this.warehouseTransferApplication.createWarehouseTransfer(
+          tenantId,
+          createWareouseTransfer
+        );
+      return res.status(200).send({
+        id: warehouse.id,
+        message:
+          'The warehouse transfer transaction has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Edits warehouse transfer transaction.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  private editWarehouseTransfer = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: warehouseTransferId } = req.params;
+    const editWarehouseTransferDTO: IEditWarehouseTransferDTO =
+      this.matchedBodyData(req);
+
+    try {
+      const warehouseTransfer =
+        await this.warehouseTransferApplication.editWarehouseTransfer(
+          tenantId,
+          warehouseTransferId,
+          editWarehouseTransferDTO
+        );
+      return res.status(200).send({
+        id: warehouseTransfer.id,
+        message:
+          'The warehouse transfer transaction has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Deletes the given warehouse transfer transaction.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  private deleteWarehouseTransfer = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: warehouseTransferId } = req.params;
+
+    try {
+      await this.warehouseTransferApplication.deleteWarehouseTransfer(
+        tenantId,
+        warehouseTransferId
+      );
+      return res.status(200).send({
+        message:
+          'The warehouse transfer transaction has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieves warehouse transfer transaction details.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  private getWarehouseTransfer = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: warehouseTransferId } = req.params;
+
+    try {
+      const warehouseTransfer =
+        await this.warehouseTransferApplication.getWarehouseTransfer(
+          tenantId,
+          warehouseTransferId
+        );
+      return res.status(200).send({ data: warehouseTransfer });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieves specific warehouse transfer transaction.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  private getWarehousesTransfers = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const filterDTO = {
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      page: 1,
+      pageSize: 12,
+      ...this.matchedQueryData(req),
+    };
+    try {
+      const { warehousesTransfers, pagination, filter } =
+        await this.warehouseTransferApplication.getWarehousesTransfers(
+          tenantId,
+          filterDTO
+        );
+
+      return res.status(200).send({
+        data: warehousesTransfers,
+        pagination,
+        filter,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Initiates the warehouse transfer.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  private initiateTransfer = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: warehouseTransferId } = req.params;
+
+    try {
+      await this.warehouseTransferApplication.initiateWarehouseTransfer(
+        tenantId,
+        warehouseTransferId
+      );
+      return res.status(200).send({
+        id: warehouseTransferId,
+        message: 'The given warehouse transfer has been initialized.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * marks the given warehouse transfer as transferred.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  private deliverTransfer = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: warehouseTransferId } = req.params;
+
+    try {
+      await this.warehouseTransferApplication.transferredWarehouseTransfer(
+        tenantId,
+        warehouseTransferId
+      );
+      return res.status(200).send({
+        id: warehouseTransferId,
+        message: 'The given warehouse transfer has been delivered.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handlerServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'WAREHOUSES_TRANSFER_SHOULD_NOT_BE_SAME') {
+        return res.status(400).send({
+          errors: [
+            { type: 'WAREHOUSES_TRANSFER_SHOULD_NOT_BE_SAME', code: 100 },
+          ],
+        });
+      }
+      if (error.errorType === 'FROM_WAREHOUSE_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'FROM_WAREHOUSE_NOT_FOUND', code: 200 }],
+        });
+      }
+      if (error.errorType === 'TO_WAREHOUSE_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'TO_WAREHOUSE_NOT_FOUND', code: 300 }],
+        });
+      }
+      if (error.errorType === 'ITEMS_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'ITEMS_NOT_FOUND', code: 400 }],
+        });
+      }
+      if (error.errorType === 'WAREHOUSE_TRANSFER_ITEMS_SHOULD_BE_INVENTORY') {
+        return res.status(400).send({
+          errors: [
+            { type: 'WAREHOUSE_TRANSFER_ITEMS_SHOULD_BE_INVENTORY', code: 500 },
+          ],
+        });
+      }
+      if (error.errorType === 'WAREHOUSE_TRANSFER_ALREADY_TRANSFERRED') {
+        return res.status(400).send({
+          errors: [
+            { type: 'WAREHOUSE_TRANSFER_ALREADY_TRANSFERRED', code: 600 },
+          ],
+        });
+      }
+      if (error.errorType === 'WAREHOUSE_TRANSFER_ALREADY_INITIATED') {
+        return res.status(400).send({
+          errors: [{ type: 'WAREHOUSE_TRANSFER_ALREADY_INITIATED', code: 700 }],
+        });
+      }
+      if (error.errorType === 'WAREHOUSE_TRANSFER_NOT_INITIATED') {
+        return res.status(400).send({
+          errors: [{ type: 'WAREHOUSE_TRANSFER_NOT_INITIATED', code: 800 }],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/controllers/Warehouses/WarehousesItem.ts b/packages/server/src/api/controllers/Warehouses/WarehousesItem.ts
new file mode 100644
index 000000000..73aded86c
--- /dev/null
+++ b/packages/server/src/api/controllers/Warehouses/WarehousesItem.ts
@@ -0,0 +1,47 @@
+import { Service, Inject } from 'typedi';
+import { Router, Request, Response, NextFunction } from 'express';
+import { param } from 'express-validator';
+
+import { Features } from '@/interfaces';
+import BaseController from '@/api/controllers/BaseController';
+import { FeatureActivationGuard } from '@/api/middleware/FeatureActivationGuard';
+import { WarehousesApplication } from '@/services/Warehouses/WarehousesApplication';
+
+@Service()
+export class WarehousesItemController extends BaseController {
+  @Inject()
+  warehousesApplication: WarehousesApplication;
+
+  router() {
+    const router = Router();
+
+    router.get(
+      '/items/:id/warehouses',
+      FeatureActivationGuard(Features.WAREHOUSES),
+      [param('id').exists().isInt().toInt()],
+      this.validationResult,
+      this.getItemWarehouses
+    );
+    return router;
+  }
+
+  getItemWarehouses = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: warehouseId } = req.params;
+
+    try {
+      const itemWarehouses = await this.warehousesApplication.getItemWarehouses(
+        tenantId,
+        warehouseId
+      );
+
+      return res.status(200).send({ itemWarehouses });
+    } catch (error) {
+      next(error);
+    }
+  };
+}
diff --git a/packages/server/src/api/controllers/Warehouses/index.ts b/packages/server/src/api/controllers/Warehouses/index.ts
new file mode 100644
index 000000000..0d61f80bc
--- /dev/null
+++ b/packages/server/src/api/controllers/Warehouses/index.ts
@@ -0,0 +1,337 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import { Request, Response, Router, NextFunction } from 'express';
+import { check, param } from 'express-validator';
+import BaseController from '@/api/controllers/BaseController';
+import { WarehousesApplication } from '@/services/Warehouses/WarehousesApplication';
+import { Features, ICreateWarehouseDTO, IEditWarehouseDTO } from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import { FeatureActivationGuard } from '@/api/middleware/FeatureActivationGuard';
+
+@Service()
+export class WarehousesController extends BaseController {
+  @Inject()
+  private warehouseApplication: WarehousesApplication;
+
+  /**
+   *
+   * @returns
+   */
+  router() {
+    const router = Router();
+
+    router.post(
+      '/activate',
+      [],
+      this.validationResult,
+      this.asyncMiddleware(this.activateWarehouses),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/',
+      FeatureActivationGuard(Features.WAREHOUSES),
+      [
+        check('name').exists(),
+        check('code').optional({ nullable: true }),
+
+        check('address').optional({ nullable: true }),
+        check('city').optional({ nullable: true }),
+        check('country').optional({ nullable: true }),
+
+        check('phone_number').optional({ nullable: true }),
+        check('email').optional({ nullable: true }).isEmail(),
+        check('website').optional({ nullable: true }).isURL(),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.createWarehouse),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/:id',
+      FeatureActivationGuard(Features.WAREHOUSES),
+      [
+        check('id').exists().isInt().toInt(),
+        check('name').exists(),
+        check('code').optional({ nullable: true }),
+
+        check('address').optional({ nullable: true }),
+        check('city').optional({ nullable: true }),
+        check('country').optional({ nullable: true }),
+
+        check('phone_number').optional({ nullable: true }),
+        check('email').optional({ nullable: true }).isEmail(),
+        check('website').optional({ nullable: true }).isURL(),
+      ],
+      this.validationResult,
+      this.asyncMiddleware(this.editWarehouse),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/:id/mark-primary',
+      FeatureActivationGuard(Features.WAREHOUSES),
+      [check('id').exists().isInt().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.markPrimaryWarehouse)
+    );
+    router.delete(
+      '/:id',
+      FeatureActivationGuard(Features.WAREHOUSES),
+      [param('id').exists().isInt().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.deleteWarehouse),
+      this.handlerServiceErrors
+    );
+    router.get(
+      '/:id',
+      FeatureActivationGuard(Features.WAREHOUSES),
+      [param('id').exists().isInt().toInt()],
+      this.validationResult,
+      this.asyncMiddleware(this.getWarehouse),
+      this.handlerServiceErrors
+    );
+    router.get(
+      '/',
+      FeatureActivationGuard(Features.WAREHOUSES),
+      [],
+      this.validationResult,
+      this.asyncMiddleware(this.getWarehouses),
+      this.handlerServiceErrors
+    );
+    return router;
+  }
+
+  /**
+   * Creates a new warehouse.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  public createWarehouse = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const createWarehouseDTO: ICreateWarehouseDTO = this.matchedBodyData(req);
+
+    try {
+      const warehouse = await this.warehouseApplication.createWarehouse(
+        tenantId,
+        createWarehouseDTO
+      );
+      return res.status(200).send({
+        id: warehouse.id,
+        message: 'The warehouse has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Deletes the given warehouse.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  public editWarehouse = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: warehouseId } = req.params;
+    const editWarehouseDTO: IEditWarehouseDTO = this.matchedBodyData(req);
+
+    try {
+      const warehouse = await this.warehouseApplication.editWarehouse(
+        tenantId,
+        warehouseId,
+        editWarehouseDTO
+      );
+
+      return res.status(200).send({
+        id: warehouse.id,
+        message: 'The warehouse has been edited successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   *
+   * @param req
+   * @param res
+   * @param next
+   * @returns
+   */
+  public deleteWarehouse = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: warehouseId } = req.params;
+
+    try {
+      await this.warehouseApplication.deleteWarehouse(tenantId, warehouseId);
+
+      return res.status(200).send({
+        message: 'The warehouse has been deleted successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+  /**
+   * Retrieves specific warehouse.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  public getWarehouse = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: warehouseId } = req.params;
+
+    try {
+      const warehouse = await this.warehouseApplication.getWarehouse(
+        tenantId,
+        warehouseId
+      );
+      return res.status(200).send({ warehouse });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieves warehouses list.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  public getWarehouses = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+
+    try {
+      const warehouses = await this.warehouseApplication.getWarehouses(
+        tenantId
+      );
+      return res.status(200).send({ warehouses });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Activates multi-warehouses feature.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  public activateWarehouses = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+
+    try {
+      await this.warehouseApplication.activateWarehouses(tenantId);
+
+      return res.status(200).send({
+        message: 'The multi-warehouses has been activated successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Marks the given warehouse as primary.
+   * @param   {Request} req
+   * @param   {Response} res
+   * @param   {NextFunction} next
+   * @returns {Response}
+   */
+  public markPrimaryWarehouse = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: warehouseId } = req.params;
+
+    try {
+      const warehouse = await this.warehouseApplication.markWarehousePrimary(
+        tenantId,
+        warehouseId
+      );
+      return res.status(200).send({
+        id: warehouse.id,
+        message: 'The given warehouse has been marked as primary.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Handles service errors.
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private handlerServiceErrors(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'WAREHOUSE_NOT_FOUND') {
+        return res.status(400).send({
+          errors: [{ type: 'WAREHOUSE_NOT_FOUND', code: 100 }],
+        });
+      }
+      if (error.errorType === 'MUTLI_WAREHOUSES_ALREADY_ACTIVATED') {
+        return res.status(400).send({
+          errors: [{ type: 'MUTLI_WAREHOUSES_ALREADY_ACTIVATED', code: 200 }],
+        });
+      }
+      if (error.errorType === 'COULD_NOT_DELETE_ONLY_WAERHOUSE') {
+        return res.status(400).send({
+          errors: [{ type: 'COULD_NOT_DELETE_ONLY_WAERHOUSE', code: 300 }],
+        });
+      }
+      if (error.errorType === 'WAREHOUSE_CODE_NOT_UNIQUE') {
+        return res.status(400).send({
+          errors: [{ type: 'WAREHOUSE_CODE_NOT_UNIQUE', code: 400 }],
+        });
+      }
+      if (error.errorType === 'WAREHOUSE_HAS_ASSOCIATED_TRANSACTIONS') {
+        return res.status(400).send({
+          errors: [
+            { type: 'WAREHOUSE_HAS_ASSOCIATED_TRANSACTIONS', code: 500 },
+          ],
+        });
+      }
+    }
+    next(error);
+  }
+}
diff --git a/packages/server/src/api/index.ts b/packages/server/src/api/index.ts
new file mode 100644
index 000000000..2eb04ec64
--- /dev/null
+++ b/packages/server/src/api/index.ts
@@ -0,0 +1,151 @@
+import { Router } from 'express';
+import { Container } from 'typedi';
+
+// Middlewares
+import JWTAuth from '@/api/middleware/jwtAuth';
+import AttachCurrentTenantUser from '@/api/middleware/AttachCurrentTenantUser';
+import SubscriptionMiddleware from '@/api/middleware/SubscriptionMiddleware';
+import TenancyMiddleware from '@/api/middleware/TenancyMiddleware';
+import EnsureTenantIsInitialized from '@/api/middleware/EnsureTenantIsInitialized';
+import SettingsMiddleware from '@/api/middleware/SettingsMiddleware';
+import I18nMiddleware from '@/api/middleware/I18nMiddleware';
+import I18nAuthenticatedMiddlware from '@/api/middleware/I18nAuthenticatedMiddlware';
+import EnsureTenantIsSeeded from '@/api/middleware/EnsureTenantIsSeeded';
+
+// Routes
+import Authentication from '@/api/controllers/Authentication';
+import InviteUsers from '@/api/controllers/InviteUsers';
+import Organization from '@/api/controllers/Organization';
+import Account from '@/api/controllers/Account';
+import Users from '@/api/controllers/Users';
+import Items from '@/api/controllers/Items';
+import ItemCategories from '@/api/controllers/ItemCategories';
+import Accounts from '@/api/controllers/Accounts';
+import AccountTypes from '@/api/controllers/AccountTypes';
+import Views from '@/api/controllers/Views';
+import ManualJournals from '@/api/controllers/ManualJournals';
+import FinancialStatements from '@/api/controllers/FinancialStatements';
+import Expenses from '@/api/controllers/Expenses';
+import Settings from '@/api/controllers/Settings';
+import Currencies from '@/api/controllers/Currencies';
+import Contacts from '@/api/controllers/Contacts/Contacts';
+import Customers from '@/api/controllers/Contacts/Customers';
+import Vendors from '@/api/controllers/Contacts/Vendors';
+import Sales from '@/api/controllers/Sales';
+import Purchases from '@/api/controllers/Purchases';
+import Resources from './controllers/Resources';
+import ExchangeRates from '@/api/controllers/ExchangeRates';
+import Media from '@/api/controllers/Media';
+import Ping from '@/api/controllers/Ping';
+import Subscription from '@/api/controllers/Subscription';
+import Licenses from '@/api/controllers/Subscription/Licenses';
+import InventoryAdjustments from '@/api/controllers/Inventory/InventoryAdjustments';
+import asyncRenderMiddleware from './middleware/AsyncRenderMiddleware';
+import Jobs from './controllers/Jobs';
+import Miscellaneous from '@/api/controllers/Miscellaneous';
+import OrganizationDashboard from '@/api/controllers/OrganizationDashboard';
+import CashflowController from './controllers/Cashflow/CashflowController';
+import AuthorizationMiddleware from './middleware/AuthorizationMiddleware';
+import RolesController from './controllers/Roles';
+import TransactionsLocking from './controllers/TransactionsLocking';
+import DashboardController from './controllers/Dashboard';
+import { BranchesController } from './controllers/Branches';
+import { WarehousesController } from './controllers/Warehouses';
+import { WarehousesTransfers } from './controllers/Warehouses/WarehouseTransfers';
+import { WarehousesItemController } from './controllers/Warehouses/WarehousesItem';
+import { BranchIntegrationErrorsMiddleware } from '@/services/Branches/BranchIntegrationErrorsMiddleware';
+import { InventoryItemsCostController } from './controllers/Inventory/InventortyItemsCosts';
+import { ProjectsController } from './controllers/Projects/Projects';
+import { ProjectTasksController } from './controllers/Projects/Tasks';
+import { ProjectTimesController } from './controllers/Projects/Times';
+
+export default () => {
+  const app = Router();
+
+  // - Global routes.
+  // ---------------------------
+  app.use(asyncRenderMiddleware);
+  app.use(I18nMiddleware);
+
+  app.use('/auth', Container.get(Authentication).router());
+  app.use('/invite', Container.get(InviteUsers).nonAuthRouter());
+  app.use('/licenses', Container.get(Licenses).router());
+  app.use('/subscription', Container.get(Subscription).router());
+  app.use('/organization', Container.get(Organization).router());
+  app.use('/ping', Container.get(Ping).router());
+  app.use('/jobs', Container.get(Jobs).router());
+  app.use('/account', Container.get(Account).router());
+
+  // - Dashboard routes.
+  // ---------------------------
+  const dashboard = Router();
+
+  dashboard.use(JWTAuth);
+  dashboard.use(AttachCurrentTenantUser);
+  dashboard.use(TenancyMiddleware);
+  dashboard.use(SubscriptionMiddleware('main'));
+  dashboard.use(EnsureTenantIsInitialized);
+  dashboard.use(SettingsMiddleware);
+  dashboard.use(I18nAuthenticatedMiddlware);
+  dashboard.use(EnsureTenantIsSeeded);
+  dashboard.use(AuthorizationMiddleware);
+
+  dashboard.use('/organization', Container.get(OrganizationDashboard).router());
+  dashboard.use('/users', Container.get(Users).router());
+  dashboard.use('/invite', Container.get(InviteUsers).authRouter());
+  dashboard.use('/currencies', Container.get(Currencies).router());
+  dashboard.use('/settings', Container.get(Settings).router());
+  dashboard.use('/accounts', Container.get(Accounts).router());
+  dashboard.use('/account_types', Container.get(AccountTypes).router());
+  dashboard.use('/manual-journals', Container.get(ManualJournals).router());
+  dashboard.use('/views', Container.get(Views).router());
+  dashboard.use('/items', Container.get(Items).router());
+  dashboard.use('/item_categories', Container.get(ItemCategories).router());
+  dashboard.use('/expenses', Container.get(Expenses).router());
+  dashboard.use(
+    '/financial_statements',
+    Container.get(FinancialStatements).router()
+  );
+  dashboard.use('/contacts', Container.get(Contacts).router());
+  dashboard.use('/customers', Container.get(Customers).router());
+  dashboard.use('/vendors', Container.get(Vendors).router());
+  dashboard.use('/sales', Container.get(Sales).router());
+  dashboard.use('/purchases', Container.get(Purchases).router());
+  dashboard.use('/resources', Container.get(Resources).router());
+  dashboard.use('/exchange_rates', Container.get(ExchangeRates).router());
+  dashboard.use('/media', Container.get(Media).router());
+  dashboard.use(
+    '/inventory_adjustments',
+    Container.get(InventoryAdjustments).router()
+  );
+  dashboard.use(
+    '/inventory',
+    Container.get(InventoryItemsCostController).router()
+  );
+  dashboard.use('/cashflow', Container.get(CashflowController).router());
+  dashboard.use('/roles', Container.get(RolesController).router());
+  dashboard.use(
+    '/transactions-locking',
+    Container.get(TransactionsLocking).router()
+  );
+  dashboard.use('/branches', Container.get(BranchesController).router());
+  dashboard.use(
+    '/warehouses/transfers',
+    Container.get(WarehousesTransfers).router()
+  );
+  dashboard.use('/warehouses', Container.get(WarehousesController).router());
+  dashboard.use('/projects', Container.get(ProjectsController).router());
+  dashboard.use('/', Container.get(ProjectTasksController).router());
+  dashboard.use('/', Container.get(ProjectTimesController).router());
+
+  dashboard.use('/', Container.get(WarehousesItemController).router());
+
+  dashboard.use('/dashboard', Container.get(DashboardController).router());
+  dashboard.use('/', Container.get(Miscellaneous).router());
+
+  app.use('/', dashboard);
+
+  app.use(BranchIntegrationErrorsMiddleware);
+
+  return app;
+};
diff --git a/packages/server/src/api/middleware/AsyncRenderMiddleware.ts b/packages/server/src/api/middleware/AsyncRenderMiddleware.ts
new file mode 100644
index 000000000..5bd6e736a
--- /dev/null
+++ b/packages/server/src/api/middleware/AsyncRenderMiddleware.ts
@@ -0,0 +1,23 @@
+import { Request, Response } from 'express';
+
+const asyncRender = (app) => (path: string, attributes = {}) =>
+  new Promise((resolve, reject) => {
+    app.render(path, attributes, (error, data) => {
+      if (error) { reject(error); }
+
+      resolve(data);
+    });
+  });
+
+/**
+ * Injects `asyncRender` method to response object.
+ * @param {Request} req Express req Object
+ * @param {Response} res  Express res Object
+ * @param {NextFunction} next  Express next Function
+ */
+const asyncRenderMiddleware = (req: Request, res: Response, next: Function) => {
+  res.asyncRender = asyncRender(req.app);
+  next();
+};
+
+export default asyncRenderMiddleware;
diff --git a/packages/server/src/api/middleware/AttachCurrentTenantUser.ts b/packages/server/src/api/middleware/AttachCurrentTenantUser.ts
new file mode 100644
index 000000000..0ba44f689
--- /dev/null
+++ b/packages/server/src/api/middleware/AttachCurrentTenantUser.ts
@@ -0,0 +1,39 @@
+import { Container } from 'typedi';
+import { Request, Response } from 'express';
+
+/**
+ * Attach user to req.currentUser
+ * @param {Request} req Express req Object
+ * @param {Response} res  Express res Object
+ * @param {NextFunction} next  Express next Function
+ */
+const attachCurrentUser = async (req: Request, res: Response, next: Function) => {
+  const Logger = Container.get('logger');
+  const { systemUserRepository } = Container.get('repositories');
+
+  try {
+    Logger.info('[attach_user_middleware] finding system user by id.');
+    const user = await systemUserRepository.findOneById(req.token.id);
+
+    if (!user) {
+      Logger.info('[attach_user_middleware] the system user not found.');
+      return res.boom.unauthorized();
+    }
+    if (!user.active) {
+      Logger.info('[attach_user_middleware] the system user not found.');
+      return res.boom.badRequest(
+        'The authorized user is inactivated.',
+        { errors: [{ type: 'USER_INACTIVE', code: 100, }] },
+      );
+    }
+    // Delete password property from user object.
+    Reflect.deleteProperty(user, 'password');
+    req.user = user;
+    return next();
+  } catch (e) {
+    Logger.error('[attach_user_middleware] error attaching user to req: %o', e);
+    return next(e);
+  }
+};
+
+export default attachCurrentUser;
diff --git a/packages/server/src/api/middleware/AuthorizationMiddleware.ts b/packages/server/src/api/middleware/AuthorizationMiddleware.ts
new file mode 100644
index 000000000..9b0c2d90b
--- /dev/null
+++ b/packages/server/src/api/middleware/AuthorizationMiddleware.ts
@@ -0,0 +1,92 @@
+import { Request, Response, NextFunction } from 'express';
+import { Container } from 'typedi';
+import { Ability } from '@casl/ability';
+import LruCache from 'lru-cache';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { IRole, IRolePremission, ISystemUser } from '@/interfaces';
+
+// store abilities of 1000 most active users
+export const ABILITIES_CACHE = new LruCache(1000);
+
+/**
+ * Retrieve ability for the given role.
+ * @param {} role
+ * @returns
+ */
+function getAbilityForRole(role) {
+  const rules = getAbilitiesRolesConds(role);
+  return new Ability(rules);
+}
+
+/**
+ * Retrieve abilities of the given role.
+ * @param {IRole} role
+ * @returns {}
+ */
+function getAbilitiesRolesConds(role: IRole) {
+  switch (role.slug) {
+    case 'admin': // predefined role.
+      return getSuperAdminRules();
+    default:
+      return getRulesFromRolePermissions(role.permissions || []);
+  }
+}
+
+/**
+ * Retrieve the super admin rules.
+ * @returns {}
+ */
+function getSuperAdminRules() {
+  return [{ action: 'manage', subject: 'all' }];
+}
+
+/**
+ * Retrieve CASL rules from role permissions.
+ * @param {IRolePremission[]} permissions -
+ * @returns {}
+ */
+function getRulesFromRolePermissions(permissions: IRolePremission[]) {
+  return permissions
+    .filter((permission: IRolePremission) => permission.value)
+    .map((permission: IRolePremission) => {
+      return {
+        action: permission.ability,
+        subject: permission.subject,
+      };
+    });
+}
+
+/**
+ * Retrieve ability for user.
+ * @param {ISystemUser} user
+ * @param {number} tenantId
+ * @returns {}
+ */
+async function getAbilityForUser(user: ISystemUser, tenantId: number) {
+  const tenancy = Container.get(HasTenancyService);
+  const { User } = tenancy.models(tenantId);
+
+  const tenantUser = await User.query()
+    .findOne('systemUserId', user.id)
+    .withGraphFetched('role.permissions');
+
+  return getAbilityForRole(tenantUser.role);
+}
+
+/**
+ *
+ * @param {Request} request -
+ * @param {Response} response -
+ * @param {NextFunction} next -
+ */
+export default async (req: Request, res: Response, next: NextFunction) => {
+  const { tenantId, user } = req;
+
+  if (ABILITIES_CACHE.has(req.user.id)) {
+    req.ability = ABILITIES_CACHE.get(req.user.id);
+  } else {
+    req.ability = await getAbilityForUser(req.user, tenantId);
+    ABILITIES_CACHE.set(req.user.id, req.ability);
+  }
+  next();
+};
diff --git a/packages/server/src/api/middleware/CheckPolicies.ts b/packages/server/src/api/middleware/CheckPolicies.ts
new file mode 100644
index 000000000..3649f0aa8
--- /dev/null
+++ b/packages/server/src/api/middleware/CheckPolicies.ts
@@ -0,0 +1,18 @@
+import { Request, Response, NextFunction } from 'express';
+import { ForbiddenError } from '@casl/ability';
+
+/**
+ *
+ */
+export default (ability: string, subject: string) =>
+  (req: Request, res: Response, next: NextFunction) => {
+    try {
+      ForbiddenError.from(req.ability).throwUnlessCan(ability, subject);
+    } catch (error) {
+      return res.status(403).send({
+        type: 'USER_PERMISSIONS_FORBIDDEN',
+        message: `You are not allowed to ${error.action} on ${error.subjectType}`,
+      });
+    }
+    next();
+  };
diff --git a/packages/server/src/api/middleware/ConvertEmptyStringsToNull.ts b/packages/server/src/api/middleware/ConvertEmptyStringsToNull.ts
new file mode 100644
index 000000000..aa7b41690
--- /dev/null
+++ b/packages/server/src/api/middleware/ConvertEmptyStringsToNull.ts
@@ -0,0 +1,13 @@
+import { Request, Response, NextFunction } from 'express';
+import deepMap from 'deep-map';
+import { convertEmptyStringToNull } from 'utils';
+
+function convertEmptyStringsToNull(data) {
+  return deepMap(data, (value) => convertEmptyStringToNull(value));
+}
+
+export default (req: Request, res: Response, next: NextFunction) => {  
+  const transfomedBody = convertEmptyStringsToNull(req.body);
+  req.body = transfomedBody;
+  next();
+};
\ No newline at end of file
diff --git a/packages/server/src/api/middleware/EnsureTenantIsInitialized.ts b/packages/server/src/api/middleware/EnsureTenantIsInitialized.ts
new file mode 100644
index 000000000..2f546cb01
--- /dev/null
+++ b/packages/server/src/api/middleware/EnsureTenantIsInitialized.ts
@@ -0,0 +1,21 @@
+import { Container } from 'typedi';
+import { Request, Response } from 'express';
+
+
+export default (req: Request, res: Response, next: Function) => {
+  const Logger = Container.get('logger');
+
+  if (!req.tenant) {
+    Logger.info('[ensure_tenant_intialized_middleware] no tenant model.');
+    throw new Error('Should load this middleware after `TenancyMiddleware`.');
+  }
+  if (!req.tenant.initializedAt) {
+    Logger.info('[ensure_tenant_initialized_middleware] tenant database not initalized.');
+    
+    return res.boom.badRequest(
+      'Tenant database is not migrated with application schema yut.',
+      { errors: [{ type: 'TENANT.DATABASE.NOT.INITALIZED' }] },
+    );
+  }
+  next();
+};
\ No newline at end of file
diff --git a/packages/server/src/api/middleware/EnsureTenantIsSeeded.ts b/packages/server/src/api/middleware/EnsureTenantIsSeeded.ts
new file mode 100644
index 000000000..69f92c76a
--- /dev/null
+++ b/packages/server/src/api/middleware/EnsureTenantIsSeeded.ts
@@ -0,0 +1,21 @@
+import { Container } from 'typedi';
+import { Request, Response } from 'express';
+
+export default (req: Request, res: Response, next: Function) => {
+  const Logger = Container.get('logger');
+
+  if (!req.tenant) {
+    Logger.info('[ensure_tenant_intialized_middleware] no tenant model.');
+    throw new Error('Should load this middleware after `TenancyMiddleware`.');
+  }
+  if (!req.tenant.seededAt) {
+    Logger.info(
+      '[ensure_tenant_initialized_middleware] tenant databae not seeded.'
+    );
+    return res.boom.badRequest(
+      'Tenant database is not seeded with initial data yet.',
+      { errors: [{ type: 'TENANT.DATABASE.NOT.SEED' }] }
+    );
+  }
+  next();
+};
diff --git a/packages/server/src/api/middleware/FeatureActivationGuard.ts b/packages/server/src/api/middleware/FeatureActivationGuard.ts
new file mode 100644
index 000000000..1455ac913
--- /dev/null
+++ b/packages/server/src/api/middleware/FeatureActivationGuard.ts
@@ -0,0 +1,18 @@
+import { Request, Response } from 'express';
+import { Features } from '@/interfaces';
+
+export const FeatureActivationGuard =
+  (feature: Features) => (req: Request, res: Response, next: Function) => {
+    const { settings } = req;
+
+    const isActivated = settings.get({ group: 'features', key: feature });
+
+    if (!isActivated) {
+      return res.status(400).send({
+        errors: [
+          { type: 'FEATURE_NOT_ACTIVATED', code: 20, payload: { feature } },
+        ],
+      });
+    }
+    next();
+  };
diff --git a/packages/server/src/api/middleware/I18nAuthenticatedMiddlware.ts b/packages/server/src/api/middleware/I18nAuthenticatedMiddlware.ts
new file mode 100644
index 000000000..19a26458c
--- /dev/null
+++ b/packages/server/src/api/middleware/I18nAuthenticatedMiddlware.ts
@@ -0,0 +1,37 @@
+import { Container } from 'typedi';
+import { Request, Response, NextFunction } from 'express';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { injectI18nUtils } from './TenantDependencyInjection';
+
+/**
+ * I18n from organization settings.
+ */
+export default (req: Request, res: Response, next: NextFunction) => {
+  const Logger = Container.get('logger');
+  const I18n = Container.get('i18n');
+
+  const { tenantId, tenant } = req;
+
+  if (!req.user) {
+    throw new Error('Should load this middleware after `JWTAuth`.');
+  }
+  if (!req.settings) {
+    throw new Error('Should load this middleware after `SettingsMiddleware`.');
+  }
+  // Get the organization language from settings.
+  const { language } = tenant.metadata;
+
+  if (language) {
+    I18n.setLocale(req, language);
+  }
+  Logger.info('[i18n_authenticated_middleware] set locale language to i18n.', {
+    language,
+    user: req.user,
+  });
+  const tenantServices = Container.get(HasTenancyService);
+  const tenantContainer = tenantServices.tenantContainer(tenantId);
+
+  tenantContainer.set('i18n', injectI18nUtils(req));
+
+  next();
+};
diff --git a/packages/server/src/api/middleware/I18nMiddleware.ts b/packages/server/src/api/middleware/I18nMiddleware.ts
new file mode 100644
index 000000000..81f0e8551
--- /dev/null
+++ b/packages/server/src/api/middleware/I18nMiddleware.ts
@@ -0,0 +1,22 @@
+import { Container } from 'typedi';
+import { Request, Response, NextFunction } from 'express';
+import { lowerCase } from 'lodash';
+
+/**
+ * Set the language from request `accept-language` header
+*  or default application language.
+ */
+export default (req: Request, res: Response, next: NextFunction) => {
+  const Logger = Container.get('logger');
+  const I18n = Container.get('i18n');
+
+  // Parses the accepted language from request object.
+  const language = lowerCase(req.headers['accept-language']) || 'en';
+
+  Logger.info('[i18n_middleware] set locale language to i18n.', {
+    language,
+    user: req.user,
+  });
+  // Initialise the global localization.
+  I18n.init(req, res, next);
+};
diff --git a/packages/server/src/api/middleware/JSONResponseTransformer.ts b/packages/server/src/api/middleware/JSONResponseTransformer.ts
new file mode 100644
index 000000000..a68bc699a
--- /dev/null
+++ b/packages/server/src/api/middleware/JSONResponseTransformer.ts
@@ -0,0 +1,37 @@
+import { snakeCase } from 'lodash';
+import { mapKeysDeep } from 'utils';
+
+/**
+ * Express middleware for intercepting and transforming json responses
+ *
+ * @param {function} [condition] - takes the req and res and returns a boolean indicating whether to run the transform on this response
+ * @param {function} transform - takes an object passed to res.json and returns a replacement object
+ * @return {function} the middleware
+ */
+export function JSONResponseTransformer(transform: Function) {
+  const replaceJson = (res) => {
+    var origJson = res.json;
+  
+    res.json = function (val) {
+      const json = JSON.parse(JSON.stringify(val));
+
+      return origJson.call(res, transform(json));
+    };
+  };
+
+  return function (req, res, next) {
+    replaceJson(res);
+    next();
+  };
+}
+
+/**
+ * Transformes the given response keys to snake case.
+ * @param response
+ * @returns
+ */
+export const snakecaseResponseTransformer = (response) => {
+  return mapKeysDeep(response, (value, key) => {
+    return snakeCase(key);
+  });
+};
diff --git a/packages/server/src/api/middleware/LoggerMiddleware.ts b/packages/server/src/api/middleware/LoggerMiddleware.ts
new file mode 100644
index 000000000..e57952cd3
--- /dev/null
+++ b/packages/server/src/api/middleware/LoggerMiddleware.ts
@@ -0,0 +1,11 @@
+import { NextFunction, Request } from 'express';
+import { Container } from 'typedi';
+
+function loggerMiddleware(request: Request, response: Response, next: NextFunction) {
+  const Logger = Container.get('logger');
+
+  Logger.info(`[routes] ${request.method} ${request.path}`);
+  next();
+}
+
+export default loggerMiddleware;
diff --git a/packages/server/src/api/middleware/LoginThrottlerMiddleware.ts b/packages/server/src/api/middleware/LoginThrottlerMiddleware.ts
new file mode 100644
index 000000000..60d437387
--- /dev/null
+++ b/packages/server/src/api/middleware/LoginThrottlerMiddleware.ts
@@ -0,0 +1,24 @@
+import { Container } from 'typedi';
+import { Request, Response, NextFunction } from 'express';
+import config from '@/config';
+
+const MAX_CONSECUTIVE_FAILS = config.throttler.login.points;
+
+export default async (req: Request, res: Response, next: NextFunction) => {
+  const { crediential } = req.body;
+  const loginThrottler = Container.get('rateLimiter.login');
+
+  // Retrieve the rate limiter response of the given crediential.
+  const emailRateRes = await loginThrottler.get(crediential);
+
+  if (emailRateRes !== null && emailRateRes.consumedPoints >= MAX_CONSECUTIVE_FAILS) {
+    const retrySecs = Math.round(emailRateRes.msBeforeNext / 1000) || 1;
+
+    res.set('Retry-After', retrySecs);
+    res.status(429).send({
+      errors: [{ type: 'LOGIN_TO_MANY_ATTEMPTS', code: 400 }],
+    });
+  } else {
+    next();
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/api/middleware/ObjectionErrorHandlerMiddleware.ts b/packages/server/src/api/middleware/ObjectionErrorHandlerMiddleware.ts
new file mode 100644
index 000000000..424b86501
--- /dev/null
+++ b/packages/server/src/api/middleware/ObjectionErrorHandlerMiddleware.ts
@@ -0,0 +1,113 @@
+import { Request, Response, NextFunction } from 'express';
+import {
+  ValidationError,
+  NotFoundError,
+  DBError,
+  UniqueViolationError,
+  NotNullViolationError,
+  ForeignKeyViolationError,
+  CheckViolationError,
+  DataError,
+} from 'objection';
+
+// In this example `res` is an express response object.
+export default function ObjectionErrorHandlerMiddleware(
+  err: Error,
+  req: Request,
+  res: Response,
+  next: NextFunction
+) {
+  if (err instanceof ValidationError) {
+    switch (err.type) {
+      case 'ModelValidation':
+        return res.status(400).send({
+          message: err.message,
+          type: err.type,
+          data: err.data,
+        });
+      case 'RelationExpression':
+        return res.status(400).send({
+          message: err.message,
+          type: 'RelationExpression',
+          data: {},
+        });
+
+      case 'UnallowedRelation':
+        return res.status(400).send({
+          message: err.message,
+          type: err.type,
+          data: {},
+        });
+
+      case 'InvalidGraph':
+        return res.status(400).send({
+          message: err.message,
+          type: err.type,
+          data: {},
+        });
+
+      default:
+        return res.status(400).send({
+          message: err.message,
+          type: 'UnknownValidationError',
+          data: {},
+        });
+    }
+  } else if (err instanceof NotFoundError) {
+    return res.status(404).send({
+      message: err.message,
+      type: 'NotFound',
+      data: {},
+    });
+  } else if (err instanceof UniqueViolationError) {
+    return res.status(409).send({
+      message: err.message,
+      type: 'UniqueViolation',
+      data: {
+        columns: err.columns,
+        table: err.table,
+        constraint: err.constraint,
+      },
+    });
+  } else if (err instanceof NotNullViolationError) {
+    return res.status(400).send({
+      message: err.message,
+      type: 'NotNullViolation',
+      data: {
+        column: err.column,
+        table: err.table,
+      },
+    });
+  } else if (err instanceof ForeignKeyViolationError) {
+    return res.status(409).send({
+      message: err.message,
+      type: 'ForeignKeyViolation',
+      data: {
+        table: err.table,
+        constraint: err.constraint,
+      },
+    });
+  } else if (err instanceof CheckViolationError) {
+    return res.status(400).send({
+      message: err.message,
+      type: 'CheckViolation',
+      data: {
+        table: err.table,
+        constraint: err.constraint,
+      },
+    });
+  } else if (err instanceof DataError) {
+    return res.status(400).send({
+      message: err.message,
+      type: 'InvalidData',
+      data: {},
+    });
+  } else if (err instanceof DBError) {
+    return res.status(500).send({
+      message: err.message,
+      type: 'UnknownDatabaseError',
+      data: {},
+    });
+  }
+  next(err);
+}
diff --git a/packages/server/src/api/middleware/RateLimiterMiddleware.ts b/packages/server/src/api/middleware/RateLimiterMiddleware.ts
new file mode 100644
index 000000000..69a79f7e9
--- /dev/null
+++ b/packages/server/src/api/middleware/RateLimiterMiddleware.ts
@@ -0,0 +1,16 @@
+import { Container } from 'typedi';
+import { Request, Response, NextFunction } from 'express';
+
+/**
+ * Rate limiter middleware.
+ */
+export default (req: Request, res: Response, next: NextFunction) => {
+  const requestRateLimiter = Container.get('rateLimiter.request');
+
+  requestRateLimiter.attempt(req.ip).then(() => {
+    next();
+  })
+  .catch(() => {
+    res.status(429).send('Too Many Requests');
+  });
+}
\ No newline at end of file
diff --git a/packages/server/src/api/middleware/SettingsMiddleware.ts b/packages/server/src/api/middleware/SettingsMiddleware.ts
new file mode 100644
index 000000000..fbb49b475
--- /dev/null
+++ b/packages/server/src/api/middleware/SettingsMiddleware.ts
@@ -0,0 +1,27 @@
+import { Request, Response, NextFunction } from 'express';
+import { Container } from 'typedi';
+import SettingsStore from '@/services/Settings/SettingsStore';
+ 
+export default async (req: Request, res: Response, next: NextFunction) => {
+  const { tenantId } = req.user;
+
+  const Logger = Container.get('logger');
+  const tenantContainer = Container.of(`tenant-${tenantId}`);
+
+  if (tenantContainer && !tenantContainer.has('settings')) {
+    const { settingRepository } = tenantContainer.get('repositories');
+
+    const settings = new SettingsStore(settingRepository);
+    tenantContainer.set('settings', settings);
+  }
+  const settings = tenantContainer.get('settings');
+
+  await settings.load();
+
+  req.settings = settings;
+
+  res.on('finish', async () => {
+    await settings.save();
+  });
+  next();
+}
\ No newline at end of file
diff --git a/packages/server/src/api/middleware/SubscriptionMiddleware.ts b/packages/server/src/api/middleware/SubscriptionMiddleware.ts
new file mode 100644
index 000000000..ce7d45258
--- /dev/null
+++ b/packages/server/src/api/middleware/SubscriptionMiddleware.ts
@@ -0,0 +1,41 @@
+import { Request, Response, NextFunction } from 'express';
+import { Container } from 'typedi';
+
+export default (subscriptionSlug = 'main') => async (
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  const { tenant, tenantId } = req;
+  const Logger = Container.get('logger');
+  const { subscriptionRepository } = Container.get('repositories');
+
+  if (!tenant) {
+    throw new Error('Should load `TenancyMiddlware` before this middleware.');
+  }
+  Logger.info('[subscription_middleware] trying get tenant main subscription.');
+  const subscription = await subscriptionRepository.getBySlugInTenant(
+    subscriptionSlug,
+    tenantId
+  );
+  // Validate in case there is no any already subscription.
+  if (!subscription) {
+    Logger.info('[subscription_middleware] tenant has no subscription.', {
+      tenantId,
+    });
+    return res.boom.badRequest('Tenant has no subscription.', {
+      errors: [{ type: 'TENANT.HAS.NO.SUBSCRIPTION' }],
+    });
+  }
+  // Validate in case the subscription is inactive.
+  else if (subscription.inactive()) {
+    Logger.info(
+      '[subscription_middleware] tenant main subscription is expired.',
+      { tenantId }
+    );
+    return res.boom.badRequest(null, {
+      errors: [{ type: 'ORGANIZATION.SUBSCRIPTION.INACTIVE' }],
+    });
+  }
+  next();
+};
diff --git a/packages/server/src/api/middleware/TenancyMiddleware.ts b/packages/server/src/api/middleware/TenancyMiddleware.ts
new file mode 100644
index 000000000..5e9f4e1ac
--- /dev/null
+++ b/packages/server/src/api/middleware/TenancyMiddleware.ts
@@ -0,0 +1,36 @@
+import { Container } from 'typedi';
+import { Request, Response, NextFunction } from 'express';
+import tenantDependencyInjection from '@/api/middleware/TenantDependencyInjection';
+import { Tenant } from '@/system/models';
+
+export default async (req: Request, res: Response, next: NextFunction) => {
+  const Logger = Container.get('logger');
+  const organizationId =
+    req.headers['organization-id'] || req.query.organization;
+
+  const notFoundOrganization = () => {
+    Logger.info('[tenancy_middleware] organization id not found.');
+    return res.boom.unauthorized('Organization identication not found.', {
+      errors: [{ type: 'ORGANIZATION.ID.NOT.FOUND', code: 100 }],
+    });
+  };
+  // In case the given organization not found.
+  if (!organizationId) {
+    return notFoundOrganization();
+  }
+  const tenant = await Tenant.query()
+    .findOne({ organizationId })
+    .withGraphFetched('metadata');
+
+  // When the given organization id not found on the system storage.
+  if (!tenant) {
+    return notFoundOrganization();
+  }
+  // When user tenant not match the given organization id.
+  if (tenant.id !== req.user.tenantId) {
+    Logger.info('[tenancy_middleware] authorized user not match org. tenant.');
+    return res.boom.unauthorized();
+  }
+  tenantDependencyInjection(req, tenant);
+  next();
+};
diff --git a/packages/server/src/api/middleware/TenantDependencyInjection.ts b/packages/server/src/api/middleware/TenantDependencyInjection.ts
new file mode 100644
index 000000000..a635ad254
--- /dev/null
+++ b/packages/server/src/api/middleware/TenantDependencyInjection.ts
@@ -0,0 +1,46 @@
+import { Container } from 'typedi';
+import { ITenant } from '@/interfaces';
+import { Request } from 'express';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import TenantsManagerService from '@/services/Tenancy/TenantsManager';
+import rtlDetect from 'rtl-detect';
+
+export default (req: Request, tenant: ITenant) => {
+  const { id: tenantId, organizationId } = tenant;
+
+  const tenantServices = Container.get(TenancyService);
+  const tenantsManager = Container.get(TenantsManagerService);
+
+  // Initialize the knex instance.
+  tenantsManager.setupKnexInstance(tenant);
+
+  const tenantContainer = tenantServices.tenantContainer(tenantId);
+
+  tenantContainer.set('i18n', injectI18nUtils(req));
+
+  const knexInstance = tenantServices.knex(tenantId);
+  const models = tenantServices.models(tenantId);
+  const repositories = tenantServices.repositories(tenantId);
+  const cacheInstance = tenantServices.cache(tenantId);
+
+  req.knex = knexInstance;
+  req.organizationId = organizationId;
+  req.tenant = tenant;
+  req.tenantId = tenant.id;
+  req.models = models;
+  req.repositories = repositories;
+  req.cache = cacheInstance;
+};
+
+export const injectI18nUtils = (req) => {
+  const locale = req.getLocale();
+  const direction = rtlDetect.getLangDir(locale);
+
+  return {
+    locale,
+    __: req.__,
+    direction,
+    isRtl: direction === 'rtl',
+    isLtr: direction === 'ltr',
+  };
+};
diff --git a/packages/server/src/api/middleware/asyncMiddleware.ts b/packages/server/src/api/middleware/asyncMiddleware.ts
new file mode 100644
index 000000000..e0c6e0256
--- /dev/null
+++ b/packages/server/src/api/middleware/asyncMiddleware.ts
@@ -0,0 +1,14 @@
+import { Request, Response, NextFunction } from 'express';
+import { Container } from 'typedi';
+
+export default (
+  fn: (rq: Request, rs: Response, next?: NextFunction) => {}) =>
+  (req: Request, res: Response, next: NextFunction) => {
+  const Logger = Container.get('logger');
+
+  Promise.resolve(fn(req, res, next))
+    .catch((error) => {
+      Logger.error('[async_middleware] error.', { error });
+      next(error);
+    });
+};
\ No newline at end of file
diff --git a/packages/server/src/api/middleware/jwtAuth.ts b/packages/server/src/api/middleware/jwtAuth.ts
new file mode 100644
index 000000000..0c101c246
--- /dev/null
+++ b/packages/server/src/api/middleware/jwtAuth.ts
@@ -0,0 +1,32 @@
+import { Request, Response, NextFunction } from 'express';
+import { Container } from 'typedi';
+import jwt from 'jsonwebtoken';
+import config from '@/config';
+
+const authMiddleware = (req: Request, res: Response, next: NextFunction) => {
+  const Logger = Container.get('logger');
+  const token = req.headers['x-access-token'] || req.query.token;
+
+  const onError = () => {
+    Logger.info('[auth_middleware] jwt verify error.');
+    res.boom.unauthorized();
+  };
+  const onSuccess = (decoded) => {
+    req.token = decoded;
+    Logger.info('[auth_middleware] jwt verify success.');
+    next();
+  };
+  if (!token) { return onError(); }
+
+  const verify = new Promise((resolve, reject) => {
+    jwt.verify(token, config.jwtSecret, async (error, decoded) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(decoded);
+      }
+    });
+  });
+  verify.then(onSuccess).catch(onError);
+};
+export default authMiddleware;
diff --git a/packages/server/src/before.ts b/packages/server/src/before.ts
new file mode 100644
index 000000000..d8755180e
--- /dev/null
+++ b/packages/server/src/before.ts
@@ -0,0 +1,10 @@
+import path from 'path';
+import moment from 'moment';
+
+global.__root_dir = path.join(__dirname, '..');
+global.__resources_dir = path.join(global.__root, 'resources');
+global.__locales_dir = path.join(global.__resources_dir, 'locales');
+
+moment.prototype.toMySqlDateTime = function () {
+  return this.format('YYYY-MM-DD HH:mm:ss');
+};
diff --git a/packages/server/src/collection/BudgetEntriesSet.ts b/packages/server/src/collection/BudgetEntriesSet.ts
new file mode 100644
index 000000000..1be8c34b8
--- /dev/null
+++ b/packages/server/src/collection/BudgetEntriesSet.ts
@@ -0,0 +1,76 @@
+
+
+export default class BudgetEntriesSet {
+
+  constructor() {
+    this.accounts = {}; 
+    this.totalSummary = {}
+    this.orderSize = null;
+  }
+
+  setZeroPlaceholder() {
+    if (!this.orderSize) { return; }
+
+    Object.values(this.accounts).forEach((account) => {
+
+      for (let i = 0; i <= this.orderSize.length; i++) {
+        if (typeof account[i] === 'undefined') {
+          account[i] = { amount: 0 };
+        }
+      }
+    });
+  }
+
+  static from(accounts, configs) {
+    const collection = new this(configs);
+
+    accounts.forEach((entry) => {
+      if (typeof this.accounts[entry.accountId] === 'undefined') {
+        collection.accounts[entry.accountId] = {};
+      }
+      if (entry.order) {
+        collection.accounts[entry.accountId][entry.order] = entry;
+      }
+    });
+    return collection;
+  }
+
+  toArray() {
+    const output = [];
+
+    Object.key(this.accounts).forEach((accountId) => {
+      const entries = this.accounts[accountId];
+      output.push({
+        account_id: accountId,
+        entries: [
+          ...Object.key(entries).map((order) => {
+            const entry = entries[order];
+            return {
+              order,
+              amount: entry.amount,
+            };
+          }),
+        ],
+      });
+    });
+  }
+
+  calcTotalSummary() {
+    const totalSummary = {};
+
+    for (let i = 0; i < this.orderSize.length; i++) {
+      Object.value(this.accounts).forEach((account) => {
+        if (typeof totalSummary[i] !== 'undefined') {
+          totalSummary[i] = { amount: 0, order: i };
+        }
+        totalSummary[i].amount += account[i].amount;
+      });
+    }
+    this.totalSummary = totalSummary;
+  }
+
+  toArrayTotalSummary() {
+    return Object.values(this.totalSummary);
+  }
+
+}
diff --git a/packages/server/src/collection/Cachable.ts b/packages/server/src/collection/Cachable.ts
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/server/src/collection/Metable.ts b/packages/server/src/collection/Metable.ts
new file mode 100644
index 000000000..80f6a9e7e
--- /dev/null
+++ b/packages/server/src/collection/Metable.ts
@@ -0,0 +1,279 @@
+
+
+export default {
+  METADATA_GROUP: 'default',
+  KEY_COLUMN: 'key',
+  VALUE_COLUMN: 'value',
+  TYPE_COLUMN: 'type',
+
+  extraColumns: [],
+  metadata: [],
+  shouldReload: true,
+  extraMetadataQuery: () => {},
+
+  /**
+   * Set the value column key to query from.
+   * @param {String} name -
+   */
+  setKeyColumnName(name) {
+    this.KEY_COLUMN = name;
+  },
+
+  /**
+   * Set the key column name to query from.
+   * @param {String} name -
+   */
+  setValueColumnName(name) {
+    this.VALUE_COLUMN = name;
+  },
+
+  /**
+   * Set extra columns to be added to the rows.
+   * @param {Array} columns -
+   */
+  setExtraColumns(columns) {
+    this.extraColumns = columns;
+  },
+ 
+  /**
+   * Metadata database query.
+   * @param {Object} query -
+   * @param {String} groupName -
+   */
+  whereQuery(query, key) {
+    const groupName = this.METADATA_GROUP;
+
+    if (groupName) {
+      query.where('group', groupName);
+    }
+    if (key) {
+      if (Array.isArray(key)) {
+        query.whereIn('key', key);
+      } else {
+        query.where('key', key);
+      }
+    }
+  },
+
+  /**
+   * Loads the metadata from the storage.
+   * @param {String|Array} key -
+   * @param {Boolean} force -
+   */
+  async load(force = false) {
+    if (this.shouldReload || force) {
+      const metadataCollection = await this.query((query) => {
+        this.whereQuery(query);
+        this.extraMetadataQuery(query);
+      }).fetchAll();
+
+      this.shouldReload = false;
+      this.metadata = [];
+
+      const metadataArray = this.mapMetadataCollection(metadataCollection);
+      metadataArray.forEach((metadata) => { this.metadata.push(metadata); });
+    }
+  },
+
+  /**
+   * Fetches all the metadata that associate with the current group.
+   */
+  async allMeta(force = false) {
+    await this.load(force);
+    return this.metadata;
+  },
+
+  /**
+   * Find the given metadata key.
+   * @param {String} key -
+   * @return {object} - Metadata object.
+   */
+  findMeta(key) {
+    return this.metadata.find((meta) => meta.key === key);
+  },
+
+  /**
+   * Fetch the metadata of the current group.
+   * @param {*} key -
+   */
+  async getMeta(key, defaultValue, force = false) {
+    await this.load(force);
+
+    const metadata = this.findMeta(key);
+    return metadata ? metadata.value : defaultValue || false;
+  },
+
+  /**
+   * Markes the metadata to should be deleted.
+   * @param {String} key -
+   */
+  async removeMeta(key) {
+    await this.load();
+    const metadata = this.findMeta(key);
+
+    if (metadata) {
+      metadata.markAsDeleted = true;
+    }
+    this.shouldReload = true;
+  
+
+  /**
+   * Remove all meta data of the given group.
+   * @param {*} group
+   */
+  removeAllMeta(group = 'default') {
+    this.metdata.map((meta) => ({
+      ...(meta.group !== group) ? { markAsDeleted: true } : {},
+      ...meta,
+    }));
+    this.shouldReload = true;
+  },
+
+  /**
+   * Set the meta data to the stack.
+   * @param {String} key -
+   * @param {String} value -
+   */
+  async setMeta(key, value, payload) {
+    if (Array.isArray(key)) {
+      const metadata = key;
+      metadata.forEach((meta) => {
+        this.setMeta(meta.key, meta.value);
+      });
+      return;
+    }
+
+    await this.load();
+    const metadata = this.findMeta(key);
+
+    if (metadata) {
+      metadata.value = value;
+      metadata.markAsUpdated = true;
+    } else {
+      this.metadata.push({
+        value, key, ...payload, markAsInserted: true,
+      });
+    }
+  },
+
+  /**
+   * Saved the modified metadata.
+   */
+  async saveMeta() {
+    const inserted = this.metadata.filter((m) => (m.markAsInserted === true));
+    const updated = this.metadata.filter((m) => (m.markAsUpdated === true));
+    const deleted = this.metadata.filter((m) => (m.markAsDeleted === true));
+
+    const metadataDeletedKeys = deleted.map((m) => m.key);
+    const metadataInserted = inserted.map((m) => this.mapMetadata(m, 'format'));
+    const metadataUpdated = updated.map((m) => this.mapMetadata(m, 'format'));
+
+    const batchUpdate = (collection) => knex.transaction((trx) => {
+      const queries = collection.map((tuple) => {
+        const query = knex(this.tableName);
+        this.whereQuery(query, tuple.key);
+        this.extraMetadataQuery(query);
+        return query.update(tuple).transacting(trx);
+      });
+      return Promise.all(queries).then(trx.commit).catch(trx.rollback);
+    });
+
+    await Promise.all([
+      knex.insert(metadataInserted).into(this.tableName),
+      batchUpdate(metadataUpdated),
+      metadataDeletedKeys.length > 0
+        ? this.query('whereIn', this.KEY_COLUMN, metadataDeletedKeys).destroy({
+          require: true,
+        }) : null,
+    ]);
+    this.shouldReload = true;
+  },
+
+  /**
+   * Purge all the cached metadata in the memory.
+   */
+  purgeMetadata() {
+    this.metadata = [];
+    this.shouldReload = true;
+  },
+
+  /**
+   * Parses the metadata value.
+   * @param {String} value -
+   * @param {String} valueType -
+   */
+  parseMetaValue(value, valueType) {
+    let parsedValue;
+
+    switch (valueType) {
+      case 'integer':
+        parsedValue = parseInt(value, 10);
+        break;
+      case 'float':
+        parsedValue = parseFloat(value);
+        break;
+      case 'boolean':
+        parsedValue = Boolean(value);
+        break;
+      case 'json':
+        parsedValue = JSON.parse(parsedValue);
+        break;
+      default:
+        parsedValue = value;
+        break;
+    }
+    return parsedValue;
+  },
+
+  /**
+   * Format the metadata before saving to the database.
+   * @param {String|Number|Boolean} value -
+   * @param {String} valueType -
+   * @return {String|Number|Boolean} -
+   */
+  formatMetaValue(value, valueType) {
+    let parsedValue;
+
+    switch (valueType) {
+      case 'number':
+        parsedValue = `${value}`;
+        break;
+      case 'boolean':
+        parsedValue = value ? '1' : '0';
+        break;
+      case 'json':
+        parsedValue = JSON.stringify(parsedValue);
+        break;
+      default:
+        parsedValue = value;
+        break;
+    }
+    return parsedValue;
+  },
+
+  mapMetadata(attr, parseType = 'parse') {
+    return {
+      key: attr[this.KEY_COLUMN],
+      value: (parseType === 'parse')
+        ? this.parseMetaValue(
+          attr[this.VALUE_COLUMN],
+          this.TYPE_COLUMN ? attr[this.TYPE_COLUMN] : false,
+        )
+        : this.formatMetaValue(
+          attr[this.VALUE_COLUMN],
+          this.TYPE_COLUMN ? attr[this.TYPE_COLUMN] : false,
+        ),
+      ...this.extraColumns.map((extraCol) => ({
+        [extraCol]: attr[extraCol] || null,
+      })),
+    };
+  },
+
+  /**
+   * Parse the metadata collection.
+   * @param {Array} collection -
+   */
+  mapMetadataCollection(collection, parseType = 'parse') {
+    return collection.map((model) => this.mapMetadata(model.attributes, parseType));
+  },
+};
diff --git a/packages/server/src/collection/NestedSet/index.ts b/packages/server/src/collection/NestedSet/index.ts
new file mode 100644
index 000000000..e7480e900
--- /dev/null
+++ b/packages/server/src/collection/NestedSet/index.ts
@@ -0,0 +1,116 @@
+
+export default class NestedSet {
+  /**
+   * Constructor method.
+   * @param {Object} options -
+   */
+  constructor(items, options) {
+    this.options = {
+      parentId: 'parent_id',
+      id: 'id',
+      ...options,
+    };
+    this.items = items || [];
+    this.tree = this.linkChildren();
+  }
+
+  setItems(items) {
+    this.items = items;
+    this.tree = this.linkChildren();
+  }
+
+  /**
+   * Link nodes children.
+   */
+  linkChildren() {
+    if (this.items.length <= 0) return false;
+
+    const map = {};
+    this.items.forEach((item) => {
+      map[item.id] = item;
+      map[item.id].children = {};
+    });
+
+    this.items.forEach((item) => {
+      const parentNodeId = item[this.options.parentId];
+      if (parentNodeId) {
+        map[parentNodeId].children[item.id] = item;
+      }
+    });
+    return map;
+  }
+
+  toArray() {
+    const stack = [];
+    const treeNodes = this.items.map((i) => ({ ...i }));
+
+    const walk = (nodes) => {
+      nodes.forEach((node) => {
+        if (!node[this.options.parentId]) {
+          stack.push(node);
+        }
+        if (node.children) {
+          const childrenNodes = Object.values(node.children)
+            .map((i) => ({ ...i }));
+
+          node.children = childrenNodes;
+          walk(childrenNodes);
+        }
+      });
+    };
+    walk(treeNodes);
+    return stack;
+  }
+
+  getTree() {
+    return this.tree;
+  }
+
+  getElementById(id) {
+    return this.tree[id] || null
+  }
+
+  getParents(id) {
+    const item = this.getElementById(id);
+    const parents = [];
+    let index = 0;
+
+    const walk = (_item) => {
+      if (!item) return;
+
+      if (index) {
+        parents.push(_item);
+      }
+      if (_item[this.options.parentId]) {
+        const parentItem = this.getElementById(_item[this.options.parentId]);  
+
+        index++;
+        walk(parentItem);
+      }      
+    };
+    walk(item);
+    return parents;
+  }
+
+  toFlattenArray(nodeMapper) {
+    const flattenTree = [];
+
+    const traversal = (nodes, parentNode) => {
+      nodes.forEach((node) => {
+        let nodeMapped = node;
+
+        if (typeof nodeMapper === 'function') {
+          nodeMapped = nodeMapper(nodeMapped, parentNode);
+        }
+        flattenTree.push(nodeMapped);
+
+        if (node.children && node.children.length > 0) {
+          traversal(node.children, node);
+        }
+      });
+    };
+    traversal(this.collection);
+
+    return flattenTree;
+  }
+}
diff --git a/packages/server/src/collection/ResourceFieldMetadataCollection.ts b/packages/server/src/collection/ResourceFieldMetadataCollection.ts
new file mode 100644
index 000000000..5d53dc17f
--- /dev/null
+++ b/packages/server/src/collection/ResourceFieldMetadataCollection.ts
@@ -0,0 +1,14 @@
+import MetableCollection from '@/lib/Metable/MetableCollection';
+import ResourceFieldMetadata from 'models/ResourceFieldMetadata';
+
+export default class ResourceFieldMetadataCollection extends MetableCollection {
+  /**
+   * Constructor method.
+   */
+  constructor() {
+    super();
+
+    this.setModel(ResourceFieldMetadata);
+    this.extraColumns = ['resource_id', 'resource_item_id'];
+  }
+}
diff --git a/packages/server/src/collection/SoftDeleteQueryBuilder.ts b/packages/server/src/collection/SoftDeleteQueryBuilder.ts
new file mode 100644
index 000000000..2bd15fe30
--- /dev/null
+++ b/packages/server/src/collection/SoftDeleteQueryBuilder.ts
@@ -0,0 +1,73 @@
+import moment from 'moment';
+import { Model } from 'objection';
+
+const options = {
+  columnName: 'deleted_at',
+  deletedValue: moment().format('YYYY-MM-DD HH:mm:ss'),
+  notDeletedValue: null,
+};
+
+export default class SoftDeleteQueryBuilder extends Model.QueryBuilder {
+  constructor(...args) {
+    super(...args);
+
+    this.onBuild((builder) => {
+      if (builder.isFind() || builder.isDelete() || builder.isUpdate()) {
+        builder.whereNotDeleted();
+      }
+    });
+  }
+
+  /**
+   * override the normal delete function with one that patches the row's "deleted" column
+   */
+  delete() {
+    this.context({
+      softDelete: true,
+    });
+    const patch = {};
+    patch[options.columnName] = options.deletedValue;
+    return this.patch(patch);
+  }
+
+  /**
+   * Provide a way to actually delete the row if necessary
+   */
+  hardDelete() {
+    return super.delete();
+  }
+
+  /**
+   * Provide a way to undo the delete
+   */
+  undelete() {
+    this.context({
+      undelete: true,
+    });
+    const patch = {};
+    patch[options.columnName] = options.notDeletedValue;
+    return this.patch(patch);
+  }
+
+  /**
+   * Provide a way to filter to ONLY deleted records without having to remember the column name
+   */
+  whereDeleted() {
+    const prefix = this.modelClass().tableName;
+
+    // this if is for backwards compatibility, to protect those that used a nullable `deleted` field
+    if (options.deletedValue === true) {
+      return this.where(`${prefix}.${options.columnName}`, options.deletedValue);
+    }
+    // qualify the column name
+    return this.whereNot(`${prefix}.${options.columnName}`, options.notDeletedValue);
+  }
+
+  // provide a way to filter out deleted records without having to remember the column name
+  whereNotDeleted() {
+    const prefix = this.modelClass().tableName;
+
+    // qualify the column name
+    return this.where(`${prefix}.${options.columnName}`, options.notDeletedValue);
+  }
+}  
diff --git a/packages/server/src/config/index.ts b/packages/server/src/config/index.ts
new file mode 100644
index 000000000..b9ff6286c
--- /dev/null
+++ b/packages/server/src/config/index.ts
@@ -0,0 +1,181 @@
+import dotenv from 'dotenv';
+
+// Set the NODE_ENV to 'development' by default
+// process.env.NODE_ENV = process.env.NODE_ENV || 'development';
+
+const envFound = dotenv.config();
+if (envFound.error) {
+  // This error should crash whole process
+  throw new Error("⚠️  Couldn't find .env file  ⚠️");
+}
+
+export default {
+  /**
+   * Your favorite port
+   */
+  port: parseInt(process.env.PORT, 10),
+
+  /**
+   * System database configuration.
+   */
+  system: {
+    db_client: process.env.SYSTEM_DB_CLIENT,
+    db_host: process.env.SYSTEM_DB_HOST,
+    db_user: process.env.SYSTEM_DB_USER,
+    db_password: process.env.SYSTEM_DB_PASSWORD,
+    db_name: process.env.SYSTEM_DB_NAME,
+    charset: process.env.SYSTEM_DB_CHARSET,
+    migrations_dir: process.env.SYSTEM_MIGRATIONS_DIR,
+    seeds_dir: process.env.SYSTEM_SEEDS_DIR,
+  },
+
+  /**
+   * Tenant database configuration.
+   */
+  tenant: {
+    db_client: process.env.TENANT_DB_CLIENT,
+    db_name_prefix: process.env.TENANT_DB_NAME_PERFIX,
+    db_host: process.env.TENANT_DB_HOST,
+    db_user: process.env.TENANT_DB_USER,
+    db_password: process.env.TENANT_DB_PASSWORD,
+    charset: process.env.TENANT_DB_CHARSET,
+    migrations_dir: process.env.TENANT_MIGRATIONS_DIR,
+    seeds_dir: process.env.TENANT_SEEDS_DIR,
+  },
+
+  /**
+   * Databases manager config.
+   */
+  manager: {
+    superUser: process.env.DB_MANAGER_SUPER_USER,
+    superPassword: process.env.DB_MANAGER_SUPER_PASSWORD,
+  },
+
+  /**
+   * Mail.
+   */
+  mail: {
+    host: process.env.MAIL_HOST,
+    port: process.env.MAIL_PORT,
+    secure: !!parseInt(process.env.MAIL_SECURE, 10),
+    username: process.env.MAIL_USERNAME,
+    password: process.env.MAIL_PASSWORD,
+  },
+
+  /**
+   * Mongo DB.
+   */
+  mongoDb: {
+    /**
+     * That long string from mlab
+     */
+    databaseURL: process.env.MONGODB_DATABASE_URL,
+  },
+
+  /**
+   * Agenda
+   */
+  agenda: {
+    dbCollection: process.env.AGENDA_DB_COLLECTION,
+    pooltime: process.env.AGENDA_POOL_TIME,
+    concurrency: parseInt(process.env.AGENDA_CONCURRENCY, 10),
+  },
+
+  /**
+   * Agendash.
+   */
+  agendash: {
+    user: process.env.AGENDASH_AUTH_USER,
+    password: process.env.AGENDASH_AUTH_PASSWORD,
+  },
+
+  /**
+   * Easy SMS gateway.
+   */
+  easySMSGateway: {
+    api_key: process.env.EASY_SMS_TOKEN,
+  },
+
+  /**
+   * JWT secret.
+   */
+  jwtSecret: process.env.JWT_SECRET,
+  resetPasswordSeconds: 600,
+
+  /**
+   *
+   */
+  customerSuccess: {
+    email: 'success@bigcapital.ly',
+    phoneNumber: '(218) 92 791 8381',
+  },
+
+  baseURL: process.env.BASE_URL,
+
+  /**
+   * General API prefix.
+   */
+  api: {
+    prefix: '/api',
+  },
+
+  /**
+   * Licenses api basic authentication.
+   */
+  licensesAuth: {
+    user: process.env.LICENSES_AUTH_USER,
+    password: process.env.LICENSES_AUTH_PASSWORD,
+  },
+
+  /**
+   * Redis storage configuration.
+   */
+  redis: {
+    port: 6379,
+  },
+
+  /**
+   * Throttler configuration.
+   */
+  throttler: {
+    login: {
+      points: 5,
+      duration: 60 * 60 * 24 * 1, // Store number for 90 days since first fail
+      blockDuration: 60 * 15,
+    },
+    requests: {
+      points: 60,
+      duration: 60,
+      blockDuration: 60 * 10,
+    },
+  },
+
+  /**
+   * Users registeration configuration.
+   */
+  registration: {
+    countries: {
+      whitelist: ['LY'],
+      blacklist: [],
+    },
+  },
+
+  /**
+   * Puppeteer remote browserless connection.
+   */
+  puppeteer: {
+    browserWSEndpoint: process.env.BROWSER_WS_ENDPOINT,
+  },
+
+  protocol: '',
+  hostname: '',
+  scheduleComputeItemCost: 'in 5 seconds',
+
+  /**
+   * Latest tenant database batch number.
+   *
+   * Should increment the batch number once you create a new migrations or seeds
+   * to application detarmines to upgrade.
+   */
+  databaseBatch: 4,
+};
diff --git a/packages/server/src/config/knexConfig.ts b/packages/server/src/config/knexConfig.ts
new file mode 100644
index 000000000..2d7631e9b
--- /dev/null
+++ b/packages/server/src/config/knexConfig.ts
@@ -0,0 +1,59 @@
+import config from '@/config';
+import { ITenant } from '@/interfaces';
+
+export const tenantKnexConfig = (tenant: ITenant) => {
+  const { organizationId, id } = tenant;
+
+  return {
+    client: config.tenant.db_client,
+    connection: {
+      host: config.tenant.db_host,
+      user: config.tenant.db_user,
+      password: config.tenant.db_password,
+      database: `${config.tenant.db_name_prefix}${organizationId}`,
+      charset: config.tenant.charset,
+    },
+    migrations: {
+      directory: config.tenant.migrations_dir,
+    },
+    seeds: {
+      tableName: 'bigcapital_seeds',
+      directory: config.tenant.seeds_dir,
+    },
+    pool: { min: 0, max: 5 },
+    userParams: {
+      tenantId: id,
+      organizationId
+    }
+  };
+};
+
+export const systemKnexConfig = {
+  client: config.system.db_client,
+  connection: {
+    host: config.system.db_host,
+    user: config.system.db_user,
+    password: config.system.db_password,
+    database: config.system.db_name,
+    charset: 'utf8',
+  },
+  migrations: {
+    directory: config.system.migrations_dir,
+  },
+  seeds: {
+    directory: config.system.seeds_dir,
+  },
+  pool: { min: 0, max: 7 },
+};
+
+export const systemDbManager = {
+  collate: [],
+  superUser: config.manager.superUser,
+  superPassword: config.manager.superPassword,
+};
+
+export const tenantSeedConfig = (tenant: ITenant) => {
+  return {
+    directory: config.tenant.seeds_dir,
+  };
+}
\ No newline at end of file
diff --git a/packages/server/src/config/smsNotifications.ts b/packages/server/src/config/smsNotifications.ts
new file mode 100644
index 000000000..d63705b7e
--- /dev/null
+++ b/packages/server/src/config/smsNotifications.ts
@@ -0,0 +1,207 @@
+import { ISmsNotificationDefined, SMS_NOTIFICATION_KEY } from '@/interfaces';
+
+export default [
+  {
+    notificationLabel: 'sms_notification.invoice_details.label',
+    notificationDescription: 'sms_notification.invoice_details.description',
+    key: SMS_NOTIFICATION_KEY.SALE_INVOICE_DETAILS,
+    module: 'sale-invoice',
+    moduleFormatted: 'module.sale_invoices.label',
+    allowedVariables: [
+      {
+        variable: 'InvoiceNumber',
+        description: 'sms_notification.invoice.var.invoice_number',
+      },
+      {
+        variable: 'ReferenceNumber',
+        description: 'sms_notification.invoice.var.reference_number',
+      },
+      {
+        variable: 'CustomerName',
+        description: 'sms_notification.invoice.var.customer_name',
+      },
+      {
+        variable: 'DueAmount',
+        description: 'sms_notification.invoice.var.due_amount',
+      },
+      {
+        variable: 'DueDate',
+        description: 'sms_notification.invoice.var.due_date',
+      },
+      {
+        variable: 'Amount',
+        description: 'sms_notification.invoice.var.amount',
+      },
+      {
+        variable: 'CompanyName',
+        description: 'sms_notification.invoice.var.company_name',
+      },
+    ],
+    defaultSmsMessage: 'sms_notification.invoice_details.default_message',
+    defaultIsNotificationEnabled: true,
+  },
+  {
+    notificationLabel: 'sms_notification.invoice_reminder.label',
+    notificationDescription: 'sms_notification.invoice_reminder.description',
+    key: SMS_NOTIFICATION_KEY.SALE_INVOICE_REMINDER,
+    module: 'sale-invoice',
+    moduleFormatted: 'module.sale_invoices.label',
+    allowedVariables: [
+      {
+        variable: 'InvoiceNumber',
+        description: 'sms_notification.invoice.var.invoice_number',
+      },
+      {
+        variable: 'ReferenceNumber',
+        description: 'sms_notification.invoice.var.reference_number',
+      },
+      {
+        variable: 'CustomerName',
+        description: 'sms_notification.invoice.var.customer_name',
+      },
+      {
+        variable: 'DueAmount',
+        description: 'sms_notification.invoice.var.due_amount',
+      },
+      {
+        variable: 'DueDate',
+        description: 'sms_notification.invoice.var.due_date',
+      },
+      {
+        variable: 'Amount',
+        description: 'sms_notification.invoice.var.amount',
+      },
+      {
+        variable: 'CompanyName',
+        description: 'sms_notification.invoice.var.company_name',
+      },
+    ],
+    defaultSmsMessage: 'sms_notification.invoice_reminder.default_message',
+    defaultIsNotificationEnabled: true,
+  },
+  {
+    notificationLabel: 'sms_notification.receipt_details.label',
+    notificationDescription: 'sms_notification.receipt_details.description',
+    key: SMS_NOTIFICATION_KEY.SALE_RECEIPT_DETAILS,
+    module: 'sale-receipt',
+    moduleFormatted: 'module.sale_receipts.label',
+    allowedVariables: [
+      {
+        variable: 'CustomerName',
+        description: 'sms_notification.receipt.var.customer_name',
+      },
+      {
+        variable: 'ReceiptNumber',
+        description: 'sms_notification.receipt.var.receipt_number',
+      },
+      {
+        variable: 'ReferenceNumber',
+        description: 'sms_notification.receipt.var.reference_number',
+      },
+      {
+        variable: 'Amount',
+        description: 'sms_notification.receipt.var.amount',
+      },
+      {
+        variable: 'CompanyName',
+        description: 'sms_notification.receipt.var.company_name',
+      },
+    ],
+    defaultSmsMessage: 'sms_notification.receipt_details.default_message',
+  },
+  {
+    notificationLabel: 'sms_notification.sale_estimate_details.label',
+    notificationDescription: 'sms_notification.estimate_details.description',
+    key: SMS_NOTIFICATION_KEY.SALE_ESTIMATE_DETAILS,
+    module: 'sale-estimate',
+    moduleFormatted: 'module.sale_estimates.label',
+    allowedVariables: [
+      {
+        variable: 'EstimateNumber',
+        description: 'sms_notification.estimate.var.estimate_number',
+      },
+      {
+        variable: 'EstimateDate',
+        description: 'sms_notification.estimate.var.estimate_date',
+      },
+      {
+        variable: 'ExpirationDate',
+        description: 'sms_notification.estimate.var.expiration_date'
+      },
+      {
+        variable: 'ReferenceNumber',
+        description: 'sms_notification.estimate.var.reference_number',
+      },
+      {
+        variable: 'CustomerName',
+        description: 'sms_notification.estimate.var.customer_name',
+      },
+      {
+        variable: 'Amount',
+        description: 'sms_notification.estimate.var.amount',
+      },
+      {
+        variable: 'CompanyName',
+        description: 'sms_notification.estimate.var.company_name',
+      },
+    ],
+    defaultSmsMessage: 'sms_notification.estimate.default_message',
+  },
+  {
+    notificationLabel: 'sms_notification.payment_receive_details.label',
+    notificationDescription: 'sms_notification.payment_receive.description',
+    key: SMS_NOTIFICATION_KEY.PAYMENT_RECEIVE_DETAILS,
+    module: 'payment-receive',
+    moduleFormatted: 'module.payment_receives.label',
+    allowedVariables: [
+      {
+        variable: 'PaymentNumber',
+        description: 'sms_notification.payment.var.payment_number',
+      },
+      {
+        variable: 'ReferenceNumber',
+        description: 'sms_notification.payment.var.reference_number',
+      },
+      {
+        variable: 'CustomerName',
+        description: 'sms_notification.payment.var.customer_name',
+      },
+      {
+        variable: 'Amount',
+        description: 'sms_notification.payment.var.amount',
+      },
+      {
+        variable: 'InvoiceNumber',
+        description: 'sms_notification.payment.var.invoice_number',
+      },
+      {
+        variable: 'CompanyName',
+        description: 'sms_notification.payment.company_name',
+      },
+    ],
+    defaultSmsMessage: 'sms_notification.payment_receive.default_message',
+    defaultIsNotificationEnabled: true,
+  },
+  {
+    notificationLabel: 'sms_notification.customer_balance.label',
+    notificationDescription: 'sms_notification.customer_balance.description',
+    key: SMS_NOTIFICATION_KEY.CUSTOMER_BALANCE,
+    module: 'customer',
+    moduleFormatted: 'module.customers.label',
+    defaultSmsMessage: 'sms_notification.customer_balance.default_message',
+    allowedVariables: [
+      {
+        variable: 'CustomerName',
+        description: 'sms_notification.customer.var.customer_name',
+      },
+      {
+        variable: 'Balance',
+        description: 'sms_notification.customer.var.balance',
+      },
+      {
+        variable: 'CompanyName',
+        description: 'sms_notification.customer.var.company_name',
+      },
+    ],
+  },
+] as ISmsNotificationDefined[];
diff --git a/packages/server/src/data/AccountTypes.ts b/packages/server/src/data/AccountTypes.ts
new file mode 100644
index 000000000..b33148625
--- /dev/null
+++ b/packages/server/src/data/AccountTypes.ts
@@ -0,0 +1,229 @@
+export const ACCOUNT_TYPE = {
+  CASH: 'cash',
+  BANK: 'bank',
+  ACCOUNTS_RECEIVABLE: 'accounts-receivable',
+  INVENTORY: 'inventory',
+  OTHER_CURRENT_ASSET: 'other-current-asset',
+  FIXED_ASSET: 'fixed-asset',
+  NON_CURRENT_ASSET: 'none-current-asset',
+
+  ACCOUNTS_PAYABLE: 'accounts-payable',
+  CREDIT_CARD: 'credit-card',
+  TAX_PAYABLE: 'tax-payable',
+  OTHER_CURRENT_LIABILITY: 'other-current-liability',
+  LOGN_TERM_LIABILITY: 'long-term-liability',
+  NON_CURRENT_LIABILITY: 'non-current-liability',
+
+  EQUITY: 'equity',
+  INCOME: 'income',
+  OTHER_INCOME: 'other-income',
+  COST_OF_GOODS_SOLD: 'cost-of-goods-sold',
+  EXPENSE: 'expense',
+  OTHER_EXPENSE: 'other-expense',
+};
+
+export const ACCOUNT_PARENT_TYPE = {
+  CURRENT_ASSET: 'current-asset',
+  FIXED_ASSET: 'fixed-asset',
+  NON_CURRENT_ASSET: 'non-current-asset',
+
+  CURRENT_LIABILITY: 'current-liability',
+  LOGN_TERM_LIABILITY: 'long-term-liability',
+  NON_CURRENT_LIABILITY: 'non-current-liability',
+
+  EQUITY: 'equity',
+  EXPENSE: 'expense',
+  INCOME: 'income',
+};
+
+export const ACCOUNT_ROOT_TYPE = {
+  ASSET: 'asset',
+  LIABILITY: 'liability',
+  EQUITY: 'equity',
+  EXPENSE: 'expense',
+  INCOME: 'income',
+};
+
+export const ACCOUNT_NORMAL = {
+  CREDIT: 'credit',
+  DEBIT: 'debit',
+};
+export const ACCOUNT_TYPES = [
+  {
+    label: 'Cash',
+    key: ACCOUNT_TYPE.CASH,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_ASSET,
+    rootType: ACCOUNT_ROOT_TYPE.ASSET,
+    multiCurrency: true,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Bank',
+    key: ACCOUNT_TYPE.BANK,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_ASSET,
+    rootType: ACCOUNT_ROOT_TYPE.ASSET,
+    multiCurrency: true,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Accounts Receivable',
+    key: ACCOUNT_TYPE.ACCOUNTS_RECEIVABLE,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.ASSET,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_ASSET,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Inventory',
+    key: ACCOUNT_TYPE.INVENTORY,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.ASSET,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_ASSET,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Other Current Asset',
+    key: ACCOUNT_TYPE.OTHER_CURRENT_ASSET,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.ASSET,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_ASSET,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Fixed Asset',
+    key: ACCOUNT_TYPE.FIXED_ASSET,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.ASSET,
+    parentType: ACCOUNT_PARENT_TYPE.FIXED_ASSET,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Non-Current Asset',
+    key: ACCOUNT_TYPE.NON_CURRENT_ASSET,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.ASSET,
+    parentType: ACCOUNT_PARENT_TYPE.FIXED_ASSET,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Accounts Payable',
+    key: ACCOUNT_TYPE.ACCOUNTS_PAYABLE,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.LIABILITY,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_LIABILITY,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Credit Card',
+    key: ACCOUNT_TYPE.CREDIT_CARD,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.LIABILITY,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_LIABILITY,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Tax Payable',
+    key: ACCOUNT_TYPE.TAX_PAYABLE,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.LIABILITY,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_LIABILITY,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Other Current Liability',
+    key: ACCOUNT_TYPE.OTHER_CURRENT_LIABILITY,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.LIABILITY,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_LIABILITY,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+  {
+    label: 'Long Term Liability',
+    key: ACCOUNT_TYPE.LOGN_TERM_LIABILITY,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.LIABILITY,
+    parentType: ACCOUNT_PARENT_TYPE.LOGN_TERM_LIABILITY,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+  {
+    label: 'Non-Current Liability',
+    key: ACCOUNT_TYPE.NON_CURRENT_LIABILITY,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.LIABILITY,
+    parentType: ACCOUNT_PARENT_TYPE.NON_CURRENT_LIABILITY,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+  {
+    label: 'Equity',
+    key: ACCOUNT_TYPE.EQUITY,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.EQUITY,
+    parentType: ACCOUNT_PARENT_TYPE.EQUITY,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Income',
+    key: ACCOUNT_TYPE.INCOME,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.INCOME,
+    parentType: ACCOUNT_PARENT_TYPE.INCOME,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+  {
+    label: 'Other Income',
+    key: ACCOUNT_TYPE.OTHER_INCOME,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.INCOME,
+    parentType: ACCOUNT_PARENT_TYPE.INCOME,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+  {
+    label: 'Cost of Goods Sold',
+    key: ACCOUNT_TYPE.COST_OF_GOODS_SOLD,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.EXPENSE,
+    parentType: ACCOUNT_PARENT_TYPE.EXPENSE,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+  {
+    label: 'Expense',
+    key: ACCOUNT_TYPE.EXPENSE,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.EXPENSE,
+    parentType: ACCOUNT_PARENT_TYPE.EXPENSE,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+  {
+    label: 'Other Expense',
+    key: ACCOUNT_TYPE.OTHER_EXPENSE,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.EXPENSE,
+    parentType: ACCOUNT_PARENT_TYPE.EXPENSE,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+];
+
+export const getAccountsSupportsMultiCurrency = () => {
+  return ACCOUNT_TYPES.filter((account) => account.multiCurrency);
+};
diff --git a/packages/server/src/data/BalanceSheetStructure.ts b/packages/server/src/data/BalanceSheetStructure.ts
new file mode 100644
index 000000000..dc9b215d5
--- /dev/null
+++ b/packages/server/src/data/BalanceSheetStructure.ts
@@ -0,0 +1,96 @@
+import { IBalanceSheetStructureSection } from '@/interfaces';
+import {
+  ACCOUNT_TYPE
+} from '@/data/AccountTypes';
+
+const balanceSheetStructure: IBalanceSheetStructureSection[] = [
+  {
+    name: 'Assets',
+    sectionType: 'assets',
+    type: 'section',
+    children: [
+      {
+        name: 'Current Asset',
+        sectionType: 'assets',
+        type: 'section',
+        children: [
+          {
+            name: 'Cash and cash equivalents',
+            type: 'accounts_section',
+            accountsTypes: [ACCOUNT_TYPE.CASH, ACCOUNT_TYPE.BANK],
+          },
+          {
+            name: 'Accounts Receivable',
+            type: 'accounts_section',
+            accountsTypes: [ACCOUNT_TYPE.ACCOUNTS_RECEIVABLE],
+          },
+          {
+            name: 'Inventories',
+            type: 'accounts_section',
+            accountsTypes: [ACCOUNT_TYPE.INVENTORY],
+          },
+          {
+            name: 'Other current assets',
+            type: 'accounts_section',
+            accountsTypes: [ACCOUNT_TYPE.OTHER_CURRENT_ASSET],
+          },
+        ],
+        alwaysShow: true,
+      },
+      {
+        name: 'Fixed Asset',
+        type: 'accounts_section',
+        accountsTypes: [ACCOUNT_TYPE.FIXED_ASSET],
+      },
+      {
+        name: 'Non-Current Assets',
+        type: 'accounts_section',
+        accountsTypes: [ACCOUNT_TYPE.NON_CURRENT_ASSET],
+      }
+    ],
+    alwaysShow: true,
+  },
+  {
+    name: 'Liabilities and Equity',
+    sectionType: 'liabilities_equity',
+    type: 'section',
+    children: [
+      {
+        name: 'Liabilities',
+        sectionType: 'liability',
+        type: 'section',
+        children: [
+          {
+            name: 'Current Liabilties',
+            type: 'accounts_section',
+            accountsTypes: [
+              ACCOUNT_TYPE.ACCOUNTS_PAYABLE,
+              ACCOUNT_TYPE.TAX_PAYABLE,
+              ACCOUNT_TYPE.CREDIT_CARD,
+              ACCOUNT_TYPE.OTHER_CURRENT_LIABILITY,
+            ],
+          },
+          {
+            name: 'Long-Term Liabilities',
+            type: 'accounts_section',
+            accountsTypes: [ACCOUNT_TYPE.LOGN_TERM_LIABILITY],
+          },
+          {
+            name: 'Non-Current Liabilities',
+            type: 'accounts_section',
+            accountsTypes: [ACCOUNT_TYPE.NON_CURRENT_LIABILITY],
+          }
+        ],
+      },
+      {
+        name: 'Equity',
+        sectionType: 'equity',
+        type: 'accounts_section',
+        accountsTypes: [ACCOUNT_TYPE.EQUITY],
+      },
+    ],
+    alwaysShow: true,
+  },
+];
+
+export default balanceSheetStructure;
\ No newline at end of file
diff --git a/packages/server/src/data/DataTypes.ts b/packages/server/src/data/DataTypes.ts
new file mode 100644
index 000000000..d5ab1086f
--- /dev/null
+++ b/packages/server/src/data/DataTypes.ts
@@ -0,0 +1,8 @@
+
+export const DATATYPES_LENGTH = {
+  STRING: 255,
+  TEXT: 65535,
+  INT_10: 4294967295,
+  DECIMAL_13_3: 9999999999.999,
+  DECIMAL_15_5: 999999999999.999,
+};
diff --git a/packages/server/src/data/ResourceFieldsKeys.ts b/packages/server/src/data/ResourceFieldsKeys.ts
new file mode 100644
index 000000000..8504d3fdf
--- /dev/null
+++ b/packages/server/src/data/ResourceFieldsKeys.ts
@@ -0,0 +1,205 @@
+/* eslint-disable quote-props */
+
+export default {
+  // Expenses.
+  expense: {
+    payment_date: {
+      column: 'payment_date',
+    },
+    payment_account: {
+      column: 'payment_account_id',
+      relation: 'accounts.id',
+    },
+    amount: {
+      column: 'total_amount',
+    },
+    currency_code: {
+      column: 'currency_code',
+    },
+    reference_no: {
+      column: 'reference_no'
+    },
+    description: {
+      column: 'description',
+    },
+    published: {
+      column: 'published',
+    },
+    user: {
+      column: 'user_id',
+      relation: 'users.id',
+      relationColumn: 'users.id',
+    },
+  },
+
+  // Accounts
+  Account: {
+    name: {
+      column: 'name',
+    },
+    type: {
+      column: 'account_type_id',
+      relation: 'account_types.id',
+      relationColumn: 'account_types.key',
+    },
+    description: {
+      column: 'description',
+    },
+    code: {
+      column: 'code',
+    },
+    root_type: {
+      column: 'account_type_id',
+      relation: 'account_types.id',
+      relationColumn: 'account_types.root_type',
+    },
+    created_at: {
+      column: 'created_at',
+      columnType: 'date',
+    },
+    active: {
+      column: 'active', 
+    },
+    balance: {
+      column: 'amount',
+      columnType: 'number'
+    },
+    currency: {
+      column: 'currency_code',
+    },
+    normal: {
+      column: 'account_type_id',
+      relation: 'account_types.id',
+      relationColumn: 'account_types.normal'
+    },
+  },
+
+  // Items
+  item: {
+    type: {
+      column: 'type',
+    },
+    name: {
+      column: 'name',
+    },
+    sellable: {
+      column: 'sellable',
+    },
+    purchasable: {
+      column: 'purchasable',
+    },
+    sell_price: {
+      column: 'sell_price'
+    },
+    cost_price: {
+      column: 'cost_price',
+    },
+    currency_code: {
+      column: 'currency_code',
+    },
+    cost_account: {
+      column: 'cost_account_id',
+      relation: 'accounts.id',
+    },
+    sell_account: {
+      column: 'sell_account_id',
+      relation: 'accounts.id',
+    },
+    inventory_account: {
+      column: 'inventory_account_id',
+      relation: 'accounts.id',
+    },
+    sell_description: {
+      column: 'sell_description',
+    },
+    purchase_description: {
+      column: 'purchase_description',
+    },
+    quantity_on_hand: {
+      column: 'quantity_on_hand',
+    },
+    note: {
+      column: 'note',
+    },
+    category: {
+      column: 'category_id',
+      relation: 'categories.id',
+    },
+    user: {
+      column: 'user_id',
+      relation: 'users.id',
+      relationColumn: 'users.id',
+    },
+    created_at: {
+      column: 'created_at',
+    }
+  },
+
+  // Item category.
+  item_category: {
+    name: {
+      column: 'name',
+    },
+    description: {
+      column: 'description',
+    },
+    parent_category_id: {
+      column: 'parent_category_id',
+      relation: 'items_categories.id',
+      relationColumn: 'items_categories.id',
+    },
+    user: {
+      column: 'user_id',
+      relation: 'users.id',
+      relationColumn: 'users.id',
+    },
+    cost_account: {
+      column: 'cost_account_id',
+      relation: 'accounts.id',
+    },
+    sell_account: {
+      column: 'sell_account_id',
+      relation: 'accounts.id',
+    },
+    inventory_account: {
+      column: 'inventory_account_id',
+      relation: 'accounts.id',
+    },
+    cost_method: {
+      column: 'cost_method',
+    },
+  },
+
+  // Manual Journals
+  manual_journal: {
+    date: {
+      column: 'date',
+    },
+    journal_number: {
+      column: 'journal_number',
+    },
+    reference: {
+      column: 'reference',
+    },
+    status: {
+      column: 'status',
+    },
+    amount: {
+      column: 'amount',
+    },
+    description: {
+      column: 'description',
+    },
+    user: {
+      column: 'user_id',
+      relation: 'users.id',
+      relationColumn: 'users.id',
+    },
+    journal_type: {
+      column: 'journal_type',
+    },
+    created_at: {
+      column: 'created_at',
+    },
+  }
+};
diff --git a/packages/server/src/data/options.ts b/packages/server/src/data/options.ts
new file mode 100644
index 000000000..023628ef8
--- /dev/null
+++ b/packages/server/src/data/options.ts
@@ -0,0 +1,212 @@
+import { getTransactionsLockingSettingsSchema } from '@/api/controllers/TransactionsLocking/utils';
+
+export default {
+  organization: {
+    name: {
+      type: 'string',
+    },
+    base_currency: {
+      type: 'string',
+    },
+    industry: {
+      type: 'string',
+    },
+    location: {
+      type: 'string',
+    },
+    fiscal_year: {
+      type: 'string',
+    },
+    financial_date_start: {
+      type: 'string',
+    },
+    language: {
+      type: 'string',
+    },
+    time_zone: {
+      type: 'string',
+    },
+    date_format: {
+      type: 'string',
+    },
+    accounting_basis: {
+      type: 'string',
+    },
+  },
+  manual_journals: {
+    next_number: {
+      type: 'string',
+    },
+    number_prefix: {
+      type: 'string',
+    },
+    auto_increment: {
+      type: 'boolean',
+    },
+  },
+  bill_payments: {
+    withdrawal_account: {
+      type: 'number',
+    },
+  },
+  sales_estimates: {
+    next_number: {
+      type: 'string',
+    },
+    number_prefix: {
+      type: 'string',
+    },
+    auto_increment: {
+      type: 'boolean',
+    },
+  },
+  sales_receipts: {
+    next_number: {
+      type: 'string',
+    },
+    number_prefix: {
+      type: 'string',
+    },
+    auto_increment: {
+      type: 'boolean',
+    },
+    preferred_deposit_account: {
+      type: 'number',
+    },
+  },
+  sales_invoices: {
+    next_number: {
+      type: 'string',
+    },
+    number_prefix: {
+      type: 'string',
+    },
+    auto_increment: {
+      type: 'boolean',
+    },
+  },
+  payment_receives: {
+    next_number: {
+      type: 'string',
+    },
+    number_prefix: {
+      type: 'string',
+    },
+    auto_increment: {
+      type: 'boolean',
+    },
+    preferred_deposit_account: {
+      type: 'number',
+    },
+    preferred_advance_deposit: {
+      type: 'number',
+    },
+  },
+  items: {
+    preferred_sell_account: {
+      type: 'number',
+    },
+    preferred_cost_account: {
+      type: 'number',
+    },
+    preferred_inventory_account: {
+      type: 'number',
+    },
+  },
+  expenses: {
+    preferred_payment_account: {
+      type: 'number',
+    },
+  },
+  accounts: {
+    account_code_required: {
+      type: 'boolean',
+    },
+    account_code_unique: {
+      type: 'boolean',
+    },
+  },
+  cashflow: {
+    next_number: {
+      type: 'string',
+    },
+    number_prefix: {
+      type: 'string',
+    },
+    auto_increment: {
+      type: 'boolean',
+    },
+  },
+  credit_note: {
+    next_number: {
+      type: 'string',
+    },
+    number_prefix: {
+      type: 'string',
+    },
+    auto_increment: {
+      type: 'boolean',
+    },
+  },
+  vendor_credit: {
+    next_number: {
+      type: 'string',
+    },
+    number_prefix: {
+      type: 'string',
+    },
+    auto_increment: {
+      type: 'boolean',
+    },
+  },
+  warehouse_transfers: {
+    next_number: {
+      type: 'string',
+    },
+    number_prefix: {
+      type: 'string',
+    },
+    auto_increment: {
+      type: 'boolean',
+    },
+  },
+  'sms-notification': {
+    'sms-notification-enable.sale-invoice-details': {
+      type: 'boolean',
+    },
+    'sms-notification-enable.sale-invoice-reminder': {
+      type: 'boolean',
+    },
+    'sms-notification-enable.sale-estimate-details': {
+      type: 'boolean',
+    },
+    'sms-notification-enable.sale-receipt-details': {
+      type: 'boolean',
+    },
+    'sms-notification-enable.payment-receive-details': {
+      type: 'boolean',
+    },
+    'sms-notification-enable.customer-balance': {
+      type: 'boolean',
+    },
+  },
+  'transactions-locking': {
+    'locking-type': {
+      type: 'string',
+    },
+    ...getTransactionsLockingSettingsSchema([
+      'all',
+      'sales',
+      'purchases',
+      'financial',
+    ]),
+  },
+  features: {
+    'multi-warehouses': {
+      type: 'boolean',
+    },
+    'multi-branches': {
+      type: 'boolean',
+    },
+  },
+};
diff --git a/packages/server/src/database/factories/index.js b/packages/server/src/database/factories/index.js
new file mode 100644
index 000000000..641db7470
--- /dev/null
+++ b/packages/server/src/database/factories/index.js
@@ -0,0 +1,390 @@
+import KnexFactory from '@/lib/KnexFactory';
+import faker from 'faker';
+import { hashPassword } from 'utils';
+
+
+export default (tenantDb) => {
+  const factory = new KnexFactory(tenantDb);
+
+  factory.define('user', 'users', async () => {
+    // const hashedPassword = await hashPassword('admin');
+
+    return {
+      first_name: faker.name.firstName(),
+      last_name: faker.name.lastName(),
+      email: faker.internet.email(),
+      phone_number: faker.phone.phoneNumberFormat().replace('-', ''),
+      active: 1,
+      // password: hashedPassword,
+    };
+  });
+
+  factory.define('password_reset', 'password_resets', async () => {
+    return {
+      user_id: null,
+      token: faker.lorem.slug,
+    };
+  });
+
+  factory.define('account_type', 'account_types', async () => ({
+    name: faker.lorem.words(2),
+    normal: 'debit',
+  }));
+
+  factory.define('account_balance', 'account_balances', async () => {
+    const account = await factory.create('account');
+
+    return {
+      account_id: account.id,
+      amount: faker.random.number(),
+      currency_code: 'USD',
+    };
+  });
+
+  factory.define('account', 'accounts', async () => {
+    const accountType = await factory.create('account_type');
+    return {
+      name: faker.lorem.word(),
+      code: faker.random.number(),
+      account_type_id: accountType.id,
+      description: faker.lorem.paragraph(),
+    };
+  });
+
+  factory.define('account_transaction', 'accounts_transactions', async () => {
+    const account = await factory.create('account');
+    const user = await factory.create('user');
+
+    return {
+      account_id: account.id,
+      credit: faker.random.number(),
+      debit: 0,
+      user_id: user.id,
+    };
+  });
+
+  factory.define('manual_journal', 'manual_journals', async () => {
+    const user = await factory.create('user');
+
+    return {
+      journal_number: faker.random.number(),
+      transaction_type: '',
+      amount: faker.random.number(),
+      date: faker.date.future,
+      status: 1,
+      user_id: user.id,
+    };
+  });
+
+  factory.define('item_category', 'items_categories', () => ({
+    name: faker.name.firstName(),
+    description: faker.lorem.text(),
+    parent_category_id: null,
+  }));
+
+  factory.define('item_metadata', 'items_metadata', async () => {
+    const item = await factory.create('item');
+
+    return {
+      key: faker.lorem.slug(),
+      value: faker.lorem.word(),
+      item_id: item.id,
+    };
+  });
+
+  factory.define('item', 'items', async () => {
+    const category = await factory.create('item_category');
+    const costAccount = await factory.create('account');
+    const sellAccount = await factory.create('account');
+    const inventoryAccount = await factory.create('account');
+
+    return {
+      name: faker.lorem.word(),
+      note: faker.lorem.paragraph(),
+      cost_price: faker.random.number(),
+      sell_price: faker.random.number(),
+      cost_account_id: costAccount.id,
+      sell_account_id: sellAccount.id,
+      inventory_account_id: inventoryAccount.id,
+      category_id: category.id,
+    };
+  });
+
+  factory.define('setting', 'settings', async () => {
+    const user = await factory.create('user');
+    return {
+      key: faker.lorem.slug(),
+      user_id: user.id,
+      type: 'string',
+      value: faker.lorem.words(),
+      group: 'default',
+    };
+  });
+
+  factory.define('role', 'roles', async () => ({
+    name: faker.lorem.word(),
+    description: faker.lorem.words(),
+    predefined: false,
+  }));
+
+  factory.define('user_has_role', 'user_has_roles', async () => {
+    const user = await factory.create('user');
+    const role = await factory.create('role');
+
+    return {
+      user_id: user.id,
+      role_id: role.id,
+    };
+  });
+
+  factory.define('permission', 'permissions', async () => {
+    const permissions = ['create', 'edit', 'delete', 'view', 'owner'];
+    const randomPermission = permissions[Math.floor(Math.random() * permissions.length)];
+
+    return {
+      name: randomPermission,
+    };
+  });
+
+  factory.define('role_has_permission', 'role_has_permissions', async () => {
+    const permission = await factory.create('permission');
+    const role = await factory.create('role');
+    const resource = await factory.create('resource');
+
+    return {
+      role_id: role.id,
+      permission_id: permission.id,
+      resource_id: resource.id,
+    };
+  });
+
+  factory.define('resource', 'resources', () => ({
+    name: faker.lorem.word(),
+  }));
+
+  factory.define('view', 'views', async () => {
+    const resource = await factory.create('resource');
+    return {
+      name: faker.lorem.word(),
+      resource_id: resource.id,
+      predefined: false,
+    };
+  });
+
+  factory.define('resource_field', 'resource_fields', async () => {
+    const resource = await factory.create('resource');
+    const dataTypes = ['select', 'date', 'text'];
+
+    return {
+      label_name: faker.lorem.words(),
+      key: faker.lorem.slug(),
+      data_type: dataTypes[Math.floor(Math.random() * dataTypes.length)],
+      help_text: faker.lorem.words(),
+      default: faker.lorem.word(),
+      resource_id: resource.id,
+      active: true,
+      columnable: true,
+      predefined: false,
+    };
+  });
+
+  factory.define('resource_custom_field_metadata', 'resource_custom_fields_metadata', async () => {
+    const resource = await factory.create('resource');
+
+    return {
+      resource_id: resource.id,
+      resource_item_id: 1,
+      key: faker.lorem.words(),
+      value: faker.lorem.words(),
+    };
+  });
+
+  factory.define('view_role', 'view_roles', async () => {
+    const view = await factory.create('view');
+    const field = await factory.create('resource_field');
+
+    return {
+      view_id: view.id,
+      index: faker.random.number(),
+      field_id: field.id,
+      value: '',
+      comparator: '',
+    };
+  });
+
+  factory.define('view_column', 'view_has_columns', async () => {
+    const view = await factory.create('view');
+    const field = await factory.create('resource_field');
+
+    return {
+      field_id: field.id,
+      view_id: view.id,
+      // index: 1,
+    };
+  });
+
+  factory.define('expense', 'expenses_transactions', async () => {
+    const paymentAccount = await factory.create('account');
+    const expenseAccount = await factory.create('account');
+    const user = await factory.create('user');
+
+    return {
+      total_amount: faker.random.number(),
+      currency_code: 'USD',
+      description: '',
+      reference_no: faker.random.number(),
+      payment_account_id: paymentAccount.id,
+      published: true,
+      user_id: user.id,
+    };
+  });
+
+  factory.define('expense_category', 'expense_transaction_categories', async () => {
+    const expense = await factory.create('expense');
+
+    return {
+      expense_account_id: expense.id,
+      description: '',
+      amount: faker.random.number(),
+      expense_id: expense.id,
+    };
+  });
+
+  factory.define('option', 'options', async () => {
+    return {
+      key: faker.lorem.slug(),
+      value: faker.lorem.slug(),
+      group: faker.lorem.slug(),
+    };
+  });
+
+  factory.define('currency', 'currencies', async () => {
+    return {
+      currency_name: faker.lorem.slug(),
+      currency_code: 'USD',
+    };
+  });
+
+  factory.define('exchange_rate', 'exchange_rates', async () => {
+    return {
+      date: '2020-02-02',
+      currency_code: 'USD',
+      exchange_rate: faker.random.number(),
+    };
+  });
+
+  factory.define('budget', 'budgets', async () => {
+    return {
+      name: faker.lorem.slug(),
+      fiscal_year: '2020',
+      period: 'month',
+      account_types: 'profit_loss',
+    };
+  });
+
+  factory.define('budget_entry', 'budget_entries', async () => {
+    const budget = await factory.create('budget');
+    const account = await factory.create('account');
+
+    return {
+      account_id: account.id,
+      budget_id: budget.id,
+      amount: 1000,
+      order: 1,
+    };
+  });
+
+  factory.define('customer', 'customers', async () => {
+    return {
+      customer_type: 'business',
+    };
+  });
+
+  factory.define('vendor', 'vendors', async () => {
+    return {
+      customer_type: 'business',
+    };
+  });
+
+  factory.define('sale_estimate', 'sales_estimates', async () => {
+    const customer = await factory.create('customer');
+
+    return {
+      customer_id: customer.id,
+      estimate_date: faker.date.past,
+      expiration_date: faker.date.future,
+      reference: '',
+      estimate_number: faker.random.number,
+      note: '',
+      terms_conditions: '',
+    };
+  });
+
+  factory.define('sale_estimate_entry', 'sales_estimate_entries', async () => {
+    const estimate = await factory.create('sale_estimate');
+    const item = await factory.create('item');
+
+    return {
+      estimate_id: estimate.id,
+      item_id: item.id,
+      description: '',
+      discount: faker.random.number,
+      quantity: faker.random.number,
+      rate: faker.random.number,
+    };
+  });
+
+  factory.define('sale_receipt', 'sales_receipts', async () => {
+    const depositAccount = await factory.create('account');
+    const customer = await factory.create('customer');
+
+    return {
+      deposit_account_id: depositAccount.id,
+      customer_id: customer.id,
+      reference_no: faker.random.number,
+      receipt_date: faker.date.past,
+    };
+  });
+
+  factory.define('sale_receipt_entry', 'sales_receipt_entries', async () => {
+    const saleReceipt = await factory.create('sale_receipt');
+    const item = await factory.create('item');
+
+    return {
+      sale_receipt_id: saleReceipt.id,
+      item_id: item.id,
+      rate: faker.random.number,
+      quantity: faker.random.number,
+    };
+  });
+
+  factory.define('sale_invoice', 'sales_invoices', async () => {
+
+    return {
+
+    };
+  });
+
+  factory.define('sale_invoice_entry', 'sales_invoices_entries', async () => {
+    return {
+
+    };
+  });
+
+  factory.define('payment_receive', 'payment_receives', async () => {
+
+  });
+
+  factory.define('payment_receive_entry', 'payment_receives_entries', async () => {
+
+  });
+
+
+  factory.define('bill', 'bills', async () => {
+    return {
+      
+    }
+  });
+
+  return factory;
+}
diff --git a/packages/server/src/database/factories/system.js b/packages/server/src/database/factories/system.js
new file mode 100644
index 000000000..ccde0f943
--- /dev/null
+++ b/packages/server/src/database/factories/system.js
@@ -0,0 +1,16 @@
+import KnexFactory from '@/lib/KnexFactory';
+import systemDb from '@/database/knex';
+import faker from 'faker';
+
+export default () => {
+  const factory = new KnexFactory(systemDb);
+
+  factory.define('password_reset', 'password_resets', async () => {
+    return {
+      email: faker.lorem.email,
+      token: faker.lorem.slug,
+    };
+  });
+
+  return factory;
+};
\ No newline at end of file
diff --git a/packages/server/src/database/migrations/20190822214303_create_accounts_table.js b/packages/server/src/database/migrations/20190822214303_create_accounts_table.js
new file mode 100644
index 000000000..81abcaf26
--- /dev/null
+++ b/packages/server/src/database/migrations/20190822214303_create_accounts_table.js
@@ -0,0 +1,19 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('accounts', (table) => {
+    table.increments('id').comment('Auto-generated id');
+    table.string('name').index();
+    table.string('slug');
+    table.string('account_type').index();
+    table.integer('parent_account_id').unsigned().references('id').inTable('accounts');
+    table.string('code', 10).index();
+    table.text('description');
+    table.boolean('active').defaultTo(true).index();
+    table.integer('index').unsigned();
+    table.boolean('predefined').defaultTo(false).index();
+    table.decimal('amount', 15, 5);
+    table.string('currency_code', 3).index();
+    table.timestamps();
+  }).raw('ALTER TABLE `ACCOUNTS` AUTO_INCREMENT = 1000');
+};
+
+exports.down = (knex) => knex.schema.dropTableIfExists('accounts');
diff --git a/packages/server/src/database/migrations/20190822214304_create_items_categories_table.js b/packages/server/src/database/migrations/20190822214304_create_items_categories_table.js
new file mode 100644
index 000000000..2fe1ec9ef
--- /dev/null
+++ b/packages/server/src/database/migrations/20190822214304_create_items_categories_table.js
@@ -0,0 +1,19 @@
+
+exports.up = function (knex) {
+  return knex.schema.createTable('items_categories', (table) => {
+    table.increments();
+    table.string('name').index();
+   
+    table.text('description');
+    table.integer('user_id').unsigned().index();
+
+    table.integer('cost_account_id').unsigned().references('id').inTable('accounts');
+    table.integer('sell_account_id').unsigned().references('id').inTable('accounts');
+    table.integer('inventory_account_id').unsigned().references('id').inTable('accounts');
+
+    table.string('cost_method');
+    table.timestamps();
+  });
+};
+
+exports.down = (knex) => knex.schema.dropTableIfExists('items_categories');
diff --git a/packages/server/src/database/migrations/20190822214306_create_items_table.js b/packages/server/src/database/migrations/20190822214306_create_items_table.js
new file mode 100644
index 000000000..16ac1ed66
--- /dev/null
+++ b/packages/server/src/database/migrations/20190822214306_create_items_table.js
@@ -0,0 +1,30 @@
+
+exports.up = function (knex) {
+  return knex.schema.createTable('items', (table) => {
+    table.increments();
+    table.string('name').index();
+    table.string('type').index();
+    table.string('code');
+    table.boolean('sellable').index();
+    table.boolean('purchasable').index();
+    table.decimal('sell_price', 13, 3).unsigned();
+    table.decimal('cost_price', 13, 3).unsigned();
+    table.string('currency_code', 3);
+    table.string('picture_uri');
+    table.integer('cost_account_id').nullable().unsigned().references('id').inTable('accounts');
+    table.integer('sell_account_id').nullable().unsigned().references('id').inTable('accounts');
+    table.integer('inventory_account_id').unsigned().references('id').inTable('accounts');
+    table.text('sell_description').nullable();
+    table.text('purchase_description').nullable();
+    table.integer('quantity_on_hand');
+    table.boolean('landed_cost').nullable();
+
+    table.text('note').nullable();
+    table.boolean('active');
+    table.integer('category_id').unsigned().index().references('id').inTable('items_categories');
+    table.integer('user_id').unsigned().index();
+    table.timestamps();
+  }).raw('ALTER TABLE `ITEMS` AUTO_INCREMENT = 1000');
+};
+
+exports.down = (knex) => knex.schema.dropTableIfExists('items');
diff --git a/packages/server/src/database/migrations/20190822214903_create_views_table.js b/packages/server/src/database/migrations/20190822214903_create_views_table.js
new file mode 100644
index 000000000..eb3929c47
--- /dev/null
+++ b/packages/server/src/database/migrations/20190822214903_create_views_table.js
@@ -0,0 +1,15 @@
+
+exports.up = function (knex) {
+  return knex.schema.createTable('views', (table) => {
+    table.increments();
+    table.string('name').index();
+    table.string('slug').index();
+    table.boolean('predefined');
+    table.string('resource_model').index();
+    table.boolean('favourite');
+    table.string('roles_logic_expression');
+    table.timestamps();
+  }).raw('ALTER TABLE `VIEWS` AUTO_INCREMENT = 1000');
+};
+
+exports.down = (knex) => knex.schema.dropTableIfExists('views');
diff --git a/packages/server/src/database/migrations/20190822214904_create_settings_table.js b/packages/server/src/database/migrations/20190822214904_create_settings_table.js
new file mode 100644
index 000000000..65f3f4fdc
--- /dev/null
+++ b/packages/server/src/database/migrations/20190822214904_create_settings_table.js
@@ -0,0 +1,13 @@
+
+exports.up = function (knex) {
+  return knex.schema.createTable('settings', (table) => {
+    table.increments();
+    table.integer('user_id').unsigned().index();
+    table.string('group').index();
+    table.string('type');
+    table.string('key').index();
+    table.string('value');
+  }).raw('ALTER TABLE `SETTINGS` AUTO_INCREMENT = 2000');
+};
+
+exports.down = (knex) => knex.schema.dropTableIfExists('settings');
diff --git a/packages/server/src/database/migrations/20190822214905_create_views_columns.js b/packages/server/src/database/migrations/20190822214905_create_views_columns.js
new file mode 100644
index 000000000..4fc76e399
--- /dev/null
+++ b/packages/server/src/database/migrations/20190822214905_create_views_columns.js
@@ -0,0 +1,11 @@
+
+exports.up = function (knex) {
+  return knex.schema.createTable('view_has_columns', (table) => {
+    table.increments();
+    table.integer('view_id').unsigned().index().references('id').inTable('views');
+    table.string('field_key');
+    table.integer('index').unsigned();
+  }).raw('ALTER TABLE `ITEMS_CATEGORIES` AUTO_INCREMENT = 1000');
+};
+
+exports.down = (knex) => knex.schema.dropTableIfExists('view_has_columns');
diff --git a/packages/server/src/database/migrations/20190822214905_create_views_roles_table.js b/packages/server/src/database/migrations/20190822214905_create_views_roles_table.js
new file mode 100644
index 000000000..4167514c3
--- /dev/null
+++ b/packages/server/src/database/migrations/20190822214905_create_views_roles_table.js
@@ -0,0 +1,19 @@
+exports.up = function (knex) {
+  return knex.schema
+    .createTable('view_roles', (table) => {
+      table.increments();
+      table.integer('index');
+      table.string('field_key').index();
+      table.string('comparator');
+      table.string('value');
+      table
+        .integer('view_id')
+        .unsigned()
+        .index()
+        .references('id')
+        .inTable('views');
+    })
+    .raw('ALTER TABLE `VIEW_ROLES` AUTO_INCREMENT = 1000');
+};
+
+exports.down = (knex) => knex.schema.dropTableIfExists('view_roles');
diff --git a/packages/server/src/database/migrations/20200104232644_create_contacts_table.js b/packages/server/src/database/migrations/20200104232644_create_contacts_table.js
new file mode 100644
index 000000000..09e0accde
--- /dev/null
+++ b/packages/server/src/database/migrations/20200104232644_create_contacts_table.js
@@ -0,0 +1,54 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('contacts', table => {
+    table.increments();
+
+    table.string('contact_service');
+    table.string('contact_type');
+
+    table.decimal('balance', 13, 3).defaultTo(0);
+    table.string('currency_code', 3);
+
+    table.decimal('opening_balance', 13, 3).defaultTo(0);
+    table.date('opening_balance_at');
+
+    table.string('salutation').nullable();
+    table.string('first_name').nullable();
+    table.string('last_name').nullable();
+    table.string('company_name').nullable();
+
+    table.string('display_name');
+
+    table.string('email').nullable();
+    table.string('work_phone').nullable();
+    table.string('personal_phone').nullable();
+    table.string('website').nullable();
+
+    table.string('billing_address_1').nullable();
+    table.string('billing_address_2').nullable();
+    table.string('billing_address_city').nullable();
+    table.string('billing_address_country').nullable();
+    table.string('billing_address_email').nullable();
+    table.string('billing_address_postcode').nullable();
+    table.string('billing_address_phone').nullable();
+    table.string('billing_address_state').nullable(),
+
+    table.string('shipping_address_1').nullable();
+    table.string('shipping_address_2').nullable();
+    table.string('shipping_address_city').nullable();
+    table.string('shipping_address_country').nullable();
+    table.string('shipping_address_email').nullable();
+    table.string('shipping_address_postcode').nullable();
+    table.string('shipping_address_phone').nullable();
+    table.string('shipping_address_state').nullable();
+
+    table.text('note');
+    table.boolean('active').defaultTo(true);
+
+    table.timestamps();
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('contacts');
+};
diff --git a/packages/server/src/database/migrations/20200104232647_create_accounts_transactions_table.js b/packages/server/src/database/migrations/20200104232647_create_accounts_transactions_table.js
new file mode 100644
index 000000000..50fe6d396
--- /dev/null
+++ b/packages/server/src/database/migrations/20200104232647_create_accounts_transactions_table.js
@@ -0,0 +1,36 @@
+exports.up = function (knex) {
+  return knex.schema
+    .createTable('accounts_transactions', (table) => {
+      table.increments();
+      table.decimal('credit', 13, 3);
+      table.decimal('debit', 13, 3);
+      table.string('transaction_type').index();
+      table.string('reference_type').index();
+      table.integer('reference_id').index();
+      table
+        .integer('account_id')
+        .unsigned()
+        .index()
+        .references('id')
+        .inTable('accounts');
+      table.string('contact_type').nullable().index();
+      table.integer('contact_id').unsigned().nullable().index();
+      table.string('transaction_number').nullable().index();
+      table.string('reference_number').nullable().index();
+      table.integer('item_id').unsigned().nullable().index();
+      table.integer('item_quantity').unsigned().nullable().index(),
+        table.string('note');
+      table.integer('user_id').unsigned().index();
+
+      table.integer('index_group').unsigned().index();
+      table.integer('index').unsigned().index();
+
+      table.date('date').index();
+      table.datetime('created_at').index();
+    })
+    .raw('ALTER TABLE `ACCOUNTS_TRANSACTIONS` AUTO_INCREMENT = 1000');
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTableIfExists('accounts_transactions');
+};
diff --git a/packages/server/src/database/migrations/20200105014405_create_expenses_table.js b/packages/server/src/database/migrations/20200105014405_create_expenses_table.js
new file mode 100644
index 000000000..169856f33
--- /dev/null
+++ b/packages/server/src/database/migrations/20200105014405_create_expenses_table.js
@@ -0,0 +1,29 @@
+exports.up = function (knex) {
+  return knex.schema
+    .createTable('expenses_transactions', (table) => {
+      table.increments();
+      table.string('currency_code', 3);
+      table.text('description');
+      table
+        .integer('payment_account_id')
+        .unsigned()
+        .references('id')
+        .inTable('accounts');
+      table.integer('payee_id').unsigned().references('id').inTable('contacts');
+      table.string('reference_no');
+
+      table.decimal('total_amount', 13, 3);
+      table.decimal('landed_cost_amount', 13, 3).defaultTo(0);
+      table.decimal('allocated_cost_amount', 13, 3).defaultTo(0);
+
+      table.date('published_at').index();
+      table.integer('user_id').unsigned().index();
+      table.date('payment_date').index();
+      table.timestamps();
+    })
+    .raw('ALTER TABLE `EXPENSES_TRANSACTIONS` AUTO_INCREMENT = 1000');
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTableIfExists('expenses');
+};
diff --git a/packages/server/src/database/migrations/20200105195823_create_manual_journals_table.js b/packages/server/src/database/migrations/20200105195823_create_manual_journals_table.js
new file mode 100644
index 000000000..8c2714648
--- /dev/null
+++ b/packages/server/src/database/migrations/20200105195823_create_manual_journals_table.js
@@ -0,0 +1,21 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('manual_journals', (table) => {
+    table.increments();
+    table.string('journal_number').index();
+    table.string('reference').index();
+    table.string('journal_type').index();
+    table.decimal('amount', 13, 3);
+    table.string('currency_code', 3);
+    table.date('date').index();
+    table.string('description');
+    table.date('published_at').index();
+    table.string('attachment_file');
+    table.integer('user_id').unsigned().index();
+    table.timestamps();
+  }).raw('ALTER TABLE `MANUAL_JOURNALS` AUTO_INCREMENT = 1000');
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('manual_journals');
+};
diff --git a/packages/server/src/database/migrations/20200105195825_create_manual_journals_entries_table.js b/packages/server/src/database/migrations/20200105195825_create_manual_journals_entries_table.js
new file mode 100644
index 000000000..ecf22cf4c
--- /dev/null
+++ b/packages/server/src/database/migrations/20200105195825_create_manual_journals_entries_table.js
@@ -0,0 +1,17 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('manual_journals_entries', (table) => {
+    table.increments();
+    table.decimal('credit', 13, 3);
+    table.decimal('debit', 13, 3);
+    table.integer('index').unsigned();
+    table.integer('account_id').unsigned().index().references('id').inTable('accounts');
+    table.integer('contact_id').unsigned().nullable().index();
+    table.string('note');
+    table.integer('manual_journal_id').unsigned().index().references('id').inTable('manual_journals');
+  }).raw('ALTER TABLE `MANUAL_JOURNALS_ENTRIES` AUTO_INCREMENT = 1000');
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('manual_journals_entries');
+};
diff --git a/packages/server/src/database/migrations/20200419171451_create_currencies_table.js b/packages/server/src/database/migrations/20200419171451_create_currencies_table.js
new file mode 100644
index 000000000..4d06717b9
--- /dev/null
+++ b/packages/server/src/database/migrations/20200419171451_create_currencies_table.js
@@ -0,0 +1,14 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('currencies', table => {
+    table.increments();
+    table.string('currency_name').index();
+    table.string('currency_code', 4).index();
+    table.string('currency_sign').index();
+    table.timestamps();
+  }).raw('ALTER TABLE `CURRENCIES` AUTO_INCREMENT = 1000');
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('currencies');
+};
diff --git a/packages/server/src/database/migrations/20200419191832_create_exchange_rates_table.js b/packages/server/src/database/migrations/20200419191832_create_exchange_rates_table.js
new file mode 100644
index 000000000..99db76530
--- /dev/null
+++ b/packages/server/src/database/migrations/20200419191832_create_exchange_rates_table.js
@@ -0,0 +1,14 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('exchange_rates', table => {
+    table.increments();
+    table.string('currency_code', 4).index();
+    table.decimal('exchange_rate');
+    table.date('date').index();
+    table.timestamps();
+  }).raw('ALTER TABLE `EXCHANGE_RATES` AUTO_INCREMENT = 1000');
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('exchange_rates');
+};
diff --git a/packages/server/src/database/migrations/20200423201600_create_media_table.js b/packages/server/src/database/migrations/20200423201600_create_media_table.js
new file mode 100644
index 000000000..64ffc3940
--- /dev/null
+++ b/packages/server/src/database/migrations/20200423201600_create_media_table.js
@@ -0,0 +1,12 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('media', (table) => {
+    table.increments();
+    table.string('attachment_file');
+    table.timestamps();
+  }); 
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('media');
+};
diff --git a/packages/server/src/database/migrations/20200503032011_create_media_links_table.js b/packages/server/src/database/migrations/20200503032011_create_media_links_table.js
new file mode 100644
index 000000000..31d26be4b
--- /dev/null
+++ b/packages/server/src/database/migrations/20200503032011_create_media_links_table.js
@@ -0,0 +1,13 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('media_links', table => {
+    table.increments();
+    table.string('model_name').index();
+    table.integer('media_id').unsigned().references('id').inTable('media');
+    table.integer('model_id').unsigned().index();
+  })
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('media_links');
+};
diff --git a/packages/server/src/database/migrations/20200606113848_create_expense_transactions_categories_table.js b/packages/server/src/database/migrations/20200606113848_create_expense_transactions_categories_table.js
new file mode 100644
index 000000000..a1bc88052
--- /dev/null
+++ b/packages/server/src/database/migrations/20200606113848_create_expense_transactions_categories_table.js
@@ -0,0 +1,29 @@
+exports.up = function (knex) {
+  return knex.schema
+    .createTable('expense_transaction_categories', (table) => {
+      table.increments();
+      table
+        .integer('expense_account_id')
+        .unsigned()
+        .index()
+        .references('id')
+        .inTable('accounts');
+      table.integer('index').unsigned();
+      table.text('description');
+      table.decimal('amount', 13, 3);
+      table.decimal('allocated_cost_amount', 13, 3).defaultTo(0);
+      table.boolean('landed_cost').defaultTo(false);
+      table
+        .integer('expense_id')
+        .unsigned()
+        .index()
+        .references('id')
+        .inTable('expenses_transactions');
+      table.timestamps();
+    })
+    .raw('ALTER TABLE `EXPENSE_TRANSACTION_CATEGORIES` AUTO_INCREMENT = 1000');
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTableIfExists('expense_transaction_categories');
+};
diff --git a/packages/server/src/database/migrations/20200713192127_create_sales_estimates_table.js b/packages/server/src/database/migrations/20200713192127_create_sales_estimates_table.js
new file mode 100644
index 000000000..06f8f1c91
--- /dev/null
+++ b/packages/server/src/database/migrations/20200713192127_create_sales_estimates_table.js
@@ -0,0 +1,35 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('sales_estimates', (table) => {
+    table.increments();
+    table.decimal('amount', 13, 3);
+    table.string('currency_code', 3);
+    table
+      .integer('customer_id')
+      .unsigned()
+      .index()
+      .references('id')
+      .inTable('contacts');
+    table.date('estimate_date').index();
+    table.date('expiration_date').index();
+    table.string('reference');
+    table.string('estimate_number').index();
+    table.text('note');
+    table.text('terms_conditions');
+    table.text('send_to_email');
+
+    table.date('delivered_at').index();
+    table.date('approved_at').index();
+    table.date('rejected_at').index();
+
+    table.integer('user_id').unsigned().index();
+
+    table.integer('converted_to_invoice_id').unsigned();
+    table.date('converted_to_invoice_at');
+
+    table.timestamps();
+  });
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTableIfExists('sales_estimates');
+};
diff --git a/packages/server/src/database/migrations/20200713213303_create_sales_receipt_table.js b/packages/server/src/database/migrations/20200713213303_create_sales_receipt_table.js
new file mode 100644
index 000000000..c1f093312
--- /dev/null
+++ b/packages/server/src/database/migrations/20200713213303_create_sales_receipt_table.js
@@ -0,0 +1,22 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('sales_receipts', table => {
+    table.increments();
+    table.decimal('amount', 13, 3);
+    table.string('currency_code', 3);
+    table.integer('deposit_account_id').unsigned().index().references('id').inTable('accounts');
+    table.integer('customer_id').unsigned().index().references('id').inTable('contacts');
+    table.date('receipt_date').index();
+    table.string('receipt_number').index();
+    table.string('reference_no').index();
+    table.string('send_to_email');
+    table.text('receipt_message');
+    table.text('statement');
+    table.date('closed_at').index();
+    table.timestamps();
+  })  
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('sales_receipts');
+};
diff --git a/packages/server/src/database/migrations/20200715193633_create_sale_invoices_table.js b/packages/server/src/database/migrations/20200715193633_create_sale_invoices_table.js
new file mode 100644
index 000000000..87c26f58c
--- /dev/null
+++ b/packages/server/src/database/migrations/20200715193633_create_sale_invoices_table.js
@@ -0,0 +1,34 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('sales_invoices', (table) => {
+    table.increments();
+    table
+      .integer('customer_id')
+      .unsigned()
+      .index()
+      .references('id')
+      .inTable('contacts');
+
+    table.date('invoice_date').index();
+    table.date('due_date');
+    table.string('invoice_no').index();
+    table.string('reference_no');
+
+    table.text('invoice_message');
+    table.text('terms_conditions');
+
+    table.decimal('balance', 13, 3);
+    table.decimal('payment_amount', 13, 3);
+    table.string('currency_code', 3);
+    table.decimal('credited_amount', 13, 3).defaultTo(0);
+
+    table.string('inv_lot_number').index();
+
+    table.date('delivered_at').index();
+    table.integer('user_id').unsigned();
+    table.timestamps();
+  });
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTableIfExists('sales_invoices');
+};
diff --git a/packages/server/src/database/migrations/20200715194514_create_payment_receives_table.js b/packages/server/src/database/migrations/20200715194514_create_payment_receives_table.js
new file mode 100644
index 000000000..c9a73ba13
--- /dev/null
+++ b/packages/server/src/database/migrations/20200715194514_create_payment_receives_table.js
@@ -0,0 +1,30 @@
+const { knexSnakeCaseMappers } = require('objection');
+
+exports.up = function (knex) {
+  return knex.schema.createTable('payment_receives', (table) => {
+    table.increments();
+    table
+      .integer('customer_id')
+      .unsigned()
+      .index()
+      .references('id')
+      .inTable('contacts');
+    table.date('payment_date').index();
+    table.decimal('amount', 13, 3).defaultTo(0);
+    table.string('currency_code', 3);
+    table.string('reference_no').index();
+    table
+      .integer('deposit_account_id')
+      .unsigned()
+      .references('id')
+      .inTable('accounts');
+    table.string('payment_receive_no').nullable();
+    table.text('statement');
+    table.integer('user_id').unsigned().index();
+    table.timestamps();
+  });
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTableIfExists('payment_receives');
+};
diff --git a/packages/server/src/database/migrations/20200718161031_create_payment_receives_entries_table.js b/packages/server/src/database/migrations/20200718161031_create_payment_receives_entries_table.js
new file mode 100644
index 000000000..d4c68a270
--- /dev/null
+++ b/packages/server/src/database/migrations/20200718161031_create_payment_receives_entries_table.js
@@ -0,0 +1,23 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('payment_receives_entries', (table) => {
+    table.increments();
+    table
+      .integer('payment_receive_id')
+      .unsigned()
+      .index()
+      .references('id')
+      .inTable('payment_receives');
+    table
+      .integer('invoice_id')
+      .unsigned()
+      .index()
+      .references('id')
+      .inTable('sales_invoices');
+    table.decimal('payment_amount', 13, 3).unsigned();
+    table.integer('index').unsigned();
+  });
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTableIfExists('payment_receives_entries');
+};
diff --git a/packages/server/src/database/migrations/20200719152005_create_bills_table.js b/packages/server/src/database/migrations/20200719152005_create_bills_table.js
new file mode 100644
index 000000000..cac0e04cd
--- /dev/null
+++ b/packages/server/src/database/migrations/20200719152005_create_bills_table.js
@@ -0,0 +1,31 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('bills', (table) => {
+    table.increments();
+    table
+      .integer('vendor_id')
+      .unsigned()
+      .index()
+      .references('id')
+      .inTable('contacts');
+    table.string('bill_number');
+    table.date('bill_date').index();
+    table.date('due_date').index();
+    table.string('reference_no').index();
+    table.string('status').index();
+    table.text('note');
+    table.decimal('amount', 13, 3).defaultTo(0);
+    table.string('currency_code');
+    table.decimal('payment_amount', 13, 3).defaultTo(0);
+    table.decimal('landed_cost_amount', 13, 3).defaultTo(0);
+    table.decimal('allocated_cost_amount', 13, 3).defaultTo(0);
+    table.decimal('credited_amount', 13, 3).defaultTo(0);
+    table.string('inv_lot_number').index();
+    table.date('opened_at').index();
+    table.integer('user_id').unsigned();
+    table.timestamps();
+  });
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTableIfExists('bills');
+};
diff --git a/packages/server/src/database/migrations/20200719153909_create_bills_payments_table.js b/packages/server/src/database/migrations/20200719153909_create_bills_payments_table.js
new file mode 100644
index 000000000..568302f3e
--- /dev/null
+++ b/packages/server/src/database/migrations/20200719153909_create_bills_payments_table.js
@@ -0,0 +1,21 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('bills_payments', table => {
+    table.increments();
+    table.integer('vendor_id').unsigned().index().references('id').inTable('contacts');
+    table.decimal('amount', 13, 3).defaultTo(0);
+    table.string('currency_code');
+    table.integer('payment_account_id').unsigned().references('id').inTable('accounts');
+    table.string('payment_number').nullable().index();
+    table.date('payment_date').index();
+    table.string('payment_method');
+    table.string('reference');
+    table.integer('user_id').unsigned().index();
+    table.text('statement');
+    table.timestamps();
+  }); 
+};
+
+exports.down = function(knex) {
+  
+};
diff --git a/packages/server/src/database/migrations/20200722164251_create_inventory_transactions_table.js b/packages/server/src/database/migrations/20200722164251_create_inventory_transactions_table.js
new file mode 100644
index 000000000..bf8de6184
--- /dev/null
+++ b/packages/server/src/database/migrations/20200722164251_create_inventory_transactions_table.js
@@ -0,0 +1,24 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('inventory_transactions', (table) => {
+    table.increments('id');
+    table.date('date').index();
+    table.string('direction').index();
+    table
+      .integer('item_id')
+      .unsigned()
+      .index()
+      .references('id')
+      .inTable('items');
+    table.integer('quantity').unsigned();
+    table.decimal('rate', 13, 3).unsigned();
+
+    table.string('transaction_type').index();
+    table.integer('transaction_id').unsigned().index();
+
+    table.integer('entry_id').unsigned().index();
+    table.integer('cost_account_id').unsigned();
+    table.timestamps();
+  });
+};
+
+exports.down = function (knex) {};
diff --git a/packages/server/src/database/migrations/20200722164252_create_landed_cost_table.js b/packages/server/src/database/migrations/20200722164252_create_landed_cost_table.js
new file mode 100644
index 000000000..f315e1bde
--- /dev/null
+++ b/packages/server/src/database/migrations/20200722164252_create_landed_cost_table.js
@@ -0,0 +1,21 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('bill_located_costs', (table) => {
+    table.increments();
+
+    table.decimal('amount', 13, 3).unsigned();
+
+    table.integer('fromTransactionId').unsigned();
+    table.string('fromTransactionType');
+    table.integer('fromTransactionEntryId').unsigned();
+
+    table.string('allocationMethod');
+    table.integer('costAccountId').unsigned();
+    table.text('description');
+
+    table.integer('billId').unsigned();
+
+    table.timestamps();
+  });
+};
+
+exports.down = function (knex) {};
diff --git a/packages/server/src/database/migrations/20200722164253_create_landed_cost_entries_table.js b/packages/server/src/database/migrations/20200722164253_create_landed_cost_entries_table.js
new file mode 100644
index 000000000..96cdc5d77
--- /dev/null
+++ b/packages/server/src/database/migrations/20200722164253_create_landed_cost_entries_table.js
@@ -0,0 +1,11 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('bill_located_cost_entries', (table) => {
+    table.increments();
+
+    table.decimal('cost', 13, 3).unsigned();
+    table.integer('entry_id').unsigned();
+    table.integer('bill_located_cost_id').unsigned();
+  });
+};
+
+exports.down = function (knex) {};
diff --git a/packages/server/src/database/migrations/20200722164255_create_inventory_transaction_meta_table.js b/packages/server/src/database/migrations/20200722164255_create_inventory_transaction_meta_table.js
new file mode 100644
index 000000000..15f348a17
--- /dev/null
+++ b/packages/server/src/database/migrations/20200722164255_create_inventory_transaction_meta_table.js
@@ -0,0 +1,11 @@
+exports.up = function (knex) {
+    return knex.schema.createTable('inventory_transaction_meta', (table) => {
+      table.increments('id');
+      table.string('transaction_number');
+      table.text('description');
+      table.integer('inventory_transaction_id').unsigned();
+    });
+  };
+  
+  exports.down = function (knex) {};
+  
\ No newline at end of file
diff --git a/packages/server/src/database/migrations/20200722173423_create_items_entries_table.js b/packages/server/src/database/migrations/20200722173423_create_items_entries_table.js
new file mode 100644
index 000000000..b480540de
--- /dev/null
+++ b/packages/server/src/database/migrations/20200722173423_create_items_entries_table.js
@@ -0,0 +1,39 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('items_entries', (table) => {
+    table.increments();
+    table.string('reference_type').index();
+    table.string('reference_id').index();
+
+    table.integer('index').unsigned();
+    table
+      .integer('item_id')
+      .unsigned()
+      .index()
+      .references('id')
+      .inTable('items');
+    table.text('description');
+    table.integer('discount').unsigned();
+    table.integer('quantity').unsigned();
+    table.integer('rate').unsigned();
+
+    table
+      .integer('sell_account_id')
+      .unsigned()
+      .references('id')
+      .inTable('accounts');
+    table
+      .integer('cost_account_id')
+      .unsigned()
+      .references('id')
+      .inTable('accounts');
+
+    table.boolean('landed_cost').defaultTo(false);
+    table.decimal('allocated_cost_amount', 13, 3).defaultTo(0);
+
+    table.timestamps();
+  });
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTableIfExists('items_entries');
+};
diff --git a/packages/server/src/database/migrations/20200728161617_create_bill_payments_entries.js b/packages/server/src/database/migrations/20200728161617_create_bill_payments_entries.js
new file mode 100644
index 000000000..d08ac23bb
--- /dev/null
+++ b/packages/server/src/database/migrations/20200728161617_create_bill_payments_entries.js
@@ -0,0 +1,23 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('bills_payments_entries', (table) => {
+    table.increments();
+    table
+      .integer('bill_payment_id')
+      .unsigned()
+      .index()
+      .references('id')
+      .inTable('bills_payments');
+    table
+      .integer('bill_id')
+      .unsigned()
+      .index()
+      .references('id')
+      .inTable('bills');
+    table.decimal('payment_amount', 13, 3).unsigned();
+    table.integer('index').unsigned();
+  });
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTableIfExists('bills_payments_entries');
+};
diff --git a/packages/server/src/database/migrations/20200810121807_create_inventory_cost_lot_tracker_table.js b/packages/server/src/database/migrations/20200810121807_create_inventory_cost_lot_tracker_table.js
new file mode 100644
index 000000000..d490cbcc7
--- /dev/null
+++ b/packages/server/src/database/migrations/20200810121807_create_inventory_cost_lot_tracker_table.js
@@ -0,0 +1,26 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('inventory_cost_lot_tracker', (table) => {
+    table.increments();
+    table.date('date').index();
+    table.string('direction').index();
+
+    table.integer('item_id').unsigned().index();
+    table.integer('quantity').unsigned().index();
+    table.decimal('rate', 13, 3);
+    table.integer('remaining');
+    table.decimal('cost', 13, 3);
+
+    table.string('transaction_type').index();
+    table.integer('transaction_id').unsigned().index();
+
+    table.integer('entry_id').unsigned().index();
+    table.integer('cost_account_id').unsigned();
+    table.integer('inventory_transaction_id').unsigned().index();
+
+    table.datetime('created_at').index();
+  });
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTableIfExists('inventory_cost_lot_tracker');
+};
diff --git a/packages/server/src/database/migrations/20200810121809_create_inventory_adjustments_table.js b/packages/server/src/database/migrations/20200810121809_create_inventory_adjustments_table.js
new file mode 100644
index 000000000..4774fcd23
--- /dev/null
+++ b/packages/server/src/database/migrations/20200810121809_create_inventory_adjustments_table.js
@@ -0,0 +1,19 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('inventory_adjustments', table => {
+    table.increments();
+    table.date('date').index();
+    table.string('type').index();
+    table.integer('adjustment_account_id').unsigned().references('id').inTable('accounts');
+    table.string('reason');
+    table.string('reference_no').index();
+    table.string('description');
+    table.integer('user_id').unsigned();
+    table.date('published_at');
+    table.timestamps();
+  });  
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('inventory_adjustments');
+};
diff --git a/packages/server/src/database/migrations/20200810121810_create_inventory_adjustments_entries_table.js b/packages/server/src/database/migrations/20200810121810_create_inventory_adjustments_entries_table.js
new file mode 100644
index 000000000..c40f877e2
--- /dev/null
+++ b/packages/server/src/database/migrations/20200810121810_create_inventory_adjustments_entries_table.js
@@ -0,0 +1,25 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('inventory_adjustments_entries', (table) => {
+    table.increments();
+    table
+      .integer('adjustment_id')
+      .unsigned()
+      .index()
+      .references('id')
+      .inTable('inventory_adjustments');
+    table.integer('index').unsigned();
+    table
+      .integer('item_id')
+      .unsigned()
+      .index()
+      .references('id')
+      .inTable('items');
+    table.integer('quantity');
+    table.decimal('cost', 13, 3).unsigned();
+    table.decimal('value', 13, 3).unsigned();
+  });
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTableIfExists('inventory_adjustments_entries');
+};
diff --git a/packages/server/src/database/migrations/20200810121910_create_cashflow_transactions_table.js b/packages/server/src/database/migrations/20200810121910_create_cashflow_transactions_table.js
new file mode 100644
index 000000000..22914346a
--- /dev/null
+++ b/packages/server/src/database/migrations/20200810121910_create_cashflow_transactions_table.js
@@ -0,0 +1,18 @@
+exports.up = (knex) => {
+  return knex.schema.createTable('cashflow_transactions', (table) => {
+    table.increments();
+    table.date('date').index();
+    table.decimal('amount', 13, 3);
+    table.string('reference_no').index();
+    table.string('transaction_type').index();
+    table.string('transaction_number').index();
+    table.string('description');
+    table.date('published_at').index();
+    table.integer('user_id').unsigned().index();
+    table.timestamps();
+  });
+};
+
+exports.down = (knex) => {
+  return knex.schema.dropTableIfExists('cashflow_transactions');
+};
diff --git a/packages/server/src/database/migrations/20210810121910_create_cashflow_transaction_lines_table.js b/packages/server/src/database/migrations/20210810121910_create_cashflow_transaction_lines_table.js
new file mode 100644
index 000000000..79a47e690
--- /dev/null
+++ b/packages/server/src/database/migrations/20210810121910_create_cashflow_transaction_lines_table.js
@@ -0,0 +1,23 @@
+exports.up = (knex) => {
+  return knex.schema.createTable('cashflow_transaction_lines', (table) => {
+    table.increments();
+    table.integer('cashflow_transaction_id').unsigned();
+    table
+      .integer('cashflow_account_id')
+      .unsigned()
+      .references('id')
+      .inTable('accounts');
+    table
+      .integer('credit_account_id')
+      .unsigned()
+      .references('id')
+      .inTable('accounts');
+    table.decimal('amount', 13, 3);
+    table.integer('index').unsigned();
+    table.timestamps();
+  });
+};
+
+exports.down = (knex) => {
+  return knex.schema.dropTableIfExists('cashflow_transaction_lines');
+};
diff --git a/packages/server/src/database/migrations/20210910121910_add_invoices_writtenoff_columns.js b/packages/server/src/database/migrations/20210910121910_add_invoices_writtenoff_columns.js
new file mode 100644
index 000000000..8ce84a105
--- /dev/null
+++ b/packages/server/src/database/migrations/20210910121910_add_invoices_writtenoff_columns.js
@@ -0,0 +1,13 @@
+exports.up = (knex) => {
+  return knex.schema.table('sales_invoices', (table) => {
+    table.decimal('writtenoff_amount', 13, 3);
+    table.date('writtenoff_at').index();
+  });
+};
+
+exports.down = (knex) => {
+  return knex.schema.table('sales_invoices', (table) => {
+    table.dropColumn('writtenoff_amount');
+    table.dropColumn('writtenoff_at');
+  });
+};
diff --git a/packages/server/src/database/migrations/20211012121910_add_costable_column_to_account_transactions.js b/packages/server/src/database/migrations/20211012121910_add_costable_column_to_account_transactions.js
new file mode 100644
index 000000000..7594fae97
--- /dev/null
+++ b/packages/server/src/database/migrations/20211012121910_add_costable_column_to_account_transactions.js
@@ -0,0 +1,11 @@
+exports.up = (knex) => {
+  return knex.schema.table('accounts_transactions', (table) => {
+    table.boolean('costable');
+  });
+};
+
+exports.down = (knex) => {
+  return knex.schema.table('accounts_transactions', (table) => {
+    table.dropColumn('costable');
+  });
+};
diff --git a/packages/server/src/database/migrations/20211014121910_add_roles_table.js b/packages/server/src/database/migrations/20211014121910_add_roles_table.js
new file mode 100644
index 000000000..e9d8a0775
--- /dev/null
+++ b/packages/server/src/database/migrations/20211014121910_add_roles_table.js
@@ -0,0 +1,21 @@
+exports.up = (knex) => {
+  return knex.schema
+    .createTable('roles', (table) => {
+      table.increments('id');
+      table.string('name', 255).notNullable();
+      table.string('slug');
+      table.text('description');
+      table.boolean('predefined');
+    })
+    .createTable('role_permissions', (table) => {
+      table.increments('id');
+      table.integer('role_id').unsigned().references('id').inTable('roles');
+      table.string('subject');
+      table.string('ability');
+      table.boolean('value');
+    });
+};
+
+exports.down = (knex) => {
+  return knex.schema.dropTable('roles').dropTable('role_permissions');
+};
diff --git a/packages/server/src/database/migrations/20211112121920_create_users_table.js b/packages/server/src/database/migrations/20211112121920_create_users_table.js
new file mode 100644
index 000000000..a5df01941
--- /dev/null
+++ b/packages/server/src/database/migrations/20211112121920_create_users_table.js
@@ -0,0 +1,19 @@
+exports.up = (knex) => {
+  return knex.schema.createTable('users', (table) => {
+    table.increments();
+    table.string('first_name');
+    table.string('last_name');
+    table.string('email').index();
+    table.string('phone_number').index();
+    table.boolean('active').index();
+    table.integer('role_id').unsigned().references('id').inTable('roles');
+    table.integer('system_user_id').unsigned();
+    table.dateTime('invited_at').index();
+    table.dateTime('invite_accepted_at').index();
+    table.timestamps();
+  });
+};
+
+exports.down = (knex) => {
+  return knex.schema.dropTableIfExists('users');
+};
diff --git a/packages/server/src/database/migrations/20211122121920_create_credit_notes_table.js b/packages/server/src/database/migrations/20211122121920_create_credit_notes_table.js
new file mode 100644
index 000000000..07aa28a65
--- /dev/null
+++ b/packages/server/src/database/migrations/20211122121920_create_credit_notes_table.js
@@ -0,0 +1,28 @@
+exports.up = (knex) => {
+  return knex.schema.createTable('credit_notes', (table) => {
+    table.increments();
+    table
+      .integer('customer_id')
+      .unsigned()
+      .references('id')
+      .inTable('contacts');
+    table.date('credit_note_date');
+    table.string('credit_note_number');
+    table.string('reference_no');
+    table.decimal('amount', 13, 3);
+
+    table.decimal('refunded_amount', 13, 3).defaultTo(0);
+    table.decimal('invoices_amount', 13, 3).defaultTo(0);
+
+    table.string('currency_code', 3);
+    table.text('note');
+    table.text('terms_conditions');
+    table.date('opened_at').index();
+    table.integer('user_id').unsigned().references('id').inTable('users');
+    table.timestamps();
+  });
+};
+
+exports.down = (knex) => {
+  return knex.schema.dropTableIfExists('credit_notescredit_notes');
+};
diff --git a/packages/server/src/database/migrations/20211122121920_create_vendor_credits_table.js b/packages/server/src/database/migrations/20211122121920_create_vendor_credits_table.js
new file mode 100644
index 000000000..0e4e361f8
--- /dev/null
+++ b/packages/server/src/database/migrations/20211122121920_create_vendor_credits_table.js
@@ -0,0 +1,23 @@
+exports.up = (knex) => {
+  return knex.schema.createTable('vendor_credits', (table) => {
+    table.increments();
+    table.integer('vendor_id').unsigned().references('id').inTable('contacts');
+    table.decimal('amount', 13, 3);
+    table.string('currency_code', 3);
+    table.date('vendor_credit_date');
+    table.string('vendor_credit_number');
+    table.string('reference_no');
+
+    table.decimal('refunded_amount', 13, 3).defaultTo(0);
+    table.decimal('invoiced_amount', 13, 3).defaultTo(0);
+
+    table.text('note');
+    table.date('opened_at').index();
+    table.integer('user_id').unsigned().references('id').inTable('users');
+    table.timestamps();
+  });
+};
+
+exports.down = (knex) => {
+  return knex.schema.dropTableIfExists('vendor_credits');
+};
diff --git a/packages/server/src/database/migrations/20211123121920_create_refund_transactions_table.js b/packages/server/src/database/migrations/20211123121920_create_refund_transactions_table.js
new file mode 100644
index 000000000..233657be2
--- /dev/null
+++ b/packages/server/src/database/migrations/20211123121920_create_refund_transactions_table.js
@@ -0,0 +1,45 @@
+exports.up = (knex) => {
+  return knex.schema
+    .createTable('refund_credit_note_transactions', (table) => {
+      table.increments();
+      table.date('date');
+      table
+        .integer('credit_note_id')
+        .unsigned()
+        .references('id')
+        .inTable('credit_notes');
+      table.decimal('amount', 13, 3);
+      table.string('currency_code', 3);
+      table.string('reference_no');
+      table
+        .integer('from_account_id')
+        .unsigned()
+        .references('id')
+        .inTable('accounts');
+      table.text('description');
+      table.timestamps();
+    })
+    .createTable('refund_vendor_credit_transactions', (table) => {
+      table.increments();
+      table.date('date');
+      table
+        .integer('vendor_credit_id')
+        .unsigned()
+        .references('id')
+        .inTable('vendor_credits');
+      table.decimal('amount', 13, 3);
+      table.string('currency_code', 3);
+      table.string('reference_no');
+      table
+        .integer('deposit_account_id')
+        .unsigned()
+        .references('id')
+        .inTable('accounts');
+      table.text('description');
+      table.timestamps();
+    });
+};
+
+exports.down = (knex) => {
+  return knex.schema.dropTableIfExists('refund_transactions');
+};
diff --git a/packages/server/src/database/migrations/20211124121920_create_credit_note_applies_invoices.js b/packages/server/src/database/migrations/20211124121920_create_credit_note_applies_invoices.js
new file mode 100644
index 000000000..678a52bf2
--- /dev/null
+++ b/packages/server/src/database/migrations/20211124121920_create_credit_note_applies_invoices.js
@@ -0,0 +1,35 @@
+exports.up = (knex) => {
+  return knex.schema
+    .createTable('credit_note_applied_invoice', (table) => {
+      table.increments();
+      table.decimal('amount', 13, 3);
+      table
+        .integer('credit_note_id')
+        .unsigned()
+        .references('id')
+        .inTable('credit_notes');
+      table
+        .integer('invoice_id')
+        .unsigned()
+        .references('id')
+        .inTable('sales_invoices');
+      table.timestamps();
+    })
+    .createTable('vendor_credit_applied_bill', (table) => {
+      table.increments();
+      table.decimal('amount', 13, 3);
+      table
+        .integer('vendor_credit_id')
+        .unsigned()
+        .references('id')
+        .inTable('vendor_credits');
+      table.integer('bill_id').unsigned().references('id').inTable('bills');
+      table.timestamps();
+    });
+};
+
+exports.down = (knex) => {
+  return knex.schema
+    .dropTableIfExists('vendor_credit_applied_bill')
+    .dropTableIfExists('credit_note_applied_invoice');
+};
diff --git a/packages/server/src/database/migrations/20220124121920_create_branches_table.js b/packages/server/src/database/migrations/20220124121920_create_branches_table.js
new file mode 100644
index 000000000..de2b75261
--- /dev/null
+++ b/packages/server/src/database/migrations/20220124121920_create_branches_table.js
@@ -0,0 +1,24 @@
+exports.up = (knex) => {
+  return knex.schema.createTable('branches', (table) => {
+    table.increments();
+
+    table.string('name');
+    table.string('code');
+
+    table.string('address');
+    table.string('city');
+    table.string('country');
+
+    table.string('phone_number');
+    table.string('email');
+    table.string('website');
+
+    table.boolean('primary');
+
+    table.timestamps();
+  });
+};
+
+exports.down = (knex) => {
+  return knex.schema.dropTableIfExists('branches');
+};
diff --git a/packages/server/src/database/migrations/20220124121920_create_warehouses_table.js b/packages/server/src/database/migrations/20220124121920_create_warehouses_table.js
new file mode 100644
index 000000000..b6617857e
--- /dev/null
+++ b/packages/server/src/database/migrations/20220124121920_create_warehouses_table.js
@@ -0,0 +1,59 @@
+exports.up = (knex) => {
+  return knex.schema
+    .createTable('warehouses', (table) => {
+      table.increments();
+      table.string('name');
+      table.string('code');
+
+      table.string('address');
+      table.string('city');
+      table.string('country');
+
+      table.string('phone_number');
+      table.string('email');
+      table.string('website');
+
+      table.boolean('primary');
+
+      table.timestamps();
+    })
+    .createTable('warehouses_transfers', (table) => {
+      table.increments();
+      table.date('date');
+      table
+        .integer('to_warehouse_id')
+        .unsigned()
+        .references('id')
+        .inTable('warehouses');
+      table
+        .integer('from_warehouse_id')
+        .unsigned()
+        .references('id')
+        .inTable('warehouses');
+      table.string('transaction_number');
+
+      table.date('transfer_initiated_at');
+      table.date('transfer_delivered_at');
+
+      table.timestamps();
+    })
+    .createTable('warehouses_transfers_entries', (table) => {
+      table.increments();
+      table.integer('index');
+      table
+        .integer('warehouse_transfer_id')
+        .unsigned()
+        .references('id')
+        .inTable('warehouses_transfers');
+      table.integer('item_id').unsigned().references('id').inTable('items');
+      table.string('description');
+      table.integer('quantity');
+      table.decimal('cost');
+    });
+};
+
+exports.down = (knex) => {
+  return knex.schema
+    .dropTableIfExists('vendor_credit_applied_bill')
+    .dropTableIfExists('credit_note_applied_invoice');
+};
diff --git a/packages/server/src/database/migrations/20220125021920_create_items_warehouses_quantity.js b/packages/server/src/database/migrations/20220125021920_create_items_warehouses_quantity.js
new file mode 100644
index 000000000..899db5e2b
--- /dev/null
+++ b/packages/server/src/database/migrations/20220125021920_create_items_warehouses_quantity.js
@@ -0,0 +1,16 @@
+exports.up = (knex) => {
+  return knex.schema.createTable('items_warehouses_quantity', (table) => {
+    table.integer('item_id').unsigned().references('id').inTable('items');
+    table
+      .integer('warehouse_id')
+      .unsigned()
+      .references('id')
+      .inTable('warehouses');
+
+    table.integer('quantity_on_hand');
+  });
+};
+
+exports.down = (knex) => {
+  return knex.schema.dropTableIfExists('items_warehouses_quantity');
+};
diff --git a/packages/server/src/database/migrations/20220125121920_add_branch_column_to_accounts_transactions.js b/packages/server/src/database/migrations/20220125121920_add_branch_column_to_accounts_transactions.js
new file mode 100644
index 000000000..ba7ab26c1
--- /dev/null
+++ b/packages/server/src/database/migrations/20220125121920_add_branch_column_to_accounts_transactions.js
@@ -0,0 +1,86 @@
+exports.up = (knex) => {
+  return knex.schema
+    .table('accounts_transactions', (table) => {
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches');
+    })
+    .table('manual_journals', (table) => {
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches');
+    })
+    .table('manual_journals_entries', (table) => {
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches');
+    })
+    .table('expenses_transactions', (table) => {
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches')
+        .after('user_id');
+    })
+    .table('cashflow_transactions', (table) => {
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches')
+        .after('user_id');
+    })
+    .table('contacts', (table) => {
+      table
+        .integer('opening_balance_branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches')
+        .after('opening_balance_at');
+    })
+    .table('refund_credit_note_transactions', (table) => {
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches')
+        .after('description');
+    })
+    .table('refund_vendor_credit_transactions', (table) => {
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches')
+        .after('description');
+    });
+};
+
+exports.down = (knex) => {
+  return knex.schema
+    .table('accounts_transactions', (table) => {
+      table.dropColumn('branch_id');
+    })
+    .table('manual_journals', (table) => {
+      table.dropColumn('branch_id');
+    })
+    .table('manual_journals_entries', (table) => {
+      table.dropColumn('branch_id');
+    })
+    .table('cashflow_transactions', (table) => {
+      table.dropColumn('branch_id');
+    })
+    .table('refund_credit_note_transactions', (table) => {
+      table.dropColumn('branch_id');
+    })
+    .table('refund_vendor_credit_transactions', (table) => {
+      table.dropColumn('branch_id');
+    });
+};
diff --git a/packages/server/src/database/migrations/20220125121920_add_branch_warehouse_columns_to_purchases.js b/packages/server/src/database/migrations/20220125121920_add_branch_warehouse_columns_to_purchases.js
new file mode 100644
index 000000000..7ce87115c
--- /dev/null
+++ b/packages/server/src/database/migrations/20220125121920_add_branch_warehouse_columns_to_purchases.js
@@ -0,0 +1,65 @@
+exports.up = (knex) => {
+  return knex.schema
+    .table('bills', (table) => {
+      table
+        .integer('warehouse_id')
+        .unsigned()
+        .references('id')
+        .inTable('warehouses');
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches');
+    })
+    .table('bills_payments', (table) => {
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches');
+    })
+    .table('vendor_credits', (table) => {
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches');
+      table
+        .integer('warehouse_id')
+        .unsigned()
+        .references('id')
+        .inTable('warehouses');
+    })
+    .table('inventory_adjustments', (table) => {
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches');
+      table
+        .integer('warehouse_id')
+        .unsigned()
+        .references('id')
+        .inTable('warehouses');
+    });
+};
+
+exports.down = (knex) => {
+  return knex.schema
+    .table('bills', (table) => {
+      table.dropColumn('warehouse_id');
+      table.dropColumn('branch_id');
+    })
+    .table('bills_payments', (table) => {
+      table.dropColumn('branch_id');
+    })
+    .table('vendor_credits', (table) => {
+      table.dropColumn('branch_id');
+      table.dropColumn('warehouse_id');
+    })
+    .table('inventory_adjustments', (table) => {
+      table.dropColumn('branch_id');
+      table.dropColumn('warehouse_id');
+    });
+};
diff --git a/packages/server/src/database/migrations/20220125121920_add_branch_warehouse_columns_to_sales.js b/packages/server/src/database/migrations/20220125121920_add_branch_warehouse_columns_to_sales.js
new file mode 100644
index 000000000..b209040e4
--- /dev/null
+++ b/packages/server/src/database/migrations/20220125121920_add_branch_warehouse_columns_to_sales.js
@@ -0,0 +1,84 @@
+exports.up = (knex) => {
+  return knex.schema
+    .table('sales_invoices', (table) => {
+      table
+        .integer('warehouse_id')
+        .unsigned()
+        .references('id')
+        .inTable('warehouses');
+
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches');
+    })
+    .table('sales_estimates', (table) => {
+      table
+        .integer('warehouse_id')
+        .unsigned()
+        .references('id')
+        .inTable('warehouses');
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches');
+    })
+    .table('sales_receipts', (table) => {
+      table
+        .integer('warehouse_id')
+        .unsigned()
+        .references('id')
+        .inTable('warehouses');
+
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches');
+    })
+    .table('payment_receives', (table) => {
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches');
+    })
+    .table('credit_notes', (table) => {
+      table
+        .integer('warehouse_id')
+        .unsigned()
+        .references('id')
+        .inTable('warehouses');
+
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches');
+    });
+};
+
+exports.down = (knex) => {
+  return knex.schema
+    .table('sales_invoices', (table) => {
+      table.dropColumn('warehouse_id');
+      table.dropColumn('branch_id');
+    })
+    .table('sales_estimates', (table) => {
+      table.dropColumn('warehouse_id');
+      table.dropColumn('branch_id');
+    })
+    .table('sales_receipts', (table) => {
+      table.dropColumn('warehouse_id');
+      table.dropColumn('branch_id');
+    })
+    .table('payment_receives', (table) => {
+      table.dropColumn('branch_id');
+    })
+    .table('credit_notes', (table) => {
+      table.dropColumn('warehouse_id');
+      table.dropColumn('branch_id');
+    });
+};
diff --git a/packages/server/src/database/migrations/20220125121920_add_warehouse_column_to_inventory_transactions.js b/packages/server/src/database/migrations/20220125121920_add_warehouse_column_to_inventory_transactions.js
new file mode 100644
index 000000000..622961f22
--- /dev/null
+++ b/packages/server/src/database/migrations/20220125121920_add_warehouse_column_to_inventory_transactions.js
@@ -0,0 +1,40 @@
+exports.up = (knex) => {
+  return knex.schema
+    .table('inventory_transactions', (table) => {
+      table
+        .integer('warehouse_id')
+        .unsigned()
+        .references('id')
+        .inTable('warehouses');
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches');
+    })
+    .table('inventory_cost_lot_tracker', (table) => {
+      table
+        .integer('warehouse_id')
+        .unsigned()
+        .references('id')
+        .inTable('warehouses');
+
+      table
+        .integer('branch_id')
+        .unsigned()
+        .references('id')
+        .inTable('branches');
+    });
+};
+
+exports.down = (knex) => {
+  return knex.schema
+    .table('inventory_transactions', (table) => {
+      table.dropColumn('warehouse_id');
+      table.dropColumn('branch_id');
+    })
+    .table('inventory_cost_lot_tracker', (table) => {
+      table.dropColumn('warehouse_id');
+      table.dropColumn('branch_id');
+    });
+};
diff --git a/packages/server/src/database/migrations/20220125121920_add_warehouse_column_to_items_entries.js b/packages/server/src/database/migrations/20220125121920_add_warehouse_column_to_items_entries.js
new file mode 100644
index 000000000..bac471bfe
--- /dev/null
+++ b/packages/server/src/database/migrations/20220125121920_add_warehouse_column_to_items_entries.js
@@ -0,0 +1,15 @@
+exports.up = (knex) => {
+  return knex.schema.table('items_entries', (table) => {
+    table
+      .integer('warehouse_id')
+      .unsigned()
+      .references('id')
+      .inTable('warehouses');
+  });
+};
+
+exports.down = (knex) => {
+  return knex.schema.table('items_entries', (table) => {
+    table.dropColumn('warehouse_id');
+  });
+};
diff --git a/packages/server/src/database/migrations/20220128121920_add_exchange_rate_to_transactions.js b/packages/server/src/database/migrations/20220128121920_add_exchange_rate_to_transactions.js
new file mode 100644
index 000000000..86c7836dc
--- /dev/null
+++ b/packages/server/src/database/migrations/20220128121920_add_exchange_rate_to_transactions.js
@@ -0,0 +1,114 @@
+exports.up = (knex) => {
+  return knex.schema
+    .table('sales_invoices', (table) => {
+      table.decimal('exchange_rate', 13, 9).after('currency_code');
+    })
+    .table('sales_estimates', (table) => {
+      table.decimal('exchange_rate', 13, 9);
+    })
+    .table('sales_receipts', (table) => {
+      table.decimal('exchange_rate', 13, 9).after('currency_code');
+    })
+    .table('payment_receives', (table) => {
+      table.decimal('exchange_rate', 13, 9).after('currency_code');
+    })
+    .table('bills', (table) => {
+      table.decimal('exchange_rate', 13, 9).after('currency_code');
+    })
+    .table('bills_payments', (table) => {
+      table.decimal('exchange_rate', 13, 9).after('currency_code');
+    })
+    .table('credit_notes', (table) => {
+      table.decimal('exchange_rate', 13, 9).after('currency_code');
+    })
+    .table('vendor_credits', (table) => {
+      table.decimal('exchange_rate', 13, 9).after('currency_code');
+    })
+    .table('accounts_transactions', (table) => {
+      table.string('currency_code', 3).after('debit');
+      table.decimal('exchange_rate', 13, 9).after('currency_code');
+    })
+    .table('manual_journals', (table) => {
+      table.decimal('exchange_rate', 13, 9).after('currency_code');
+    })
+    .table('cashflow_transactions', (table) => {
+      table.string('currency_code', 3).after('amount');
+      table.decimal('exchange_rate', 13, 9).after('currency_code');
+    })
+    .table('expenses_transactions', (table) => {
+      table.decimal('exchange_rate', 13, 9).after('currency_code');
+    })
+    .table('refund_credit_note_transactions', (table) => {
+      table.decimal('exchange_rate', 13, 9).after('currency_code');
+    })
+    .table('refund_vendor_credit_transactions', (table) => {
+      table.decimal('exchange_rate', 13, 9).after('currency_code');
+    })
+    .table('bill_located_costs', (table) => {
+      table.string('currency_code', 3).after('amount');
+      table.decimal('exchange_rate', 13, 9).after('currency_code');
+    })
+    .table('contacts', (table) => {
+      table
+        .decimal('opening_balance_exchange_rate', 13, 9)
+        .after('opening_balance_at');
+    })
+    .table('items', (table) => {
+      table.dropColumn('currency_code');
+    });
+};
+
+exports.down = (knex) => {
+  return knex.schema
+    .table('sales_invoices', (table) => {
+      table.dropColumn('exchange_rate');
+    })
+    .table('sales_estimates', (table) => {
+      table.dropColumn('exchange_rate');
+    })
+    .table('sales_receipts', (table) => {
+      table.dropColumn('exchange_rate');
+    })
+    .table('payment_receives', (table) => {
+      table.dropColumn('exchange_rate');
+    })
+    .table('bills', (table) => {
+      table.dropColumn('exchange_rate');
+    })
+    .table('bills_payments', (table) => {
+      table.dropColumn('exchange_rate');
+    })
+    .table('credit_notes', (table) => {
+      table.dropColumn('exchange_rate');
+    })
+    .table('vendor_credits', (table) => {
+      table.dropColumn('exchange_rate');
+    })
+    .table('accounts_transactions', (table) => {
+      table.dropColumn('currency_code');
+      table.dropColumn('exchange_rate');
+    })
+    .table('manual_journals', (table) => {
+      table.dropColumn('exchange_rate');
+    })
+    .table('cashflow_transactions', (table) => {
+      table.dropColumn('currency_code');
+      table.dropColumn('exchange_rate');
+    })
+    .table('expenses_transactions', (table) => {
+      table.dropColumn('exchange_rate');
+    })
+    .table('refund_credit_note_transactions', (table) => {
+      table.dropColumn('exchange_rate');
+    })
+    .table('refund_vendor_credit_transactions', (table) => {
+      table.dropColumn('exchange_rate');
+    })
+    .table('bill_located_costs', (table) => {
+      table.dropColumn('currency_code');
+      table.dropColumn('exchange_rate');
+    })
+    .table('contacts', (table) => {
+      table.dropColumn('opening_balance_exchange_rate');
+    });
+};
diff --git a/packages/server/src/database/migrations/20220129121920_add_writtenoff_expense_account_to_invoices.js b/packages/server/src/database/migrations/20220129121920_add_writtenoff_expense_account_to_invoices.js
new file mode 100644
index 000000000..4f496cd11
--- /dev/null
+++ b/packages/server/src/database/migrations/20220129121920_add_writtenoff_expense_account_to_invoices.js
@@ -0,0 +1,15 @@
+exports.up = (knex) => {
+  return knex.schema.table('sales_invoices', (table) => {
+    table
+      .integer('writtenoff_expense_account_id')
+      .unsigned()
+      .references('id')
+      .inTable('accounts');
+  });
+};
+
+exports.down = (knex) => {
+  return knex.schema.table('sales_invoices', (table) => {
+    table.dropColumn('writtenoff_expense_account_id');
+  });
+};
diff --git a/packages/server/src/database/migrations/20220229121920_rename_contacts_shipping_billing_addresses.js b/packages/server/src/database/migrations/20220229121920_rename_contacts_shipping_billing_addresses.js
new file mode 100644
index 000000000..117086ef0
--- /dev/null
+++ b/packages/server/src/database/migrations/20220229121920_rename_contacts_shipping_billing_addresses.js
@@ -0,0 +1,19 @@
+exports.up = (knex) => {
+  return knex.schema
+    .raw(
+      'ALTER TABLE CONTACTS CHANGE SHIPPING_ADDRESS_1 SHIPPING_ADDRESS1 VARCHAR(255)'
+    )
+    .raw(
+      'ALTER TABLE CONTACTS CHANGE SHIPPING_ADDRESS_2 SHIPPING_ADDRESS2 VARCHAR(255)'
+    )
+    .raw(
+      'ALTER TABLE CONTACTS CHANGE BILLING_ADDRESS_1 BILLING_ADDRESS1 VARCHAR(255)'
+    )
+    .raw(
+      'ALTER TABLE CONTACTS CHANGE BILLING_ADDRESS_2 BILLING_ADDRESS2 VARCHAR(255)'
+    );
+};
+
+exports.down = (knex) => {
+  return knex.schema.table('contacts', (table) => {});
+};
diff --git a/packages/server/src/database/migrations/20220329121920_add_cashflow_credit_account.js b/packages/server/src/database/migrations/20220329121920_add_cashflow_credit_account.js
new file mode 100644
index 000000000..4bc18796f
--- /dev/null
+++ b/packages/server/src/database/migrations/20220329121920_add_cashflow_credit_account.js
@@ -0,0 +1,18 @@
+exports.up = (knex) => {
+  return knex.schema.table('cashflow_transactions', (table) => {
+    table
+      .integer('cashflow_account_id')
+      .unsigned()
+      .references('id')
+      .inTable('accounts');
+    table
+      .integer('credit_account_id')
+      .unsigned()
+      .references('id')
+      .inTable('accounts');
+  });
+};
+
+exports.down = (knex) => {
+  return knex.schema.table('cashflow_transactions', () => {});
+};
diff --git a/packages/server/src/database/migrations/20220329121920_add_seed_at_column_to_accounts.ts b/packages/server/src/database/migrations/20220329121920_add_seed_at_column_to_accounts.ts
new file mode 100644
index 000000000..257602b05
--- /dev/null
+++ b/packages/server/src/database/migrations/20220329121920_add_seed_at_column_to_accounts.ts
@@ -0,0 +1,7 @@
+exports.up = (knex) => {
+  return knex.schema.table('accounts', (table) => {
+    table.date('seeded_at').after('currency_code').nullable();
+  });
+};
+
+exports.down = (knex) => {};
diff --git a/packages/server/src/database/migrations/20220429121920_create_projects_table.ts b/packages/server/src/database/migrations/20220429121920_create_projects_table.ts
new file mode 100644
index 000000000..96518246f
--- /dev/null
+++ b/packages/server/src/database/migrations/20220429121920_create_projects_table.ts
@@ -0,0 +1,93 @@
+exports.up = (knex) => {
+  return knex.schema
+    .createTable('projects', (table) => {
+      table.increments('id').comment('Auto-generated id');
+      table.string('name');
+      table.integer('contact_id').unsigned();
+      table.date('deadline');
+      table.decimal('cost_estimate');
+      table.string('status');
+      table.timestamps();
+    })
+    .createTable('tasks', (table) => {
+      table.increments('id').comment('Auto-generated id');
+      table.string('name');
+      table.string('charge_type');
+      table.decimal('rate');
+      table.decimal('estimate_hours').unsigned();
+      table.decimal('actual_hours').unsigned();
+      table.decimal('invoiced_hours').unsigned().default(0);
+      table
+        .integer('project_id')
+        .unsigned()
+        .references('id')
+        .inTable('projects');
+      table.timestamps();
+    })
+    .createTable('times', (table) => {
+      table.increments('id').comment('Auto-generated id');
+      table.integer('duration').unsigned();
+      table.string('description');
+      table.date('date');
+
+      table.integer('taskId').unsigned().references('id').inTable('tasks');
+      table
+        .integer('project_id')
+        .unsigned()
+        .references('id')
+        .inTable('projects');
+      table.timestamps();
+    })
+    .table('accounts_transactions', (table) => {
+      table
+        .integer('projectId')
+        .unsigned()
+        .references('id')
+        .inTable('projects');
+    })
+    .table('manual_journals_entries', (table) => {
+      table
+        .integer('projectId')
+        .unsigned()
+        .references('id')
+        .inTable('projects');
+    })
+    .table('bills', (table) => {
+      table
+        .integer('projectId')
+        .unsigned()
+        .references('id')
+        .inTable('projects');
+      table.decimal('invoiced_amount').unsigned().defaultTo(0);
+    })
+    .table('items_entries', (table) => {
+      table
+        .integer('projectId')
+        .unsigned()
+        .references('id')
+        .inTable('projects');
+
+      table.integer('project_ref_id').unsigned();
+      table.string('project_ref_type');
+      table.decimal('project_ref_invoiced_amount').unsigned().defaultTo(0);
+    })
+    .table('sales_invoices', (table) => {
+      table
+        .integer('projectId')
+        .unsigned()
+        .references('id')
+        .inTable('projects');
+    })
+    .table('expenses_transactions', (table) => {
+      table
+        .integer('projectId')
+        .unsigned()
+        .references('id')
+        .inTable('projects');
+      table.decimal('invoiced_amount').unsigned().defaultTo(0);
+    });
+};
+
+exports.down = (knex) => {
+  return knex.schema.dropTable('tasks');
+};
diff --git a/packages/server/src/database/migrations/20220429121922_add_project_id_to_expense_lines.ts b/packages/server/src/database/migrations/20220429121922_add_project_id_to_expense_lines.ts
new file mode 100644
index 000000000..7d3931f35
--- /dev/null
+++ b/packages/server/src/database/migrations/20220429121922_add_project_id_to_expense_lines.ts
@@ -0,0 +1,7 @@
+exports.up = (knex) => {
+  return knex.schema.table('expense_transaction_categories', (table) => {
+    table.integer('projectId').unsigned().references('id').inTable('projects');
+  });
+};
+
+exports.down = (knex) => {};
diff --git a/packages/server/src/database/objection.ts b/packages/server/src/database/objection.ts
new file mode 100644
index 000000000..cf57361c4
--- /dev/null
+++ b/packages/server/src/database/objection.ts
@@ -0,0 +1,8 @@
+import { Model } from 'objection';
+
+// Bind all Models to a knex instance. If you only have one database in
+// your server this is all you have to do. For multi database systems, see
+// the Model.bindKnex() method.
+export default ({ knex }) => {
+  Model.knex(knex);
+};
diff --git a/packages/server/src/database/seeds/core/20190423085242_seed_accounts.ts b/packages/server/src/database/seeds/core/20190423085242_seed_accounts.ts
new file mode 100644
index 000000000..eff86978f
--- /dev/null
+++ b/packages/server/src/database/seeds/core/20190423085242_seed_accounts.ts
@@ -0,0 +1,22 @@
+import { TenantSeeder } from '@/lib/Seeder/TenantSeeder';
+import AccountsData from '../data/accounts';
+
+export default class SeedAccounts extends TenantSeeder {
+  /**
+   * Seeds initial accounts to the organization. 
+   */
+  up(knex) {
+    const data = AccountsData.map((account) => {
+      return {
+        ...account,
+        name: this.i18n.__(account.name),
+        description: this.i18n.__(account.description),
+        currencyCode: this.tenant.metadata.baseCurrency,
+      };
+    });
+    return knex('accounts').then(async () => {
+      // Inserts seed entries.
+      return knex('accounts').insert(data);
+    });
+  }
+}
diff --git a/packages/server/src/database/seeds/core/20200810121809_seed_settings.ts b/packages/server/src/database/seeds/core/20200810121809_seed_settings.ts
new file mode 100644
index 000000000..4e02409d0
--- /dev/null
+++ b/packages/server/src/database/seeds/core/20200810121809_seed_settings.ts
@@ -0,0 +1,52 @@
+import { TenantSeeder } from '@/lib/Seeder/TenantSeeder';
+
+export default class SeedSettings extends TenantSeeder {
+  /**
+   *
+   * @returns
+   */
+  up() {
+    const settings = [
+      // Orgnization settings.
+      { group: 'organization', key: 'accounting_basis', value: 'accural' },
+
+      // Accounts settings.
+      { group: 'accounts', key: 'account_code_unique', value: true },
+
+      // Manual journals settings.
+      { group: 'manual_journals', key: 'next_number', value: '00001' },
+      { group: 'manual_journals', key: 'auto_increment', value: true },
+
+      // Sale invoices settings.
+      { group: 'sales_invoices', key: 'next_number', value: '00001' },
+      { group: 'sales_invoices', key: 'number_prefix', value: 'INV-' },
+      { group: 'sales_invoices', key: 'auto_increment', value: true },
+
+      // Sale receipts settings.
+      { group: 'sales_receipts', key: 'next_number', value: '00001' },
+      { group: 'sales_receipts', key: 'number_prefix', value: 'REC-' },
+      { group: 'sales_receipts', key: 'auto_increment', value: true },
+
+      // Sale estimates settings.
+      { group: 'sales_estimates', key: 'next_number', value: '00001' },
+      { group: 'sales_estimates', key: 'number_prefix', value: 'EST-' },
+      { group: 'sales_estimates', key: 'auto_increment', value: true },
+
+      // Payment receives settings.
+      { group: 'payment_receives', key: 'number_prefix', value: 'PAY-' },
+      { group: 'payment_receives', key: 'next_number', value: '00001' },
+      { group: 'payment_receives', key: 'auto_increment', value: true },
+
+      // Cashflow settings.
+      { group: 'cashflow', key: 'number_prefix', value: 'CF-' },
+      { group: 'cashflow', key: 'next_number', value: '00001' },
+      { group: 'cashflow', key: 'auto_increment', value: true },
+
+      // warehouse transfers settings.
+      { group: 'warehouse_transfers', key: 'next_number', value: '00001' },
+      { group: 'warehouse_transfers', key: 'number_prefix', value: 'WT-' },
+      { group: 'warehouse_transfers', key: 'auto_increment', value: true },
+    ];
+    return this.knex('settings').insert(settings);
+  }
+}
diff --git a/packages/server/src/database/seeds/core/20200810121909_seed_items_settings.ts b/packages/server/src/database/seeds/core/20200810121909_seed_items_settings.ts
new file mode 100644
index 000000000..1950b4c75
--- /dev/null
+++ b/packages/server/src/database/seeds/core/20200810121909_seed_items_settings.ts
@@ -0,0 +1,34 @@
+import { TenantSeeder } from '@/lib/Seeder/TenantSeeder';
+
+export default class SeedSettings extends TenantSeeder {
+  /**
+   * 
+   * @param knex 
+   * @returns 
+   */
+  async up(knex) {
+    const costAccount = await knex('accounts')
+      .where('slug', 'cost-of-goods-sold')
+      .first();
+
+    const sellAccount = await knex('accounts')
+      .where('slug', 'sales-of-product-income')
+      .first();
+
+    const inventoryAccount = await knex('accounts')
+      .where('slug', 'inventory-asset')
+      .first();
+
+    const settings = [
+      // Items settings.
+      { group: 'items', key: 'preferred_sell_account', value: sellAccount?.id },
+      { group: 'items', key: 'preferred_cost_account', value: costAccount?.id },
+      {
+        group: 'items',
+        key: 'preferred_inventory_account',
+        value: inventoryAccount?.id,
+      },
+    ];
+    return knex('settings').insert(settings);
+  }
+}
diff --git a/packages/server/src/database/seeds/core/20210810121909_seed_roles.ts b/packages/server/src/database/seeds/core/20210810121909_seed_roles.ts
new file mode 100644
index 000000000..5bbca56b4
--- /dev/null
+++ b/packages/server/src/database/seeds/core/20210810121909_seed_roles.ts
@@ -0,0 +1,28 @@
+import { TenantSeeder } from '@/lib/Seeder/TenantSeeder';
+
+export default class SeedRolesAndPermissions extends TenantSeeder {
+  /**
+   * Seeds roles and associated permissiojns.
+   * @param knex
+   * @returns
+   */
+  // eslint-disable-next-line class-methods-use-this
+  async up(knex) {
+    return knex('roles').insert([
+      {
+        id: 1,
+        name: 'role.admin.name',
+        predefined: true,
+        slug: 'admin',
+        description: 'role.admin.desc',
+      },
+      {
+        id: 2,
+        name: 'role.staff.name',
+        predefined: true,
+        slug: 'staff',
+        description: 'role.staff.desc',
+      },
+    ]);
+  }
+}
diff --git a/packages/server/src/database/seeds/core/20210812121909_seed_roles_permissions.ts b/packages/server/src/database/seeds/core/20210812121909_seed_roles_permissions.ts
new file mode 100644
index 000000000..041057387
--- /dev/null
+++ b/packages/server/src/database/seeds/core/20210812121909_seed_roles_permissions.ts
@@ -0,0 +1,49 @@
+import { TenantSeeder } from '@/lib/Seeder/TenantSeeder';
+
+export default class SeedRolesAndPermissions extends TenantSeeder {
+  /**
+   * Seeds roles and associated permissiojns.
+   * @param knex
+   * @returns
+   */
+  // eslint-disable-next-line class-methods-use-this
+  async up(knex) {
+    return knex('role_permissions').insert([
+      // Assign sale invoice permissions to staff role.
+      { roleId: 2, subject: 'SaleInvoice', ability: 'create' },
+      { roleId: 2, subject: 'SaleInvoice', ability: 'delete' },
+      { roleId: 2, subject: 'SaleInvoice', ability: 'view' },
+      { roleId: 2, subject: 'SaleInvoice', ability: 'edit' },
+
+      // Assign sale estimate permissions to staff role.
+      { roleId: 2, subject: 'SaleEstimate', ability: 'create' },
+      { roleId: 2, subject: 'SaleEstimate', ability: 'delete' },
+      { roleId: 2, subject: 'SaleEstimate', ability: 'view' },
+      { roleId: 2, subject: 'SaleEstimate', ability: 'edit' },
+
+      // Assign sale receipt permissions to staff role.
+      { roleId: 2, subject: 'SaleReceipt', ability: 'create' },
+      { roleId: 2, subject: 'SaleReceipt', ability: 'delete' },
+      { roleId: 2, subject: 'SaleReceipt', ability: 'view' },
+      { roleId: 2, subject: 'SaleReceipt', ability: 'edit' },
+
+      // Assign payment receive permissions to staff role.
+      { roleId: 2, subject: 'PaymentReceive', ability: 'create' },
+      { roleId: 2, subject: 'PaymentReceive', ability: 'delete' },
+      { roleId: 2, subject: 'PaymentReceive', ability: 'view' },
+      { roleId: 2, subject: 'PaymentReceive', ability: 'edit' },
+
+      // Assign bill permissions to staff role.
+      { roleId: 2, subject: 'Bill', ability: 'create' },
+      { roleId: 2, subject: 'Bill', ability: 'delete' },
+      { roleId: 2, subject: 'Bill', ability: 'view' },
+      { roleId: 2, subject: 'Bill', ability: 'edit' },
+
+      // Assign payment made permissions to staff role.
+      { roleId: 2, subject: 'PaymentMade', ability: 'create' },
+      { roleId: 2, subject: 'PaymentMade', ability: 'delete' },
+      { roleId: 2, subject: 'PaymentMade', ability: 'view' },
+      { roleId: 2, subject: 'PaymentMade', ability: 'edit' },
+    ]);
+  }
+}
diff --git a/packages/server/src/database/seeds/core/20210912121909_seed_credit_settings.ts b/packages/server/src/database/seeds/core/20210912121909_seed_credit_settings.ts
new file mode 100644
index 000000000..3c88a4c76
--- /dev/null
+++ b/packages/server/src/database/seeds/core/20210912121909_seed_credit_settings.ts
@@ -0,0 +1,22 @@
+import { TenantSeeder } from '@/lib/Seeder/TenantSeeder';
+
+export default class SeedCustomerVendorCreditSettings extends TenantSeeder {
+  /**
+   *
+   * @returns
+   */
+  up() {
+    const settings = [
+      // Credit note.
+      { group: 'credit_note', key: 'number_prefix', value: 'CN-' },
+      { group: 'credit_note', key: 'next_number', value: '00001' },
+      { group: 'credit_note', key: 'auto_increment', value: true },
+
+      // Vendor credit.
+      { group: 'vendor_credit', key: 'number_prefix', value: 'VC-' },
+      { group: 'vendor_credit', key: 'next_number', value: '00001' },
+      { group: 'vendor_credit', key: 'auto_increment', value: true },
+    ];
+    return this.knex('settings').insert(settings);
+  }
+}
diff --git a/packages/server/src/database/seeds/core/index.ts b/packages/server/src/database/seeds/core/index.ts
new file mode 100644
index 000000000..0b95c889d
--- /dev/null
+++ b/packages/server/src/database/seeds/core/index.ts
@@ -0,0 +1 @@
+// .gitkeep
\ No newline at end of file
diff --git a/packages/server/src/database/seeds/data/accounts.js b/packages/server/src/database/seeds/data/accounts.js
new file mode 100644
index 000000000..fb6bf6c07
--- /dev/null
+++ b/packages/server/src/database/seeds/data/accounts.js
@@ -0,0 +1,318 @@
+
+export default [
+  {
+    name:'Bank Account',
+    slug: 'bank-account',
+    account_type: 'bank',
+    code: '10001',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name:'Saving Bank Account',
+    slug: 'saving-bank-account',
+    account_type: 'bank',
+    code: '10002',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  {
+    name:'Undeposited Funds',
+    slug: 'undeposited-funds',
+    account_type: 'cash',
+    code: '10003',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name:'Petty Cash',
+    slug: 'petty-cash',
+    account_type: 'cash',
+    code: '10004',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name:'Computer Equipment',
+    slug: 'computer-equipment',
+    code: '10005',
+    account_type: 'fixed-asset',
+    predefined: 0,
+    parent_account_id: null,
+    index: 1,
+    active: 1,
+    description: '',
+  },
+  {
+    name:'Office Equipment',
+    slug: 'office-equipment',
+    code: '10006',
+    account_type: 'fixed-asset',
+    predefined: 0,
+    parent_account_id: null,
+    index: 1,
+    active: 1,
+    description: '',
+  },
+  {
+    name:'Accounts Receivable (A/R)',
+    slug: 'accounts-receivable',
+    account_type: 'accounts-receivable',
+    code: '10007',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name:'Inventory Asset',
+    slug: 'inventory-asset',
+    code: '10008',
+    account_type: 'inventory',
+    predefined: 1,
+    parent_account_id: null,
+    index: 1,
+    active: 1,
+    description:'An account that holds valuation of products or goods that availiable for sale.',
+  },
+
+  // Libilities
+  {
+    name:'Accounts Payable (A/P)',
+    slug: 'accounts-payable',
+    account_type: 'accounts-payable',
+    parent_account_id: null,
+    code: '20001',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name:'Owner A Drawings',
+    slug: 'owner-drawings',
+    account_type: 'other-current-liability',
+    parent_account_id: null,
+    code: '20002',
+    description:'Withdrawals by the owners.',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  {
+    name:'Loan',
+    slug: 'owner-drawings',
+    account_type: 'other-current-liability',
+    code: '20003',
+    description:'Money that has been borrowed from a creditor.',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  {
+    name:'Opening Balance Liabilities',
+    slug: 'opening-balance-liabilities',
+    account_type: 'other-current-liability',
+    code: '20004',
+    description:'This account will hold the difference in the debits and credits entered during the opening balance..',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  {
+    name:'Revenue Received in Advance',
+    slug: 'revenue-received-in-advance',
+    account_type: 'other-current-liability',
+    parent_account_id: null,
+    code: '20005',
+    description: 'When customers pay in advance for products/services.',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  {
+    name:'Sales Tax Payable',
+    slug: 'owner-drawings',
+    account_type: 'other-current-liability',
+    code: '20006',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+
+  // Equity
+  {
+    name:'Retained Earnings',
+    slug: 'retained-earnings',
+    account_type: 'equity',
+    code: '30001',
+    description:'Retained earnings tracks net income from previous fiscal years.',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name:'Opening Balance Equity',
+    slug: 'opening-balance-equity',
+    account_type: 'equity',
+    code: '30002',
+    description:'When you enter opening balances to the accounts, the amounts enter in Opening balance equity. This ensures that you have a correct trial balance sheet for your company, without even specific the second credit or debit entry.',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name: "Owner's Equity",
+    slug: 'owner-equity',
+    account_type: 'equity',
+    code: '30003',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name:`Drawings`,
+    slug: 'drawings',
+    account_type: 'equity',
+    code: '30003',
+    description:'Goods purchased with the intention of selling these to customers',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+
+  // Expenses
+  {
+    name:'Other Expenses',
+    slug: 'other-expenses',
+    account_type: 'other-expense',
+    parent_account_id: null,
+    code: '40001',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name:'Cost of Goods Sold',
+    slug: 'cost-of-goods-sold',
+    account_type: 'cost-of-goods-sold',
+    parent_account_id: null,
+    code: '40002',
+    description:'Tracks the direct cost of the goods sold.',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name:'Office expenses',
+    slug: 'office-expenses',
+    account_type: 'expense',
+    parent_account_id: null,
+    code: '40003',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  {
+    name:'Rent',
+    slug: 'rent',
+    account_type: 'expense',
+    parent_account_id: null,
+    code: '40004',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  {
+    name:'Exchange Gain or Loss',
+    slug: 'exchange-grain-loss',
+    account_type: 'other-expense',
+    parent_account_id: null,
+    code: '40005',
+    description:'Tracks the gain and losses of the exchange differences.',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name:'Bank Fees and Charges',
+    slug: 'bank-fees-and-charges',
+    account_type: 'expense',
+    parent_account_id: null,
+    code: '40006',
+    description: 'Any bank fees levied is recorded into the bank fees and charges account. A bank account maintenance fee, transaction charges, a late payment fee are some examples.',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  {
+    name:'Depreciation Expense',
+    slug: 'depreciation-expense',
+    account_type: 'expense',
+    parent_account_id: null,
+    code: '40007',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+
+  // Income
+  {
+    name:'Sales of Product Income',
+    slug: 'sales-of-product-income',
+    account_type: 'income',
+    predefined: 1,
+    parent_account_id: null,
+    code: '50001',
+    index: 1,
+    active: 1,
+    description: '',
+  },
+  {
+    name:'Sales of Service Income',
+    slug: 'sales-of-service-income',
+    account_type: 'income',
+    predefined: 0,
+    parent_account_id: null,
+    code: '50002',
+    index: 1,
+    active: 1,
+    description: '',
+  },
+  {
+    name:'Uncategorized Income',
+    slug: 'uncategorized-income',
+    account_type: 'income',
+    parent_account_id: null,
+    code: '50003',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name:'Other Income',
+    slug: 'other-income',
+    account_type: 'other-income',
+    parent_account_id: null,
+    code: '50004',
+    description:'The income activities are not associated to the core business.',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  }
+];
\ No newline at end of file
diff --git a/packages/server/src/decorators/eventDispatcher.ts b/packages/server/src/decorators/eventDispatcher.ts
new file mode 100644
index 000000000..4ac9a6d50
--- /dev/null
+++ b/packages/server/src/decorators/eventDispatcher.ts
@@ -0,0 +1,11 @@
+import { EventDispatcher as EventDispatcherClass } from 'event-dispatch';
+import { Container } from 'typedi';
+
+export function EventDispatcher() {
+  return (object: any, propertyName: string, index?: number): void => {
+    const eventDispatcher = new EventDispatcherClass();
+    Container.registerHandler({ object, propertyName, index, value: () => eventDispatcher });
+  };
+}
+
+export { EventDispatcher as EventDispatcherInterface } from 'event-dispatch';
diff --git a/packages/server/src/exceptions/HttpException.ts b/packages/server/src/exceptions/HttpException.ts
new file mode 100644
index 000000000..217b082ae
--- /dev/null
+++ b/packages/server/src/exceptions/HttpException.ts
@@ -0,0 +1,9 @@
+class HttpException extends Error {
+  public status: number;
+  public message: string;
+  constructor(status: number, message: string) {
+    super(message);
+    this.status = status;
+    this.message = message;
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/exceptions/ModelEntityNotFound.ts b/packages/server/src/exceptions/ModelEntityNotFound.ts
new file mode 100644
index 000000000..a7bd6dfe1
--- /dev/null
+++ b/packages/server/src/exceptions/ModelEntityNotFound.ts
@@ -0,0 +1,8 @@
+
+export default class ModelEntityNotFound extends Error {
+
+  constructor(entityId, message?) {
+    message = message || `Entity with id ${entityId} does not exist`;
+    super(message);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/exceptions/NoPaymentModelWithPricedPlan.ts b/packages/server/src/exceptions/NoPaymentModelWithPricedPlan.ts
new file mode 100644
index 000000000..938ec8b4a
--- /dev/null
+++ b/packages/server/src/exceptions/NoPaymentModelWithPricedPlan.ts
@@ -0,0 +1,8 @@
+
+
+export default class NoPaymentModelWithPricedPlan {
+
+  constructor() {
+    
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/exceptions/NotAllowedChangeSubscriptionPlan.ts b/packages/server/src/exceptions/NotAllowedChangeSubscriptionPlan.ts
new file mode 100644
index 000000000..3c5380259
--- /dev/null
+++ b/packages/server/src/exceptions/NotAllowedChangeSubscriptionPlan.ts
@@ -0,0 +1,8 @@
+
+
+export default class NotAllowedChangeSubscriptionPlan {
+
+  constructor() {
+    this.name = "NotAllowedChangeSubscriptionPlan";
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/exceptions/PaymentAmountInvalidWithPlan.ts b/packages/server/src/exceptions/PaymentAmountInvalidWithPlan.ts
new file mode 100644
index 000000000..834e8cbe1
--- /dev/null
+++ b/packages/server/src/exceptions/PaymentAmountInvalidWithPlan.ts
@@ -0,0 +1,7 @@
+
+
+export default class PaymentAmountInvalidWithPlan{
+  constructor() {
+    
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/exceptions/PaymentInputInvalid.ts b/packages/server/src/exceptions/PaymentInputInvalid.ts
new file mode 100644
index 000000000..065bfb3b4
--- /dev/null
+++ b/packages/server/src/exceptions/PaymentInputInvalid.ts
@@ -0,0 +1,5 @@
+
+
+export default class PaymentInputInvalid {
+  constructor() {}
+}
\ No newline at end of file
diff --git a/packages/server/src/exceptions/ServiceError.ts b/packages/server/src/exceptions/ServiceError.ts
new file mode 100644
index 000000000..2e3139805
--- /dev/null
+++ b/packages/server/src/exceptions/ServiceError.ts
@@ -0,0 +1,14 @@
+
+
+export default class ServiceError {
+  errorType: string;
+  message: string;
+  payload: any;
+
+  constructor(errorType: string, message?: string, payload?: any) {
+    this.errorType = errorType;
+    this.message = message || null;
+
+    this.payload = payload;
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/exceptions/ServiceErrors.ts b/packages/server/src/exceptions/ServiceErrors.ts
new file mode 100644
index 000000000..cb15ff196
--- /dev/null
+++ b/packages/server/src/exceptions/ServiceErrors.ts
@@ -0,0 +1,15 @@
+import ServiceError from './ServiceError';
+
+
+export default class ServiceErrors {
+  errors: ServiceError[];
+
+  constructor(errors: ServiceError[]) {
+    this.errors = errors;
+  }
+
+  hasType(errorType: string) {
+    return this.errors
+      .some((error: ServiceError) => error.errorType === errorType);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/exceptions/TenantAlreadyInitialized.ts b/packages/server/src/exceptions/TenantAlreadyInitialized.ts
new file mode 100644
index 000000000..72c11f810
--- /dev/null
+++ b/packages/server/src/exceptions/TenantAlreadyInitialized.ts
@@ -0,0 +1,7 @@
+
+
+export default class TenantAlreadyInitialized {
+  constructor() {
+    
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/exceptions/TenantAlreadySeeded.ts b/packages/server/src/exceptions/TenantAlreadySeeded.ts
new file mode 100644
index 000000000..b4fac0bb0
--- /dev/null
+++ b/packages/server/src/exceptions/TenantAlreadySeeded.ts
@@ -0,0 +1,9 @@
+
+
+
+
+export default class TenantAlreadySeeded {
+  constructor() {
+    
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/exceptions/TenantDBAlreadyExists.ts b/packages/server/src/exceptions/TenantDBAlreadyExists.ts
new file mode 100644
index 000000000..72c51890d
--- /dev/null
+++ b/packages/server/src/exceptions/TenantDBAlreadyExists.ts
@@ -0,0 +1,9 @@
+
+
+
+
+export default class TenantDBAlreadyExists {
+  constructor() {
+    
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/exceptions/TenantDatabaseNotBuilt.ts b/packages/server/src/exceptions/TenantDatabaseNotBuilt.ts
new file mode 100644
index 000000000..8b655e10a
--- /dev/null
+++ b/packages/server/src/exceptions/TenantDatabaseNotBuilt.ts
@@ -0,0 +1,7 @@
+
+
+export default class TenantDatabaseNotBuilt {
+  constructor() {
+    
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/exceptions/VoucherCodeRequired.ts b/packages/server/src/exceptions/VoucherCodeRequired.ts
new file mode 100644
index 000000000..b92eb155c
--- /dev/null
+++ b/packages/server/src/exceptions/VoucherCodeRequired.ts
@@ -0,0 +1,6 @@
+
+export default class VoucherCodeRequired {
+  constructor() {
+    this.name = 'VoucherCodeRequired';
+  }
+}
diff --git a/packages/server/src/exceptions/index.ts b/packages/server/src/exceptions/index.ts
new file mode 100644
index 000000000..a18746d02
--- /dev/null
+++ b/packages/server/src/exceptions/index.ts
@@ -0,0 +1,25 @@
+import NotAllowedChangeSubscriptionPlan from './NotAllowedChangeSubscriptionPlan';
+import ServiceError from './ServiceError';
+import ServiceErrors from './ServiceErrors';
+import NoPaymentModelWithPricedPlan from './NoPaymentModelWithPricedPlan';
+import PaymentInputInvalid from './PaymentInputInvalid';
+import PaymentAmountInvalidWithPlan from './PaymentAmountInvalidWithPlan';
+import TenantAlreadyInitialized from './TenantAlreadyInitialized';
+import TenantAlreadySeeded from './TenantAlreadySeeded';
+import TenantDBAlreadyExists from './TenantDBAlreadyExists';
+import TenantDatabaseNotBuilt from './TenantDatabaseNotBuilt';
+import VoucherCodeRequired from './VoucherCodeRequired';
+
+export {
+  NotAllowedChangeSubscriptionPlan,
+  NoPaymentModelWithPricedPlan,
+  PaymentAmountInvalidWithPlan,
+  ServiceError,
+  ServiceErrors,
+  PaymentInputInvalid,
+  TenantAlreadyInitialized,
+  TenantAlreadySeeded,
+  TenantDBAlreadyExists,
+  TenantDatabaseNotBuilt,
+  VoucherCodeRequired,
+};
\ No newline at end of file
diff --git a/packages/server/src/interfaces/APAgingSummaryReport.ts b/packages/server/src/interfaces/APAgingSummaryReport.ts
new file mode 100644
index 000000000..788892112
--- /dev/null
+++ b/packages/server/src/interfaces/APAgingSummaryReport.ts
@@ -0,0 +1,51 @@
+import {
+  IAgingPeriod,
+  IAgingPeriodTotal,
+  IAgingAmount
+} from './AgingReport';
+import {
+  INumberFormatQuery
+} from './FinancialStatements';
+
+export interface IAPAgingSummaryQuery {
+  asDate: Date | string;
+  agingDaysBefore: number;
+  agingPeriods: number;
+  numberFormat: INumberFormatQuery;
+  vendorsIds: number[];
+  noneZero: boolean;
+
+  branchesIds?: number[]
+}
+
+export interface IAPAgingSummaryVendor {
+  vendorName: string,
+  current: IAgingAmount,
+  aging: IAgingPeriodTotal[],
+  total: IAgingAmount,
+};
+
+export interface IAPAgingSummaryTotal {
+  current: IAgingAmount,
+  aging: IAgingPeriodTotal[],
+  total: IAgingAmount,
+};
+
+export interface IAPAgingSummaryData {
+  vendors: IAPAgingSummaryVendor[],
+  total: IAPAgingSummaryTotal,
+};
+
+export type IAPAgingSummaryColumns = IAgingPeriod[];
+
+
+export interface IARAgingSummaryMeta {
+  baseCurrency: string,
+  organizationName: string,
+}
+
+
+export interface IAPAgingSummaryMeta {
+  baseCurrency: string,
+  organizationName: string,
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/ARAgingSummaryReport.ts b/packages/server/src/interfaces/ARAgingSummaryReport.ts
new file mode 100644
index 000000000..a9d6ff3f5
--- /dev/null
+++ b/packages/server/src/interfaces/ARAgingSummaryReport.ts
@@ -0,0 +1,37 @@
+import { IAgingPeriod, IAgingPeriodTotal, IAgingAmount } from './AgingReport';
+import { INumberFormatQuery } from './FinancialStatements';
+
+export interface IARAgingSummaryQuery {
+  asDate: Date | string;
+  agingDaysBefore: number;
+  agingPeriods: number;
+  numberFormat: INumberFormatQuery;
+  customersIds: number[];
+  branchesIds: number[];
+  noneZero: boolean;
+}
+
+export interface IARAgingSummaryCustomer {
+  customerName: string;
+  current: IAgingAmount;
+  aging: IAgingPeriodTotal[];
+  total: IAgingAmount;
+}
+
+export interface IARAgingSummaryTotal {
+  current: IAgingAmount;
+  aging: IAgingPeriodTotal[];
+  total: IAgingAmount;
+}
+
+export interface IARAgingSummaryData {
+  customers: IARAgingSummaryCustomer[];
+  total: IARAgingSummaryTotal;
+}
+
+export type IARAgingSummaryColumns = IAgingPeriod[];
+
+export interface IARAgingSummaryMeta {
+  organizationName: string,
+  baseCurrency: string,
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/Account.ts b/packages/server/src/interfaces/Account.ts
new file mode 100644
index 000000000..d89616135
--- /dev/null
+++ b/packages/server/src/interfaces/Account.ts
@@ -0,0 +1,144 @@
+import { Knex } from 'knex';
+import { IDynamicListFilterDTO } from '@/interfaces/DynamicFilter';
+
+export interface IAccountDTO {
+  name: string;
+  code: string;
+  description: string;
+  accountType: string;
+  parentAccountId: number;
+  active: boolean;
+}
+
+export interface IAccountCreateDTO extends IAccountDTO {
+  currencyCode?: string;
+}
+
+export interface IAccountEditDTO extends IAccountDTO {}
+
+export interface IAccount {
+  id: number;
+  name: string;
+  slug: string;
+  code: string;
+  index: number;
+  description: string;
+  accountType: string;
+  parentAccountId: number;
+  active: boolean;
+  predefined: boolean;
+  amount: number;
+  currencyCode: string;
+  transactions?: any[];
+  type?: any[];
+  accountNormal: string;
+  accountParentType: string;
+}
+
+export enum AccountNormal {
+  DEBIT = 'debit',
+  CREDIT = 'credit',
+}
+
+export interface IAccountsTransactionsFilter {
+  accountId?: number;
+}
+
+export interface IAccountTransaction {
+  id?: number;
+
+  credit: number;
+  debit: number;
+  currencyCode: string;
+  exchangeRate: number;
+
+  accountId: number;
+  contactId?: number | null;
+  date: string | Date;
+
+  referenceType: string;
+  referenceId: number;
+
+  referenceNumber?: string;
+  transactionNumber?: string;
+
+  note?: string;
+
+  index: number;
+  indexGroup?: number;
+
+  costable?: boolean;
+
+  userId?: number;
+  itemId?: number;
+  branchId?: number;
+  projectId?: number;
+
+  account?: IAccount;
+}
+export interface IAccountResponse extends IAccount {}
+
+export interface IAccountsFilter extends IDynamicListFilterDTO {
+  stringifiedFilterRoles?: string;
+  onlyInactive: boolean;
+}
+
+export interface IAccountType {
+  label: string;
+  key: string;
+  normal: string;
+  rootType: string;
+  childType: string;
+  balanceSheet: boolean;
+  incomeSheet: boolean;
+}
+
+export interface IAccountsTypesService {
+  getAccountsTypes(tenantId: number): Promise<IAccountType>;
+}
+
+export interface IAccountEventCreatingPayload {
+  tenantId: number;
+  accountDTO: any;
+  trx: Knex.Transaction;
+}
+export interface IAccountEventCreatedPayload {
+  tenantId: number;
+  account: IAccount;
+  accountId: number;
+  trx: Knex.Transaction;
+}
+
+export interface IAccountEventEditedPayload {
+  tenantId: number;
+  account: IAccount;
+  oldAccount: IAccount;
+  trx: Knex.Transaction;
+}
+
+export interface IAccountEventDeletedPayload {
+  tenantId: number;
+  accountId: number;
+  oldAccount: IAccount;
+  trx: Knex.Transaction;
+}
+
+export interface IAccountEventDeletePayload {
+  trx: Knex.Transaction;
+  oldAccount: IAccount;
+  tenantId: number;
+}
+
+export interface IAccountEventActivatedPayload {
+  tenantId: number;
+  accountId: number;
+  trx: Knex.Transaction;
+}
+
+export enum AccountAction {
+  CREATE = 'Create',
+  EDIT = 'Edit',
+  DELETE = 'Delete',
+  VIEW = 'View',
+  TransactionsLocking = 'TransactionsLocking',
+}
diff --git a/packages/server/src/interfaces/AgingReport.ts b/packages/server/src/interfaces/AgingReport.ts
new file mode 100644
index 000000000..65983d44f
--- /dev/null
+++ b/packages/server/src/interfaces/AgingReport.ts
@@ -0,0 +1,22 @@
+export interface IAgingPeriodTotal extends IAgingPeriod {
+  total: IAgingAmount;
+};
+
+export interface IAgingAmount {
+  amount: number;
+  formattedAmount: string;
+  currencyCode: string;
+}
+
+export interface IAgingPeriod {
+  fromPeriod: Date | string;
+  toPeriod: Date | string;
+  beforeDays: number;
+  toDays: number;
+}
+
+export interface IAgingSummaryContact {
+  current: IAgingAmount;
+  aging: IAgingPeriodTotal[];
+  total: IAgingAmount;
+}
diff --git a/packages/server/src/interfaces/Authentication.ts b/packages/server/src/interfaces/Authentication.ts
new file mode 100644
index 000000000..be86dfdd3
--- /dev/null
+++ b/packages/server/src/interfaces/Authentication.ts
@@ -0,0 +1,29 @@
+import { ISystemUser } from './User';
+import { ITenant } from './Tenancy';
+
+export interface IRegisterDTO {
+  firstName: string,
+  lastName: string,
+  email: string,
+  password: string,
+  organizationName: string,
+};
+
+export interface ILoginDTO {
+  crediential: string,
+  password: string,
+};
+
+export interface IPasswordReset {
+  id: number,
+  email: string,
+  token: string,
+  createdAt: Date,
+};
+
+export interface IAuthenticationService {
+  signIn(emailOrPhone: string, password: string): Promise<{ user: ISystemUser, token: string, tenant: ITenant }>;
+  register(registerDTO: IRegisterDTO): Promise<ISystemUser>;
+  sendResetPassword(email: string): Promise<IPasswordReset>;
+  resetPassword(token: string, password: string): Promise<void>;
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/BalanceSheet.ts b/packages/server/src/interfaces/BalanceSheet.ts
new file mode 100644
index 000000000..a175c405f
--- /dev/null
+++ b/packages/server/src/interfaces/BalanceSheet.ts
@@ -0,0 +1,192 @@
+import {
+  INumberFormatQuery,
+  IFormatNumberSettings,
+  IFinancialSheetBranchesQuery,
+} from './FinancialStatements';
+
+// Balance sheet schema nodes types.
+export enum BALANCE_SHEET_SCHEMA_NODE_TYPE {
+  AGGREGATE = 'AGGREGATE',
+  ACCOUNTS = 'ACCOUNTS',
+  ACCOUNT = 'ACCOUNT',
+}
+
+export enum BALANCE_SHEET_NODE_TYPE {
+  AGGREGATE = 'AGGREGATE',
+  ACCOUNTS = 'ACCOUNTS',
+  ACCOUNT = 'ACCOUNT',
+}
+
+// Balance sheet schema nodes ids.
+export enum BALANCE_SHEET_SCHEMA_NODE_ID {
+  ASSETS = 'ASSETS',
+  CURRENT_ASSETS = 'CURRENT_ASSETS',
+  CASH_EQUIVALENTS = 'CASH_EQUIVALENTS',
+  ACCOUNTS_RECEIVABLE = 'ACCOUNTS_RECEIVABLE',
+  NON_CURRENT_ASSET = 'NON_CURRENT_ASSET',
+  FIXED_ASSET = 'FIXED_ASSET',
+  OTHER_CURRENT_ASSET = 'OTHER_CURRENT_ASSET',
+  INVENTORY = 'INVENTORY',
+  LIABILITY_EQUITY = 'LIABILITY_EQUITY',
+  LIABILITY = 'LIABILITY',
+  CURRENT_LIABILITY = 'CURRENT_LIABILITY',
+  LOGN_TERM_LIABILITY = 'LOGN_TERM_LIABILITY',
+  NON_CURRENT_LIABILITY = 'NON_CURRENT_LIABILITY',
+  EQUITY = 'EQUITY',
+}
+
+// Balance sheet query.
+export interface IBalanceSheetQuery extends IFinancialSheetBranchesQuery {
+  displayColumnsType: 'total' | 'date_periods';
+  displayColumnsBy: string;
+  fromDate: Date;
+  toDate: Date;
+  numberFormat: INumberFormatQuery;
+  noneTransactions: boolean;
+  noneZero: boolean;
+  basis: 'cash' | 'accural';
+  accountIds: number[];
+
+  percentageOfColumn: boolean;
+  percentageOfRow: boolean;
+
+  previousPeriod: boolean;
+  previousPeriodAmountChange: boolean;
+  previousPeriodPercentageChange: boolean;
+
+  previousYear: boolean;
+  previousYearAmountChange: boolean;
+  previousYearPercentageChange: boolean;
+}
+
+// Balance sheet meta.
+export interface IBalanceSheetMeta {
+  isCostComputeRunning: boolean;
+  organizationName: string;
+  baseCurrency: string;
+}
+
+export interface IBalanceSheetFormatNumberSettings
+  extends IFormatNumberSettings {
+  type: string;
+}
+
+// Balance sheet service.
+export interface IBalanceSheetStatementService {
+  balanceSheet(
+    tenantId: number,
+    query: IBalanceSheetQuery
+  ): Promise<IBalanceSheetDOO>;
+}
+
+export type IBalanceSheetStatementData = IBalanceSheetDataNode[];
+
+export interface IBalanceSheetDOO {
+  query: IBalanceSheetQuery;
+  data: IBalanceSheetStatementData;
+  meta: IBalanceSheetMeta;
+}
+
+
+export interface IBalanceSheetCommonNode {
+  total: IBalanceSheetTotal;
+  horizontalTotals?: IBalanceSheetTotal[];
+
+  percentageRow?: IBalanceSheetPercentageAmount;
+  percentageColumn?: IBalanceSheetPercentageAmount;
+
+  previousPeriod?: IBalanceSheetTotal;
+  previousPeriodChange?: IBalanceSheetTotal;
+  previousPeriodPercentage?: IBalanceSheetPercentageAmount;
+
+  previousYear?: IBalanceSheetTotal;
+  previousYearChange?: IBalanceSheetTotal;
+  previousYearPercentage?: IBalanceSheetPercentageAmount;
+}
+
+export interface IBalanceSheetAggregateNode extends IBalanceSheetCommonNode {
+  id: string;
+  name: string;
+  nodeType: BALANCE_SHEET_SCHEMA_NODE_TYPE.AGGREGATE;
+  children?: (IBalanceSheetAggregateNode | IBalanceSheetAccountNode)[];
+}
+
+export interface IBalanceSheetTotal {
+  amount: number;
+  formattedAmount: string;
+  currencyCode: string;
+  date?: string | Date;
+}
+
+export interface IBalanceSheetAccountNode extends IBalanceSheetCommonNode {
+  id: number;
+  index: number;
+  name: string;
+  code: string;
+  parentAccountId?: number;
+  nodeType: BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNT;
+  children?: IBalanceSheetAccountNode[];
+}
+
+export type IBalanceSheetDataNode = IBalanceSheetAggregateNode;
+
+export interface IBalanceSheetPercentageAmount {
+  amount: number;
+  formattedAmount: string;
+}
+
+export interface IBalanceSheetSchemaAggregateNode {
+  name: string;
+  id: string;
+  type: BALANCE_SHEET_SCHEMA_NODE_TYPE;
+  children: IBalanceSheetSchemaNode[];
+  alwaysShow: boolean;
+}
+
+export interface IBalanceSheetSchemaAccountNode {
+  name: string;
+  id: string;
+  type: BALANCE_SHEET_SCHEMA_NODE_TYPE;
+  accountsTypes: string[];
+}
+
+export type IBalanceSheetSchemaNode =
+  | IBalanceSheetSchemaAccountNode
+  | IBalanceSheetSchemaAggregateNode;
+
+export interface IBalanceSheetDatePeriods {
+  assocAccountNodeDatePeriods(node): any;
+  initDateRangeCollection(): void;
+}
+
+export interface IBalanceSheetComparsions {
+  assocPreviousYearAccountNode(node);
+  hasPreviousPeriod(): boolean;
+  hasPreviousYear(): boolean;
+  assocPreviousPeriodAccountNode(node);
+}
+
+export interface IBalanceSheetTotalPeriod extends IFinancialSheetTotalPeriod {
+  percentageRow?: IBalanceSheetPercentageAmount;
+  percentageColumn?: IBalanceSheetPercentageAmount;
+}
+
+export interface IFinancialSheetTotalPeriod {
+  fromDate: any;
+  toDate: any;
+  total: any;
+}
+
+export enum IFinancialDatePeriodsUnit {
+  Day = 'day',
+  Month = 'month',
+  Year = 'year',
+}
+
+export enum IAccountTransactionsGroupBy {
+  Quarter = 'quarter',
+  Year = 'year',
+  Day = 'day',
+  Month = 'month',
+  Week = 'week',
+}
diff --git a/packages/server/src/interfaces/Bill.ts b/packages/server/src/interfaces/Bill.ts
new file mode 100644
index 000000000..fcf89dbda
--- /dev/null
+++ b/packages/server/src/interfaces/Bill.ts
@@ -0,0 +1,140 @@
+import { Knex } from 'knex';
+import { IDynamicListFilterDTO } from './DynamicFilter';
+import { IItemEntry, IItemEntryDTO } from './ItemEntry';
+import { IBillLandedCost } from './LandedCost'; 
+export interface IBillDTO {
+  vendorId: number;
+  billNumber: string;
+  billDate: Date;
+  dueDate: Date;
+  referenceNo: string;
+  status: string;
+  note: string;
+  amount: number;
+  paymentAmount: number;
+  exchangeRate?: number;
+  open: boolean;
+  entries: IItemEntryDTO[];
+
+  branchId?: number;
+  warehouseId?: number;
+  projectId?: number;
+}
+
+export interface IBillEditDTO {
+  vendorId: number;
+  billNumber: string;
+  billDate: Date;
+  dueDate: Date;
+  referenceNo: string;
+  status: string;
+  note: string;
+  amount: number;
+  paymentAmount: number;
+  open: boolean;
+  entries: IItemEntryDTO[];
+
+  branchId?: number;
+  warehouseId?: number;
+  projectId?: number;
+}
+
+export interface IBill {
+  id?: number;
+
+  vendorId: number;
+  billNumber: string;
+  billDate: Date;
+  dueDate: Date;
+  referenceNo: string;
+  status: string;
+  note: string;
+
+  amount: number;
+  allocatedCostAmount: number;
+  landedCostAmount: number;
+  unallocatedCostAmount: number;
+
+  paymentAmount: number;
+  currencyCode: string;
+  exchangeRate: number;
+
+  dueAmount: number;
+  overdueDays: number;
+
+  billableAmount: number;
+  invoicedAmount: number;
+
+  openedAt: Date | string;
+
+  entries: IItemEntry[];
+
+  createdAt: Date;
+  updateAt: Date;
+
+  isOpen: boolean;
+
+  userId?: number;
+  branchId?: number;
+  projectId?: number;
+
+  localAmount?: number;
+  locatedLandedCosts?: IBillLandedCost[];
+}
+
+export interface IBillsFilter extends IDynamicListFilterDTO {
+  stringifiedFilterRoles?: string;
+  page: number;
+  pageSize: number;
+}
+
+export interface IBillsService {
+  validateVendorHasNoBills(tenantId: number, vendorId: number): Promise<void>;
+}
+
+export interface IBillCreatedPayload {
+  tenantId: number;
+  bill: IBill;
+  billId: number;
+  trx: Knex.Transaction;
+}
+
+export interface IBillCreatingPayload{
+  tenantId: number;
+  billDTO: IBillDTO;
+  trx: Knex.Transaction; 
+}
+
+export interface IBillEditingPayload {
+  tenantId: number;
+  oldBill: IBill;
+  billDTO: IBillEditDTO;
+  trx: Knex.Transaction; 
+}
+export interface IBillEditedPayload {
+  tenantId: number;
+  billId: number;
+  oldBill: IBill;
+  bill: IBill;
+  trx: Knex.Transaction;
+}
+
+export interface IBIllEventDeletedPayload {
+  tenantId: number;
+  billId: number;
+  oldBill: IBill;
+  trx: Knex.Transaction;
+}
+
+export interface IBillEventDeletingPayload {
+  tenantId: number;
+  oldBill: IBill;
+  trx: Knex.Transaction; 
+}
+export enum BillAction {
+  Create = 'Create',
+  Edit = 'Edit',
+  Delete = 'Delete',
+  View = 'View',
+  NotifyBySms = 'NotifyBySms',
+}
diff --git a/packages/server/src/interfaces/BillPayment.ts b/packages/server/src/interfaces/BillPayment.ts
new file mode 100644
index 000000000..f941616fa
--- /dev/null
+++ b/packages/server/src/interfaces/BillPayment.ts
@@ -0,0 +1,117 @@
+import { Knex } from 'knex';
+import { IBill } from './Bill';
+
+export interface IBillPaymentEntry {
+  id?: number;
+  billPaymentId: number;
+  billId: number;
+  paymentAmount: number;
+
+  bill?: IBill;
+}
+
+export interface IBillPayment {
+  id?: number;
+  vendorId: number;
+  amount: number;
+  currencyCode: string;
+  reference: string;
+  paymentAccountId: number;
+  paymentNumber: string;
+  paymentDate: Date;
+  exchangeRate: number | null;
+  userId: number;
+  entries: IBillPaymentEntry[];
+  statement: string;
+  createdAt: Date;
+  updatedAt: Date;
+
+  localAmount?: number;
+  branchId?: number;
+}
+
+export interface IBillPaymentEntryDTO {
+  billId: number;
+  paymentAmount: number;
+}
+
+export interface IBillPaymentDTO {
+  vendorId: number;
+  paymentAccountId: number;
+  paymentNumber?: string;
+  paymentDate: Date;
+  exchangeRate?: number;
+  statement: string;
+  reference: string;
+  entries: IBillPaymentEntryDTO[];
+  branchId?: number;
+}
+
+export interface IBillReceivePageEntry {
+  billId: number;
+  entryType: string;
+  billNo: string;
+  dueAmount: number;
+  amount: number;
+  totalPaymentAmount: number;
+  paymentAmount: number;
+  currencyCode: string;
+  date: Date | string;
+}
+
+export interface IBillPaymentsService {
+  validateVendorHasNoPayments(tenantId: number, vendorId): Promise<void>;
+}
+
+export interface IBillPaymentEventCreatedPayload {
+  tenantId: number;
+  billPayment: IBillPayment;
+  billPaymentId: number;
+  trx: Knex.Transaction;
+}
+
+export interface IBillPaymentCreatingPayload {
+  tenantId: number;
+  billPaymentDTO: IBillPaymentDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IBillPaymentEditingPayload {
+  tenantId: number;
+  billPaymentDTO: IBillPaymentDTO;
+  oldBillPayment: IBillPayment;
+  trx: Knex.Transaction;
+}
+export interface IBillPaymentEventEditedPayload {
+  tenantId: number;
+  billPaymentId: number;
+  billPayment: IBillPayment;
+  oldBillPayment: IBillPayment;
+  trx: Knex.Transaction;
+}
+
+export interface IBillPaymentEventDeletedPayload {
+  tenantId: number;
+  billPaymentId: number;
+  oldBillPayment: IBillPayment;
+  trx: Knex.Transaction;
+}
+
+export interface IBillPaymentDeletingPayload {
+  tenantId: number;
+  oldBillPayment: IBillPayment;
+  trx: Knex.Transaction;
+}
+
+export interface IBillPaymentPublishingPayload {
+  tenantId: number;
+  oldBillPayment: IBillPayment;
+  trx: Knex.Transaction;
+}
+
+export enum IPaymentMadeAction {
+  Create = 'Create',
+  Edit = 'Edit',
+  Delete = 'Delete',
+  View = 'View',
+}
diff --git a/packages/server/src/interfaces/Branches.ts b/packages/server/src/interfaces/Branches.ts
new file mode 100644
index 000000000..671de6563
--- /dev/null
+++ b/packages/server/src/interfaces/Branches.ts
@@ -0,0 +1,50 @@
+import { Knex } from 'knex';
+
+export interface IBranch {
+  id?: number;
+}
+
+export interface ICreateBranchDTO {
+  name: string;
+  code: string;
+
+  primary?: boolean;
+}
+export interface IEditBranchDTO {
+  code: string;
+}
+
+export interface IBranchCreatePayload {
+  tenantId: number;
+  createBranchDTO: ICreateBranchDTO;
+  trx: Knex.Transaction;
+}
+export interface IBranchCreatedPayload {}
+
+export interface IBranchEditPayload {}
+export interface IBranchEditedPayload {}
+
+export interface IBranchDeletePayload {}
+export interface IBranchDeletedPayload {}
+
+export interface IBranchesActivatePayload {
+  tenantId: number;
+  trx: Knex.Transaction;
+}
+export interface IBranchesActivatedPayload {
+  tenantId: number;
+  primaryBranch: IBranch;
+  trx: Knex.Transaction;
+}
+
+export interface IBranchMarkAsPrimaryPayload {
+  tenantId: number;
+  oldBranch: IBranch;
+  trx: Knex.Transaction;
+}
+export interface IBranchMarkedAsPrimaryPayload {
+  tenantId: number;
+  oldBranch: IBranch;
+  markedBranch: IBranch;
+  trx: Knex.Transaction;
+}
diff --git a/packages/server/src/interfaces/CashFlow.ts b/packages/server/src/interfaces/CashFlow.ts
new file mode 100644
index 000000000..289159727
--- /dev/null
+++ b/packages/server/src/interfaces/CashFlow.ts
@@ -0,0 +1,227 @@
+import { INumberFormatQuery } from './FinancialStatements';
+import { IAccount } from './Account';
+import { ILedger } from './Ledger';
+import { ITableRow } from './Table';
+
+export interface ICashFlowStatementQuery {
+  fromDate: Date | string;
+  toDate: Date | string;
+  displayColumnsBy: string;
+  displayColumnsType: string;
+  noneZero: boolean;
+  noneTransactions: boolean;
+  numberFormat: INumberFormatQuery;
+  basis: string;
+
+  branchesIds?: number[];
+}
+
+export interface ICashFlowStatementTotal {
+  amount: number;
+  formattedAmount: string;
+  currencyCode: string;
+}
+
+export interface ICashFlowStatementTotalPeriod {
+  fromDate: Date;
+  toDate: Date;
+  total: ICashFlowStatementTotal;
+}
+
+export interface ICashFlowStatementCommonSection {
+  id: string;
+  label: string;
+  total: ICashFlowStatementTotal;
+  footerLabel?: string;
+}
+
+export interface ICashFlowStatementAccountMeta {
+  id: number;
+  label: string;
+  code: string;
+  total: ICashFlowStatementTotal;
+  accountType: string;
+  adjusmentType: string;
+  sectionType: ICashFlowStatementSectionType.ACCOUNT;
+}
+
+export enum ICashFlowStatementSectionType {
+  REGULAR = 'REGULAR',
+  AGGREGATE = 'AGGREGATE',
+  NET_INCOME = 'NET_INCOME',
+  ACCOUNT = 'ACCOUNT',
+  ACCOUNTS = 'ACCOUNTS',
+  TOTAL = 'TOTAL',
+  CASH_AT_BEGINNING = 'CASH_AT_BEGINNING',
+}
+
+export interface ICashFlowStatementAccountSection
+  extends ICashFlowStatementCommonSection {
+  sectionType: ICashFlowStatementSectionType.ACCOUNTS;
+  children: ICashFlowStatementAccountMeta[];
+  total: ICashFlowStatementTotal;
+}
+
+export interface ICashFlowStatementNetIncomeSection
+  extends ICashFlowStatementCommonSection {
+  sectionType: ICashFlowStatementSectionType.NET_INCOME;
+}
+
+export interface ICashFlowStatementTotalSection
+  extends ICashFlowStatementCommonSection {
+  sectionType: ICashFlowStatementSectionType.TOTAL;
+}
+
+export interface ICashFlowStatementAggregateSection
+  extends ICashFlowStatementCommonSection {
+  sectionType: ICashFlowStatementSectionType.AGGREGATE;
+}
+
+export interface ICashFlowCashBeginningNode
+  extends ICashFlowStatementCommonSection {
+    sectionType: ICashFlowStatementSectionType.CASH_AT_BEGINNING;
+  }
+
+export type ICashFlowStatementSection =
+  | ICashFlowStatementAccountSection
+  | ICashFlowStatementNetIncomeSection
+  | ICashFlowStatementTotalSection
+  | ICashFlowStatementCommonSection;
+
+export interface ICashFlowStatementColumn {}
+export interface ICashFlowStatementMeta {
+  isCostComputeRunning: boolean;
+  organizationName: string;
+  baseCurrency: string;
+}
+
+export interface ICashFlowStatementDOO {
+  data: ICashFlowStatementData;
+  meta: ICashFlowStatementMeta;
+  query: ICashFlowStatementQuery;
+}
+
+export interface ICashFlowStatementService {
+  cashFlow(
+    tenantId: number,
+    query: ICashFlowStatementQuery
+  ): Promise<ICashFlowStatementDOO>;
+}
+
+// CASH FLOW SCHEMA TYPES.
+// -----------------------------
+export interface ICashFlowSchemaCommonSection {
+  id: string;
+  label: string;
+  children: ICashFlowSchemaSection[];
+  footerLabel?: string;
+}
+
+export enum CASH_FLOW_ACCOUNT_RELATION {
+  MINES = 'mines',
+  PLUS = 'plus',
+}
+
+export enum CASH_FLOW_SECTION_ID {
+  NET_INCOME = 'NET_INCOME',
+  OPERATING = 'OPERATING',
+  OPERATING_ACCOUNTS = 'OPERATING_ACCOUNTS',
+  INVESTMENT = 'INVESTMENT',
+  FINANCIAL = 'FINANCIAL',
+
+  NET_OPERATING = 'NET_OPERATING',
+  NET_INVESTMENT = 'NET_INVESTMENT',
+  NET_FINANCIAL = 'NET_FINANCIAL',
+
+  CASH_BEGINNING_PERIOD = 'CASH_BEGINNING_PERIOD',
+  CASH_END_PERIOD = 'CASH_END_PERIOD',
+  NET_CASH_INCREASE = 'NET_CASH_INCREASE',
+}
+
+export interface ICashFlowSchemaAccountsSection
+  extends ICashFlowSchemaCommonSection {
+  sectionType: ICashFlowStatementSectionType.ACCOUNT;
+  accountsRelations: ICashFlowSchemaAccountRelation[];
+}
+
+export interface ICashFlowSchemaTotalSection
+  extends ICashFlowStatementCommonSection {
+  sectionType: ICashFlowStatementSectionType.TOTAL;
+  equation: string;
+}
+
+export type ICashFlowSchemaSection =
+  | ICashFlowSchemaAccountsSection
+  | ICashFlowSchemaTotalSection
+  | ICashFlowSchemaCommonSection;
+
+export type ICashFlowStatementData = ICashFlowSchemaSection[];
+
+export interface ICashFlowSchemaAccountRelation {
+  type: string;
+  direction: CASH_FLOW_ACCOUNT_RELATION.PLUS;
+}
+
+export interface ICashFlowSchemaSectionAccounts
+  extends ICashFlowStatementCommonSection {
+  type: ICashFlowStatementSectionType.ACCOUNT;
+  accountsRelations: ICashFlowSchemaAccountRelation[];
+}
+
+export interface ICashFlowSchemaSectionTotal {
+  type: ICashFlowStatementSectionType.TOTAL;
+  totalEquation: string;
+}
+
+export interface ICashFlowDatePeriod {
+  fromDate: ICashFlowDate;
+  toDate: ICashFlowDate;
+  total: ICashFlowStatementTotal;
+}
+
+export interface ICashFlowDate {
+  formattedDate: string;
+  date: Date;
+}
+
+export interface ICashFlowStatement {
+  /**
+   * Constructor method.
+   * @constructor
+   */
+  constructor(
+    accounts: IAccount[],
+    ledger: ILedger,
+    cashLedger: ILedger,
+    netIncomeLedger: ILedger,
+    query: ICashFlowStatementQuery,
+    baseCurrency: string
+  ): void;
+
+  reportData(): ICashFlowStatementData;
+}
+
+export interface ICashFlowTable {
+  constructor(reportStatement: ICashFlowStatement): void;
+  tableRows(): ITableRow[];
+}
+
+export interface IDateRange {
+  fromDate: Date;
+  toDate: Date;
+}
+
+export interface ICashflowTransactionSchema {
+  amount: number;
+  date: Date;
+  referenceNo?: string | null;
+  transactionNumber: string;
+  transactionType: string;
+  creditAccountId: number;
+  cashflowAccountId: number;
+  userId: number;
+  publishedAt?: Date | null;
+  branchId?: number;
+}
+
+export interface ICashflowTransactionInput extends ICashflowTransactionSchema {}
diff --git a/packages/server/src/interfaces/CashflowService.ts b/packages/server/src/interfaces/CashflowService.ts
new file mode 100644
index 000000000..8b0576d8e
--- /dev/null
+++ b/packages/server/src/interfaces/CashflowService.ts
@@ -0,0 +1,128 @@
+import { Knex } from 'knex';
+import { IAccount } from './Account';
+
+export interface ICashflowAccountTransactionsFilter {
+  page: number;
+  pageSize: number;
+}
+
+export interface ICashflowAccountsFilter {
+  inactiveMode: boolean;
+  stringifiedFilterRoles?: string;
+  sortOrder: string;
+  columnSortBy: string;
+}
+
+export interface ICashflowAccount {
+  id: number;
+  name: string;
+  balance: number;
+  formattedBalance: string;
+  accountType: string;
+}
+
+interface ICashflowCommandLineDTO {
+  creditAccountId: number;
+  cashflowAccountId: number;
+  amount: number;
+  index: number;
+}
+
+export interface ICashflowCommandDTO {
+  date: Date;
+
+  transactionNumber: string;
+  referenceNo: string;
+  transactionType: string;
+  description: string;
+
+  amount: number;
+  exchangeRate: number;
+  currencyCode: string;
+
+  creditAccountId: number;
+  cashflowAccountId: number;
+
+  publish: boolean;
+  branchId?: number;
+}
+
+export interface ICashflowNewCommandDTO extends ICashflowCommandDTO {}
+
+export interface ICashflowTransaction {
+  id?: number;
+  date: Date;
+
+  referenceNo: string;
+  description: string;
+
+  transactionType: string;
+  transactionNumber: string;
+
+  amount: number;
+  localAmount?: number;
+  currencyCode: string;
+  exchangeRate: number;
+
+  publishedAt?: Date | null;
+  userId: number;
+  entries: ICashflowTransactionLine[];
+
+  creditAccountId: number;
+  cashflowAccountId: number;
+
+  creditAccount?: IAccount;
+  cashflowAccount?: IAccount;
+
+  branchId?: number;
+  isPublished: boolean;
+
+  isCashDebit?: boolean;
+  isCashCredit?: boolean;
+}
+
+export interface ICashflowTransactionLine {
+  creditAccountId: number;
+  cashflowAccountId: number;
+  amount: number;
+  index: number;
+
+  creditAccount?: IAccount;
+}
+
+export enum CashflowDirection {
+  IN = 'in',
+  OUT = 'out',
+}
+
+export interface ICommandCashflowCreatingPayload {
+  tenantId: number;
+  trx: Knex.Transaction;
+  newTransactionDTO: ICashflowNewCommandDTO;
+}
+
+export interface ICommandCashflowCreatedPayload {
+  tenantId: number;
+  newTransactionDTO: ICashflowNewCommandDTO;
+  cashflowTransaction: ICashflowTransaction;
+  trx: Knex.Transaction;
+}
+
+export interface ICommandCashflowDeletingPayload {
+  tenantId: number;
+  oldCashflowTransaction: ICashflowTransaction;
+  trx: Knex.Transaction;
+}
+
+export interface ICommandCashflowDeletedPayload {
+  tenantId: number;
+  cashflowTransactionId: number;
+  oldCashflowTransaction: ICashflowTransaction;
+  trx: Knex.Transaction;
+}
+
+export enum CashflowAction {
+  Create = 'Create',
+  Delete = 'Delete',
+  View = 'View',
+}
diff --git a/packages/server/src/interfaces/Contact.ts b/packages/server/src/interfaces/Contact.ts
new file mode 100644
index 000000000..17eeb7652
--- /dev/null
+++ b/packages/server/src/interfaces/Contact.ts
@@ -0,0 +1,391 @@
+import { ISystemUser } from '@/interfaces';
+import { Knex } from 'knex';
+import { IFilterRole } from './DynamicFilter';
+
+export enum ContactService {
+  Customer = 'customer',
+  Vendor = 'vendor',
+}
+
+// ----------------------------------
+export interface IContactAddress {
+  billingAddress1: string;
+  billingAddress2: string;
+  billingAddressCity: string;
+  billingAddressCountry: string;
+  billingAddressEmail: string;
+  billingAddressZipcode: string;
+  billingAddressPhone: string;
+  billingAddressState: string;
+
+  shippingAddress1: string;
+  shippingAddress2: string;
+  shippingAddressCity: string;
+  shippingAddressCountry: string;
+  shippingAddressEmail: string;
+  shippingAddressZipcode: string;
+  shippingAddressPhone: string;
+  shippingAddressState: string;
+}
+export interface IContactAddressDTO {
+  billingAddress1?: string;
+  billingAddress2?: string;
+  billingAddressCity?: string;
+  billingAddressCountry?: string;
+  billingAddressEmail?: string;
+  billingAddressZipcode?: string;
+  billingAddressPhone?: string;
+  billingAddressState?: string;
+
+  shippingAddress1?: string;
+  shippingAddress2?: string;
+  shippingAddressCity?: string;
+  shippingAddressCountry?: string;
+  shippingAddressEmail?: string;
+  shippingAddressZipcode?: string;
+  shippingAddressPhone?: string;
+  shippingAddressState?: string;
+}
+export interface IContact extends IContactAddress {
+  id?: number;
+  contactService: 'customer' | 'vendor';
+  contactType: string;
+
+  balance: number;
+  currencyCode: string;
+
+  openingBalance: number;
+  openingBalanceExchangeRate: number;
+  localOpeningBalance?: number;
+  openingBalanceAt: Date;
+  openingBalanceBranchId: number;
+
+  salutation: string;
+  firstName: string;
+  lastName: string;
+  companyName: string;
+  displayName: string;
+
+  email: string;
+  website: string;
+  workPhone: string;
+  personalPhone: string;
+
+  note: string;
+  active: boolean;
+}
+export interface IContactNewDTO {
+  contactType?: string;
+
+  currencyCode?: string;
+
+  openingBalance?: number;
+  openingBalanceAt?: string;
+
+  salutation?: string;
+  firstName?: string;
+  lastName?: string;
+  companyName?: string;
+  displayName: string;
+
+  website?: string;
+  email?: string;
+  workPhone?: string;
+  personalPhone?: string;
+
+  note?: string;
+  active: boolean;
+}
+export interface IContactEditDTO {
+  contactType?: string;
+
+  salutation?: string;
+  firstName?: string;
+  lastName?: string;
+  companyName?: string;
+  displayName: string;
+
+  website?: string;
+  email?: string;
+  workPhone?: string;
+  personalPhone?: string;
+
+  note?: string;
+  active: boolean;
+}
+
+// Customer Interfaces.
+// ----------------------------------
+export interface ICustomer extends IContact {
+  contactService: 'customer';
+}
+export interface ICustomerNewDTO extends IContactAddressDTO {
+  customerType: string;
+
+  currencyCode: string;
+
+  openingBalance?: number;
+  openingBalanceAt?: string;
+  openingBalanceExchangeRate?: number;
+  openingBalanceBranchId?: number;
+
+  salutation?: string;
+  firstName?: string;
+  lastName?: string;
+  companyName?: string;
+  displayName: string;
+
+  website?: string;
+  email?: string;
+  workPhone?: string;
+  personalPhone?: string;
+
+  note?: string;
+  active?: boolean;
+}
+export interface ICustomerEditDTO extends IContactAddressDTO {
+  customerType: string;
+
+  salutation?: string;
+  firstName?: string;
+  lastName?: string;
+  companyName?: string;
+  displayName: string;
+
+  website?: string;
+  email?: string;
+  workPhone?: string;
+  personalPhone?: string;
+
+  note?: string;
+  active?: boolean;
+}
+
+// Vendor Interfaces.
+// ----------------------------------
+export interface IVendor extends IContact {
+  contactService: 'vendor';
+}
+export interface IVendorNewDTO extends IContactAddressDTO {
+  currencyCode: string;
+
+  openingBalance?: number;
+  openingBalanceAt?: string;
+  openingBalanceExchangeRate?: number;
+  openingBalanceBranchId?: number;
+
+  salutation?: string;
+  firstName?: string;
+  lastName?: string;
+  companyName?: string;
+  displayName: string;
+
+  website?: string;
+  email?: string;
+  workPhone?: string;
+  personalPhone?: string;
+
+  note?: string;
+  active?: boolean;
+}
+export interface IVendorEditDTO extends IContactAddressDTO {
+  salutation?: string;
+  firstName?: string;
+  lastName?: string;
+  companyName?: string;
+  displayName?: string;
+
+  website?: string;
+  email?: string;
+  workPhone?: string;
+  personalPhone?: string;
+
+  note?: string;
+  active?: boolean;
+}
+
+export interface IVendorsFilter extends IDynamicListFilter {
+  stringifiedFilterRoles?: string;
+  page?: number;
+  pageSize?: number;
+}
+
+export interface ICustomersFilter extends IDynamicListFilter {
+  stringifiedFilterRoles?: string;
+  page?: number;
+  pageSize?: number;
+}
+
+export interface IContactsAutoCompleteFilter {
+  limit: number;
+  keyword: string;
+  filterRoles?: IFilterRole[];
+  columnSortBy: string;
+  sortOrder: string;
+}
+
+export interface IContactAutoCompleteItem {
+  displayName: string;
+  contactService: string;
+}
+export interface ICustomerEventCreatedPayload {
+  tenantId: number;
+  customerId: number;
+  authorizedUser: ISystemUser;
+  customer: ICustomer;
+  trx: Knex.Transaction;
+}
+export interface ICustomerEventCreatingPayload {
+  tenantId: number;
+  customerDTO: ICustomerNewDTO;
+  trx: Knex.Transaction;
+}
+export interface ICustomerEventEditedPayload {
+  customerId: number;
+  customer: ICustomer;
+  trx: Knex.Transaction;
+}
+
+export interface ICustomerEventEditingPayload {
+  tenantId: number;
+  customerDTO: ICustomerEditDTO;
+  customerId: number;
+  trx: Knex.Transaction;
+}
+
+export interface ICustomerDeletingPayload {
+  tenantId: number;
+  customerId: number;
+  oldCustomer: ICustomer;
+}
+
+export interface ICustomerEventDeletedPayload {
+  tenantId: number;
+  customerId: number;
+  oldCustomer: ICustomer;
+  authorizedUser: ISystemUser;
+  trx: Knex.Transaction;
+}
+export interface IVendorEventCreatingPayload {
+  tenantId: number;
+  vendorDTO: IVendorNewDTO;
+  trx: Knex.Transaction;
+}
+export interface IVendorEventCreatedPayload {
+  tenantId: number;
+  vendorId: number;
+  vendor: IVendor;
+  authorizedUser: ISystemUser;
+  trx: Knex.Transaction;
+}
+
+export interface IVendorEventDeletingPayload {
+  tenantId: number;
+  vendorId: number;
+  oldVendor: IVendor;
+}
+
+export interface IVendorEventDeletedPayload {
+  tenantId: number;
+  vendorId: number;
+  authorizedUser: ISystemUser;
+  oldVendor: IVendor;
+  trx: Knex.Transaction;
+}
+export interface IVendorEventEditingPayload {
+  trx: Knex.Transaction;
+  tenantId: number;
+  vendorDTO: IVendorEditDTO;
+}
+export interface IVendorEventEditedPayload {
+  tenantId: number;
+  vendorId: number;
+  vendor: IVendor;
+  authorizedUser: ISystemUser;
+  trx: Knex.Transaction;
+}
+
+export enum CustomerAction {
+  Create = 'Create',
+  Edit = 'Edit',
+  Delete = 'Delete',
+  View = 'View',
+}
+
+export enum VendorAction {
+  Create = 'Create',
+  Edit = 'Edit',
+  Delete = 'Delete',
+  View = 'View',
+}
+
+export interface ICustomerOpeningBalanceEditDTO {
+  openingBalance: number;
+  openingBalanceAt: Date | string;
+  openingBalanceExchangeRate: number;
+  openingBalanceBranchId?: number;
+}
+
+export interface ICustomerOpeningBalanceEditingPayload {
+  tenantId: number;
+  oldCustomer: ICustomer;
+  openingBalanceEditDTO: ICustomerOpeningBalanceEditDTO;
+  trx: Knex.Transaction;
+}
+
+export interface ICustomerOpeningBalanceEditedPayload {
+  tenantId: number;
+  customer: ICustomer;
+  oldCustomer: ICustomer;
+  openingBalanceEditDTO: ICustomerOpeningBalanceEditDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IVendorOpeningBalanceEditDTO {
+  openingBalance: number;
+  openingBalanceAt: Date | string;
+  openingBalanceExchangeRate: number;
+  openingBalanceBranchId?: number;
+}
+
+export interface IVendorOpeningBalanceEditingPayload {
+  tenantId: number;
+  oldVendor: IVendor;
+  openingBalanceEditDTO: IVendorOpeningBalanceEditDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IVendorOpeningBalanceEditedPayload {
+  tenantId: number;
+  vendor: IVendor;
+  oldVendor: IVendor;
+  openingBalanceEditDTO: IVendorOpeningBalanceEditDTO;
+  trx: Knex.Transaction;
+}
+
+
+export interface ICustomerActivatingPayload {
+  tenantId: number;
+  trx: Knex.Transaction,
+  oldCustomer: IContact;
+}
+
+export interface ICustomerActivatedPayload {
+  tenantId: number;
+  trx: Knex.Transaction,
+  oldCustomer: IContact; 
+  customer: IContact;
+}
+
+export interface IVendorActivatingPayload {
+  tenantId: number;
+  trx: Knex.Transaction,
+  oldVendor: IContact;
+}
+
+export interface IVendorActivatedPayload {
+  tenantId: number;
+  trx: Knex.Transaction,
+  oldVendor: IContact; 
+  vendor: IContact;
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/ContactBalanceSummary.ts b/packages/server/src/interfaces/ContactBalanceSummary.ts
new file mode 100644
index 000000000..ddefabab1
--- /dev/null
+++ b/packages/server/src/interfaces/ContactBalanceSummary.ts
@@ -0,0 +1,47 @@
+import { INumberFormatQuery } from './FinancialStatements';
+
+export interface IContactBalanceSummaryQuery {
+  asDate: Date;
+  numberFormat: INumberFormatQuery;
+  percentageColumn: boolean;
+  noneTransactions: boolean;
+  noneZero: boolean;
+}
+
+export interface IContactBalanceSummaryAmount {
+  amount: number;
+  formattedAmount: string;
+  currencyCode: string;
+}
+export interface IContactBalanceSummaryPercentage {
+  amount: number;
+  formattedAmount: string;
+}
+
+export interface IContactBalanceSummaryContact {
+  total: IContactBalanceSummaryAmount;
+  percentageOfColumn?: IContactBalanceSummaryPercentage;
+}
+
+export interface IContactBalanceSummaryTotal {
+  total: IContactBalanceSummaryAmount;
+  percentageOfColumn?: IContactBalanceSummaryPercentage;
+}
+
+export interface ICustomerBalanceSummaryData {
+  customers: IContactBalanceSummaryContact[];
+  total: IContactBalanceSummaryTotal;
+}
+
+export interface ICustomerBalanceSummaryStatement {
+  data: ICustomerBalanceSummaryData;
+  columns: {};
+  query: IContactBalanceSummaryQuery;
+}
+
+export interface ICustomerBalanceSummaryService {
+  customerBalanceSummary(
+    tenantId: number,
+    query: IContactBalanceSummaryQuery
+  ): Promise<ICustomerBalanceSummaryStatement>;
+}
diff --git a/packages/server/src/interfaces/CreditNote.ts b/packages/server/src/interfaces/CreditNote.ts
new file mode 100644
index 000000000..5eea94d34
--- /dev/null
+++ b/packages/server/src/interfaces/CreditNote.ts
@@ -0,0 +1,255 @@
+import { Knex } from 'knex';
+import { IDynamicListFilter, IItemEntry, IVendorCredit } from '@/interfaces';
+import { ILedgerEntry } from './Ledger';
+
+export interface ICreditNoteEntryNewDTO {
+  index: number;
+  itemId: number;
+  rate: number;
+  quantity: number;
+  discount: number;
+  description: string;
+  warehouseId?: number;
+}
+export interface ICreditNoteNewDTO {
+  customerId: number;
+  exchangeRate?: number;
+  creditNoteDate: Date;
+  creditNoteNumber: string;
+  note: string;
+  open: boolean;
+  entries: ICreditNoteEntryNewDTO[];
+  branchId?: number;
+  warehouseId?: number;
+}
+
+export interface ICreditNoteEditDTO {
+  customerId: number;
+  exchangeRate?: number;
+  creditNoteDate: Date;
+  creditNoteNumber: string;
+  note: string;
+  open: boolean;
+  entries: ICreditNoteEntryNewDTO[];
+  branchId?: number;
+  warehouseId?: number;
+}
+
+export interface ICreditNoteEntry extends IItemEntry {}
+
+export interface ICreditNote {
+  id?: number;
+  customerId: number;
+  amount: number;
+  refundedAmount: number;
+  currencyCode: string;
+  exchangeRate: number;
+  creditNoteDate: Date;
+  creditNoteNumber: string;
+  referenceNo?: string;
+  note?: string;
+  openedAt: Date | null;
+  entries: ICreditNoteEntry[];
+  isOpen: boolean;
+  isClosed: boolean;
+  isDraft: boolean;
+  isPublished: boolean;
+  creditsRemaining: number;
+  localAmount?: number;
+  branchId?: number;
+  warehouseId: number;
+  createdAt?: Date,
+}
+
+export enum CreditNoteAction {
+  Create = 'Create',
+  Edit = 'Edit',
+  Delete = 'Delete',
+  View = 'View',
+  Refund = 'Refund',
+}
+
+export interface ICreditNoteDeletingPayload {
+  tenantId: number;
+  oldCreditNote: ICreditNote;
+  trx: Knex.Transaction;
+}
+
+export interface ICreditNoteDeletedPayload {
+  tenantId: number;
+  oldCreditNote: ICreditNote;
+  creditNoteId: number;
+  trx: Knex.Transaction;
+}
+
+export interface ICreditNoteEditingPayload {
+  trx: Knex.Transaction;
+  oldCreditNote: ICreditNote;
+  creditNoteEditDTO: ICreditNoteEditDTO;
+  tenantId: number;
+}
+
+export interface ICreditNoteEditedPayload {
+  trx: Knex.Transaction;
+  oldCreditNote: ICreditNote;
+  creditNoteId: number;
+  creditNote: ICreditNote;
+  creditNoteEditDTO: ICreditNoteEditDTO;
+  tenantId: number;
+}
+
+export interface ICreditNoteCreatedPayload {
+  tenantId: number;
+  creditNoteDTO: ICreditNoteNewDTO;
+  creditNote: ICreditNote;
+  creditNoteId: number;
+  trx: Knex.Transaction;
+}
+
+export interface ICreditNoteCreatingPayload {
+  tenantId: number;
+  creditNoteDTO: ICreditNoteNewDTO;
+  trx: Knex.Transaction;
+}
+
+export interface ICreditNoteOpeningPayload {
+  tenantId: number;
+  creditNoteId: number;
+  oldCreditNote: ICreditNote;
+  trx: Knex.Transaction;
+}
+
+export interface ICreditNoteOpenedPayload {
+  tenantId: number;
+  creditNote: ICreditNote;
+  creditNoteId: number;
+  oldCreditNote: ICreditNote;
+  trx: Knex.Transaction;
+}
+
+export interface ICreditNotesQueryDTO {}
+
+export interface ICreditNotesQueryDTO extends IDynamicListFilter {
+  page: number;
+  pageSize: number;
+  searchKeyword?: string;
+}
+
+export interface ICreditNoteRefundDTO {
+  fromAccountId: number;
+  amount: number;
+  exchangeRate?: number;
+  referenceNo: string;
+  description: string;
+  date: Date;
+  branchId?: number;
+}
+
+export interface ICreditNoteApplyInvoiceDTO {
+  entries: { invoiceId: number; amount: number }[];
+}
+
+export interface IRefundCreditNote {
+  id?: number | null;
+  date: Date;
+  referenceNo: string;
+  amount: number;
+  currencyCode: string;
+  exchangeRate: number;
+  fromAccountId: number;
+  description: string;
+  creditNoteId: number;
+  createdAt?: Date | null;
+  userId?: number;
+  branchId?: number;
+
+  creditNote?: ICreditNote;
+}
+
+export interface IRefundCreditNotePOJO {
+  formattedAmount: string;
+}
+
+export interface IRefundCreditNoteDeletedPayload {
+  trx: Knex.Transaction;
+  refundCreditId: number;
+  oldRefundCredit: IRefundCreditNote;
+  tenantId: number;
+}
+
+export interface IRefundCreditNoteDeletingPayload {
+  trx: Knex.Transaction;
+  refundCreditId: number;
+  oldRefundCredit: IRefundCreditNote;
+  tenantId: number;
+}
+
+export interface IRefundCreditNoteCreatingPayload {
+  trx: Knex.Transaction;
+  creditNote: ICreditNote;
+  tenantId: number;
+  newCreditNoteDTO: ICreditNoteRefundDTO;
+}
+
+export interface IRefundCreditNoteCreatedPayload {
+  trx: Knex.Transaction;
+  refundCreditNote: IRefundCreditNote;
+  creditNote: ICreditNote;
+  tenantId: number;
+}
+
+export interface IRefundCreditNoteOpenedPayload {
+  tenantId: number;
+  creditNoteId: number;
+  oldCreditNote: ICreditNote;
+  trx: Knex.Transaction;
+}
+
+export interface IApplyCreditToInvoiceEntryDTO {
+  amount: number;
+  invoiceId: number;
+}
+
+export interface IApplyCreditToInvoicesDTO {
+  entries: IApplyCreditToInvoiceEntryDTO[];
+}
+
+export interface IApplyCreditToInvoicesCreatedPayload {
+  trx: Knex.Transaction;
+  creditNote: ICreditNote;
+  tenantId: number;
+  creditNoteAppliedInvoices: ICreditNoteAppliedToInvoice[];
+}
+export interface IApplyCreditToInvoicesDeletedPayload {
+  trx: Knex.Transaction;
+  creditNote: ICreditNote;
+  creditNoteAppliedToInvoice: ICreditNoteAppliedToInvoice;
+  tenantId: number;
+}
+
+export interface ICreditNoteAppliedToInvoice {
+  invoiceId: number;
+  amount: number;
+  creditNoteId: number;
+}
+export interface ICreditNoteAppliedToInvoiceModel {
+  amount: number;
+  entries: ICreditNoteAppliedToInvoice[];
+}
+
+export type ICreditNoteGLCommonEntry = Pick<
+  ILedgerEntry,
+  | 'date'
+  | 'userId'
+  | 'currencyCode'
+  | 'exchangeRate'
+  | 'transactionType'
+  | 'transactionId'
+  | 'transactionNumber'
+  | 'referenceNumber'
+  | 'createdAt'
+  | 'indexGroup'
+  | 'credit'
+  | 'debit'
+  | 'branchId'
+>;
diff --git a/packages/server/src/interfaces/Currency.ts b/packages/server/src/interfaces/Currency.ts
new file mode 100644
index 000000000..2bcfc5620
--- /dev/null
+++ b/packages/server/src/interfaces/Currency.ts
@@ -0,0 +1,27 @@
+
+
+export interface ICurrencyDTO {
+  currencyName: string,
+  currencyCode: string,
+  currencySign: string,
+};
+export interface ICurrencyEditDTO {
+  currencyName: string,
+  currencySign: string,
+}
+export interface ICurrency {
+  id: number,
+  currencyName: string,
+  currencyCode: string,
+  currencySign: string,
+  createdAt: Date,
+  updatedAt: Date,
+};
+
+export interface ICurrenciesService {
+  newCurrency(tenantId: number, currencyDTO: ICurrencyDTO): Promise<void>;
+  editCurrency(tenantId: number, currencyId: number, editCurrencyDTO: ICurrencyEditDTO): Promise<void>;
+
+  deleteCurrency(tenantId: number, currencyCode: string): Promise<void>;
+  listCurrencies(tenantId: number): Promise<ICurrency[]>;
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/CustomerBalanceSummary.ts b/packages/server/src/interfaces/CustomerBalanceSummary.ts
new file mode 100644
index 000000000..cda13f7c9
--- /dev/null
+++ b/packages/server/src/interfaces/CustomerBalanceSummary.ts
@@ -0,0 +1,49 @@
+import { INumberFormatQuery } from './FinancialStatements';
+
+import {
+  IContactBalanceSummaryQuery,
+  IContactBalanceSummaryAmount,
+  IContactBalanceSummaryPercentage,
+  IContactBalanceSummaryTotal,
+} from './ContactBalanceSummary';
+
+export interface ICustomerBalanceSummaryQuery
+  extends IContactBalanceSummaryQuery {
+  customersIds?: number[];
+}
+
+export interface ICustomerBalanceSummaryAmount
+  extends IContactBalanceSummaryAmount {}
+
+export interface ICustomerBalanceSummaryPercentage
+  extends IContactBalanceSummaryPercentage {}
+
+export interface ICustomerBalanceSummaryCustomer {
+  id: number,
+  customerName: string;
+  total: ICustomerBalanceSummaryAmount;
+  percentageOfColumn?: ICustomerBalanceSummaryPercentage;
+}
+
+export interface ICustomerBalanceSummaryTotal
+  extends IContactBalanceSummaryTotal {
+  total: ICustomerBalanceSummaryAmount;
+  percentageOfColumn?: ICustomerBalanceSummaryPercentage;
+}
+
+export interface ICustomerBalanceSummaryData {
+  customers: ICustomerBalanceSummaryCustomer[];
+  total: ICustomerBalanceSummaryTotal;
+}
+
+export interface ICustomerBalanceSummaryStatement {
+  data: ICustomerBalanceSummaryData;
+  query: ICustomerBalanceSummaryQuery;
+}
+
+export interface ICustomerBalanceSummaryService {
+  customerBalanceSummary(
+    tenantId: number,
+    query: ICustomerBalanceSummaryQuery
+  ): Promise<ICustomerBalanceSummaryStatement>;
+}
diff --git a/packages/server/src/interfaces/DynamicFilter.ts b/packages/server/src/interfaces/DynamicFilter.ts
new file mode 100644
index 000000000..674328fb9
--- /dev/null
+++ b/packages/server/src/interfaces/DynamicFilter.ts
@@ -0,0 +1,38 @@
+import { IModel, ISortOrder } from "./Model";
+
+export interface IDynamicFilter {
+  setModel(model: IModel): void;
+  buildQuery(): void;
+  getResponseMeta();
+}
+
+export interface IFilterRole {
+  fieldKey: string;
+  value: string;
+  condition?: string;
+  index?: number;
+  comparator?: string;
+}
+export interface IDynamicListFilter {
+  customViewId?: number;
+  filterRoles?: IFilterRole[];
+  columnSortBy: ISortOrder;
+  sortOrder: string;
+  stringifiedFilterRoles: string;
+  searchKeyword?: string;
+}
+
+export interface IDynamicListService {
+  dynamicList(
+    tenantId: number,
+    model: any,
+    filter: IDynamicListFilter
+  ): Promise<any>;
+  handlerErrorsToResponse(error, req, res, next): void;
+}
+
+// Search role.
+export interface ISearchRole {
+  fieldKey: string;
+  comparator: string;
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/Entry.ts b/packages/server/src/interfaces/Entry.ts
new file mode 100644
index 000000000..8d43449e7
--- /dev/null
+++ b/packages/server/src/interfaces/Entry.ts
@@ -0,0 +1,18 @@
+export interface ICommonEntry {
+  id?: number;
+  amount: number;
+}
+
+export interface ICommonLandedCostEntry extends ICommonEntry {
+  landedCost: boolean;
+  allocatedCostAmount: number;
+}
+
+export interface ICommonEntryDTO {
+  id?: number;
+  amount: number;
+}
+
+export interface ICommonLandedCostEntryDTO extends ICommonEntryDTO {
+  landedCost?: boolean;
+}
diff --git a/packages/server/src/interfaces/ExchangeRate.ts b/packages/server/src/interfaces/ExchangeRate.ts
new file mode 100644
index 000000000..fc3bd33e4
--- /dev/null
+++ b/packages/server/src/interfaces/ExchangeRate.ts
@@ -0,0 +1,36 @@
+import { IFilterRole } from './DynamicFilter';
+
+export interface IExchangeRate {
+  id: number,
+  currencyCode: string,
+  exchangeRate: number,
+  date: Date,
+  createdAt: Date,
+  updatedAt: Date,
+};
+
+export interface IExchangeRateDTO {
+  currencyCode: string,
+  exchangeRate: number,
+  date: Date,
+};
+
+export interface IExchangeRateEditDTO {
+  exchangeRate: number,
+};
+
+export interface IExchangeRateFilter {
+  page: number,
+  pageSize: number,
+  filterRoles?: IFilterRole[];
+  columnSortBy: string;
+  sortOrder: string;
+};
+
+export interface IExchangeRatesService {
+  newExchangeRate(tenantId: number, exchangeRateDTO: IExchangeRateDTO): Promise<IExchangeRate>;
+  editExchangeRate(tenantId: number, exchangeRateId: number, editExRateDTO: IExchangeRateEditDTO): Promise<void>;
+
+  deleteExchangeRate(tenantId: number, exchangeRateId: number): Promise<void>;
+  listExchangeRates(tenantId: number, exchangeRateFilter: IExchangeRateFilter): Promise<void>;
+};
\ No newline at end of file
diff --git a/packages/server/src/interfaces/Expenses.ts b/packages/server/src/interfaces/Expenses.ts
new file mode 100644
index 000000000..6a47bef01
--- /dev/null
+++ b/packages/server/src/interfaces/Expenses.ts
@@ -0,0 +1,200 @@
+import { Knex } from 'knex';
+import { ISystemUser } from './User';
+import { IFilterRole } from './DynamicFilter';
+import { IAccount } from './Account';
+
+export interface IPaginationMeta {
+  total: number;
+  page: number;
+  pageSize: number;
+}
+
+export interface IExpensesFilter {
+  page: number;
+  pageSize: number;
+  filterRoles?: IFilterRole[];
+  columnSortBy: string;
+  sortOrder: string;
+  viewSlug?: string;
+}
+
+export interface IExpense {
+  id: number;
+  totalAmount: number;
+  localAmount?: number;
+  currencyCode: string;
+  exchangeRate: number;
+  description?: string;
+  paymentAccountId: number;
+  peyeeId?: number;
+  referenceNo?: string;
+  publishedAt: Date | null;
+  userId: number;
+  paymentDate: Date;
+  payeeId: number;
+  landedCostAmount: number;
+  allocatedCostAmount: number;
+  unallocatedCostAmount: number;
+  categories?: IExpenseCategory[];
+  isPublished: boolean;
+
+  localLandedCostAmount?: number;
+  localAllocatedCostAmount?: number;
+  localUnallocatedCostAmount?: number;
+  
+  billableAmount: number;
+  invoicedAmount: number;
+
+  branchId?: number;
+
+  createdAt?: Date;
+}
+
+export interface IExpenseCategory {
+  id?: number;
+  expenseAccountId: number;
+  index: number;
+  description: string;
+  expenseId: number;
+  amount: number;
+
+  projectId?: number;
+
+  allocatedCostAmount: number;
+  unallocatedCostAmount: number;
+  landedCost: boolean;
+
+  expenseAccount?: IAccount;
+}
+
+export interface IExpenseCommonDTO {
+  currencyCode: string;
+  exchangeRate?: number;
+  description?: string;
+  paymentAccountId: number;
+  peyeeId?: number;
+  referenceNo?: string;
+  publish: boolean;
+  userId: number;
+  paymentDate: Date;
+  payeeId: number;
+  categories: IExpenseCategoryDTO[];
+
+  branchId?: number;
+}
+
+export interface IExpenseCreateDTO extends IExpenseCommonDTO {}
+export interface IExpenseEditDTO extends IExpenseCommonDTO {}
+
+export interface IExpenseCategoryDTO {
+  id?: number;
+  expenseAccountId: number;
+  index: number;
+  amount: number;
+  description?: string;
+  expenseId: number;
+  landedCost?: boolean;
+  projectId?: number;
+}
+
+export interface IExpensesService {
+  newExpense(
+    tenantid: number,
+    expenseDTO: IExpenseDTO,
+    authorizedUser: ISystemUser
+  ): Promise<IExpense>;
+
+  editExpense(
+    tenantid: number,
+    expenseId: number,
+    expenseDTO: IExpenseDTO,
+    authorizedUser: ISystemUser
+  ): void;
+
+  publishExpense(
+    tenantId: number,
+    expenseId: number,
+    authorizedUser: ISystemUser
+  ): Promise<void>;
+
+  deleteExpense(
+    tenantId: number,
+    expenseId: number,
+    authorizedUser: ISystemUser
+  ): Promise<void>;
+
+  getExpensesList(
+    tenantId: number,
+    expensesFilter: IExpensesFilter
+  ): Promise<{
+    expenses: IExpense[];
+    pagination: IPaginationMeta;
+    filterMeta: IFilterMeta;
+  }>;
+
+  getExpense(tenantId: number, expenseId: number): Promise<IExpense>;
+}
+
+export interface IExpenseCreatingPayload {
+  trx: Knex.Transaction;
+  tenantId: number;
+  expenseDTO: IExpenseCreateDTO;
+}
+
+export interface IExpenseEventEditingPayload {
+  tenantId: number;
+  oldExpense: IExpense;
+  expenseDTO: IExpenseEditDTO;
+  trx: Knex.Transaction;
+}
+export interface IExpenseCreatedPayload {
+  tenantId: number;
+  expenseId: number;
+  authorizedUser: ISystemUser;
+  expense: IExpense;
+  trx: Knex.Transaction;
+}
+
+export interface IExpenseEventEditPayload {
+  tenantId: number;
+  expenseId: number;
+  expense: IExpense;
+  expenseDTO: IExpenseEditDTO;
+  authorizedUser: ISystemUser;
+  oldExpense: IExpense;
+  trx: Knex.Transaction;
+}
+
+export interface IExpenseEventDeletePayload {
+  tenantId: number;
+  expenseId: number;
+  authorizedUser: ISystemUser;
+  oldExpense: IExpense;
+  trx: Knex.Transaction;
+}
+
+export interface IExpenseDeletingPayload {
+  trx: Knex.Transaction;
+  tenantId: number;
+  oldExpense: IExpense;
+}
+export interface IExpenseEventPublishedPayload {
+  tenantId: number;
+  expenseId: number;
+  oldExpense: IExpense;
+  expense: IExpense;
+  authorizedUser: ISystemUser;
+  trx: Knex.Transaction;
+}
+
+export interface IExpensePublishingPayload {
+  trx: Knex.Transaction;
+  oldExpense: IExpense;
+  tenantId: number;
+}
+export enum ExpenseAction {
+  Create = 'Create',
+  Edit = 'Edit',
+  Delete = 'Delete',
+  View = 'View',
+}
diff --git a/packages/server/src/interfaces/Features.ts b/packages/server/src/interfaces/Features.ts
new file mode 100644
index 000000000..691cf76af
--- /dev/null
+++ b/packages/server/src/interfaces/Features.ts
@@ -0,0 +1,15 @@
+export enum Features {
+  WAREHOUSES = 'warehouses',
+  BRANCHES = 'branches',
+}
+
+export interface IFeatureAllItem {
+  name: string;
+  isAccessible: boolean;
+  defaultAccessible: boolean;
+}
+
+export interface IFeatureConfiugration {
+  name: string;
+  defaultValue?: boolean;
+}
diff --git a/packages/server/src/interfaces/FinancialReports/CashflowAccountTransactions/index.ts b/packages/server/src/interfaces/FinancialReports/CashflowAccountTransactions/index.ts
new file mode 100644
index 000000000..afc98f7dc
--- /dev/null
+++ b/packages/server/src/interfaces/FinancialReports/CashflowAccountTransactions/index.ts
@@ -0,0 +1,32 @@
+import { INumberFormatQuery } from '../../FinancialStatements';
+
+export interface ICashflowAccountTransactionsQuery {
+  page: number;
+  pageSize: number;
+  accountId: number;
+  numberFormat: INumberFormatQuery;
+}
+
+export interface ICashflowAccountTransaction {
+  withdrawal: number;
+  deposit: number;
+  runningBalance: number;
+
+  formattedWithdrawal: string;
+  formattedDeposit: string;
+  formattedRunningBalance: string;
+
+  transactionNumber: string;
+  referenceNumber: string;
+
+  referenceId: number;
+  referenceType: string;
+
+  formattedTransactionType: string;
+
+  balance: number;
+  formattedBalance: string;
+
+  date: Date;
+  formattedDate: string;
+}
diff --git a/packages/server/src/interfaces/FinancialStatements.ts b/packages/server/src/interfaces/FinancialStatements.ts
new file mode 100644
index 000000000..ca39183e0
--- /dev/null
+++ b/packages/server/src/interfaces/FinancialStatements.ts
@@ -0,0 +1,44 @@
+export interface INumberFormatQuery {
+  precision: number;
+  divideOn1000: boolean;
+  showZero: boolean;
+  formatMoney: 'total' | 'always' | 'none';
+  negativeFormat: 'parentheses' | 'mines';
+}
+
+export interface IFormatNumberSettings {
+  precision?: number;
+  divideOn1000?: boolean;
+  excerptZero?: boolean;
+  negativeFormat?: 'parentheses' | 'mines';
+  thousand?: string;
+  decimal?: string;
+  zeroSign?: string;
+  currencyCode?: string;
+  money?: boolean;
+}
+
+export enum ReportsAction {
+  READ_BALANCE_SHEET = 'read-balance-sheet',
+  READ_TRIAL_BALANCE_SHEET = 'read-trial-balance-sheet',
+  READ_PROFIT_LOSS = 'read-profit-loss',
+  READ_JOURNAL = 'read-journal',
+  READ_GENERAL_LEDGET = 'read-general-ledger',
+  READ_CASHFLOW = 'read-cashflow',
+  READ_AR_AGING_SUMMARY = 'read-ar-aging-summary',
+  READ_AP_AGING_SUMMARY = 'read-ap-aging-summary',
+  READ_PURCHASES_BY_ITEMS = 'read-purchases-by-items',
+  READ_SALES_BY_ITEMS = 'read-sales-by-items',
+  READ_CUSTOMERS_TRANSACTIONS = 'read-customers-transactions',
+  READ_VENDORS_TRANSACTIONS = 'read-vendors-transactions',
+  READ_CUSTOMERS_SUMMARY_BALANCE = 'read-customers-summary-balance',
+  READ_VENDORS_SUMMARY_BALANCE = 'read-vendors-summary-balance',
+  READ_INVENTORY_VALUATION_SUMMARY = 'read-inventory-valuation-summary',
+  READ_INVENTORY_ITEM_DETAILS = 'read-inventory-item-details',
+  READ_CASHFLOW_ACCOUNT_TRANSACTION = 'read-cashflow-account-transactions',
+  READ_PROJECT_PROFITABILITY_SUMMARY = 'read-project-profitability-summary',
+}
+
+export interface IFinancialSheetBranchesQuery {
+  branchesIds?: number[];
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/GeneralLedgerSheet.ts b/packages/server/src/interfaces/GeneralLedgerSheet.ts
new file mode 100644
index 000000000..bf1662086
--- /dev/null
+++ b/packages/server/src/interfaces/GeneralLedgerSheet.ts
@@ -0,0 +1,81 @@
+
+
+export interface IGeneralLedgerSheetQuery {
+  fromDate: Date | string,
+  toDate: Date | string,
+  basis: string,
+  numberFormat: {
+    noCents: boolean,
+    divideOn1000: boolean,
+  },
+  noneTransactions: boolean,
+  accountsIds: number[],
+  branchesIds?: number[];
+};
+
+export interface IGeneralLedgerSheetAccountTransaction {
+  id: number,
+
+  amount: number,
+  runningBalance: number,
+  credit: number,
+  debit: number,
+
+  formattedAmount: string,
+  formattedCredit: string,
+  formattedDebit: string,
+  formattedRunningBalance: string,
+
+  currencyCode: string,
+  note?: string,
+
+  transactionType?: string,
+  transactionNumber: string,
+
+  referenceId?: number,
+  referenceType?: string,
+
+  date: Date|string,
+};
+
+export interface IGeneralLedgerSheetAccountBalance {
+  date: Date|string,
+  amount: number,
+  formattedAmount: string,
+  currencyCode: string,
+}
+
+export interface IGeneralLedgerSheetAccount {
+  id: number,
+  name: string,
+  code: string,
+  index: number,
+  parentAccountId: number,
+  transactions: IGeneralLedgerSheetAccountTransaction[],
+  openingBalance: IGeneralLedgerSheetAccountBalance,
+  closingBalance: IGeneralLedgerSheetAccountBalance,
+}
+
+export interface IAccountTransaction {
+  id: number,
+  index: number,
+  draft: boolean,
+  note: string,
+  accountId: number,
+  transactionType: string,
+  referenceType: string,
+  referenceId: number,
+  contactId: number,
+  contactType: string,
+  credit: number,
+  debit: number,
+  date: string|Date,
+  createdAt: string|Date,
+  updatedAt: string|Date,
+}
+
+export interface IGeneralLedgerMeta {
+  isCostComputeRunning: boolean,
+  organizationName: string,
+  baseCurrency: string,
+};
\ No newline at end of file
diff --git a/packages/server/src/interfaces/IInventoryValuationSheet.ts b/packages/server/src/interfaces/IInventoryValuationSheet.ts
new file mode 100644
index 000000000..dedb6c483
--- /dev/null
+++ b/packages/server/src/interfaces/IInventoryValuationSheet.ts
@@ -0,0 +1,47 @@
+import { INumberFormatQuery } from './FinancialStatements';
+
+export interface IInventoryValuationReportQuery {
+  asDate: Date | string;
+  numberFormat: INumberFormatQuery;
+  noneTransactions: boolean;
+  noneZero: boolean;
+  onlyActive: boolean;
+  itemsIds: number[];
+
+  warehousesIds?: number[];
+  branchesIds?: number[];
+}
+
+export interface IInventoryValuationSheetMeta {
+  organizationName: string;
+  baseCurrency: string;
+  isCostComputeRunning: boolean;
+}
+
+export interface IInventoryValuationItem {
+  id: number;
+  name: string;
+  code: string;
+  valuation: number;
+  quantity: number;
+  average: number;
+  valuationFormatted: string;
+  quantityFormatted: string;
+  averageFormatted: string;
+  currencyCode: string;
+}
+
+export interface IInventoryValuationTotal {
+  valuation: number;
+  quantity: number;
+
+  valuationFormatted: string;
+  quantityFormatted: string;
+}
+
+export type IInventoryValuationStatement =
+  | {
+      items: IInventoryValuationItem[];
+      total: IInventoryValuationTotal;
+    }
+  | {};
diff --git a/packages/server/src/interfaces/InventoryAdjustment.ts b/packages/server/src/interfaces/InventoryAdjustment.ts
new file mode 100644
index 000000000..07b234a4f
--- /dev/null
+++ b/packages/server/src/interfaces/InventoryAdjustment.ts
@@ -0,0 +1,100 @@
+import { Knex } from 'knex';
+import { IItem } from './Item';
+
+type IAdjustmentTypes = 'increment' | 'decrement';
+
+export interface IQuickInventoryAdjustmentDTO {
+  date: Date;
+  type: IAdjustmentTypes;
+  adjustmentAccountId: number;
+  reason: string;
+  description: string;
+  referenceNo: string;
+  itemId: number;
+  quantity: number;
+  cost: number;
+  publish: boolean;
+
+  warehouseId?: number;
+  branchId?: number;
+}
+
+export interface IInventoryAdjustment {
+  id?: number;
+  date: Date;
+  adjustmentAccountId: number;
+  reason: string;
+  description: string;
+  type: string;
+  referenceNo: string;
+  inventoryDirection?: 'IN' | 'OUT';
+  entries: IInventoryAdjustmentEntry[];
+  userId: number;
+  publishedAt?: Date | null;
+  createdAt?: Date;
+  isPublished: boolean;
+
+  branchId?: number;
+  warehouseId?: number;
+}
+
+export interface IInventoryAdjustmentEntry {
+  id?: number;
+  adjustmentId?: number;
+  index: number;
+  itemId: number;
+  quantity?: number;
+  cost?: number;
+  value?: number;
+
+  item?: IItem;
+}
+
+export interface IInventoryAdjustmentsFilter {
+  page: number;
+  pageSize: number;
+}
+
+export interface IInventoryAdjustmentEventCreatedPayload {
+  tenantId: number;
+  inventoryAdjustment: IInventoryAdjustment;
+  inventoryAdjustmentId: number;
+  trx: Knex.Transaction;
+}
+export interface IInventoryAdjustmentCreatingPayload {
+  tenantId: number;
+  quickAdjustmentDTO: IQuickInventoryAdjustmentDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IInventoryAdjustmentEventPublishedPayload {
+  tenantId: number;
+  inventoryAdjustmentId: number;
+  inventoryAdjustment: IInventoryAdjustment;
+  trx: Knex.Transaction;
+}
+
+export interface IInventoryAdjustmentPublishingPayload {
+  trx: Knex.Transaction;
+  tenantId: number;
+  oldInventoryAdjustment: IInventoryAdjustment;
+}
+export interface IInventoryAdjustmentEventDeletedPayload {
+  tenantId: number;
+  inventoryAdjustmentId: number;
+  oldInventoryAdjustment: IInventoryAdjustment;
+  trx: Knex.Transaction;
+}
+
+export interface IInventoryAdjustmentDeletingPayload {
+  tenantId: number;
+  oldInventoryAdjustment: IInventoryAdjustment;
+  trx: Knex.Transaction;
+}
+
+export enum InventoryAdjustmentAction {
+  CREATE = 'Create',
+  EDIT = 'Edit',
+  DELETE = 'Delete',
+  VIEW = 'View',
+}
diff --git a/packages/server/src/interfaces/InventoryCost.ts b/packages/server/src/interfaces/InventoryCost.ts
new file mode 100644
index 000000000..c1049b078
--- /dev/null
+++ b/packages/server/src/interfaces/InventoryCost.ts
@@ -0,0 +1,16 @@
+import { Knex } from "knex";
+
+
+
+export interface IInventoryItemCostMeta {
+  itemId: number;
+  valuation: number;
+  quantity: number;
+  average: number;
+}
+
+export interface IInventoryCostLotsGLEntriesWriteEvent {
+  tenantId: number,
+  startingDate: Date,
+  trx: Knex.Transaction
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/InventoryCostMethod.ts b/packages/server/src/interfaces/InventoryCostMethod.ts
new file mode 100644
index 000000000..104edc5e3
--- /dev/null
+++ b/packages/server/src/interfaces/InventoryCostMethod.ts
@@ -0,0 +1,6 @@
+
+
+interface IInventoryCostMethod {
+  computeItemsCost(fromDate: Date): void,
+  storeInventoryLotsCost(transactions: any[]): void,
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/InventoryDetails.ts b/packages/server/src/interfaces/InventoryDetails.ts
new file mode 100644
index 000000000..733cb588a
--- /dev/null
+++ b/packages/server/src/interfaces/InventoryDetails.ts
@@ -0,0 +1,94 @@
+import {
+  INumberFormatQuery,
+} from './FinancialStatements';
+
+export interface IInventoryDetailsQuery {
+  fromDate: Date | string;
+  toDate: Date | string;
+  numberFormat: INumberFormatQuery;
+  noneTransactions: boolean;
+  itemsIds: number[]
+
+  warehousesIds?: number[];
+  branchesIds?: number[];
+}
+
+export interface IInventoryDetailsNumber {
+  number: number;
+  formattedNumber: string;
+}
+
+export interface IInventoryDetailsMoney {
+  amount: number;
+  formattedAmount: string;
+  currencyCode: string;
+}
+
+export interface IInventoryDetailsDate {
+  date: Date;
+  formattedDate: string;
+}
+
+export interface IInventoryDetailsOpening {
+  nodeType: 'OPENING_ENTRY';
+  date: IInventoryDetailsDate;
+  quantity: IInventoryDetailsNumber;
+  value: IInventoryDetailsNumber;
+}
+
+export interface IInventoryDetailsClosing extends IInventoryDetailsOpening {
+  nodeType: 'CLOSING_ENTRY';
+}
+
+export interface IInventoryDetailsItem {
+  id: number;
+  nodeType: string;
+  name: string;
+  code: string;
+  children: (
+    | IInventoryDetailsItemTransaction
+    | IInventoryDetailsOpening
+    | IInventoryDetailsClosing
+  )[];
+}
+
+export interface IInventoryDetailsItemTransaction {
+  nodeType: string;
+  date: IInventoryDetailsDate;
+  transactionType: string;
+  transactionNumber?: string;
+
+  quantityMovement: IInventoryDetailsNumber;
+  valueMovement: IInventoryDetailsNumber;
+
+  quantity: IInventoryDetailsNumber;
+  total: IInventoryDetailsNumber;
+  cost: IInventoryDetailsNumber;
+  value: IInventoryDetailsNumber;
+  profitMargin: IInventoryDetailsNumber;
+  
+  rate: IInventoryDetailsNumber;
+
+  runningQuantity: IInventoryDetailsNumber;
+  runningValuation: IInventoryDetailsNumber;
+
+  direction: string;
+}
+
+export type IInventoryDetailsNode =
+  | IInventoryDetailsItem
+  | IInventoryDetailsItemTransaction;
+export type IInventoryDetailsData = IInventoryDetailsItem[];
+
+
+export interface IInventoryItemDetailMeta {
+  isCostComputeRunning: boolean;
+  organizationName: string;
+  baseCurrency: string;
+}
+
+export interface IInvetoryItemDetailDOO {
+  data: IInventoryDetailsData;
+  query: IInventoryDetailsQuery;
+  meta: IInventoryItemDetailMeta;
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/InventoryTransaction.ts b/packages/server/src/interfaces/InventoryTransaction.ts
new file mode 100644
index 000000000..b483e1c60
--- /dev/null
+++ b/packages/server/src/interfaces/InventoryTransaction.ts
@@ -0,0 +1,95 @@
+import { Knex } from 'knex';
+import { IItem } from './Item';
+import { ISaleInvoice } from './SaleInvoice';
+import { ISaleReceipt } from './SaleReceipt';
+
+export type TInventoryTransactionDirection = 'IN' | 'OUT';
+
+export interface IInventoryTransaction {
+  id?: number;
+  date: Date | string;
+  direction: TInventoryTransactionDirection;
+  itemId: number;
+  quantity: number | null;
+  rate: number;
+  transactionType: string;
+  transcationTypeFormatted?: string;
+  transactionId: number;
+  costAccountId?: number;
+  entryId: number;
+  meta?: IInventoryTransactionMeta;
+  costLotAggregated?: IInventoryCostLotAggregated;
+  createdAt?: Date;
+  updatedAt?: Date;
+  warehouseId?: number;
+}
+
+export interface IInventoryTransactionMeta {
+  id?: number;
+  transactionNumber: string;
+  description: string;
+}
+
+export interface IInventoryCostLotAggregated {
+  cost: number;
+  quantity: number;
+}
+
+export interface IInventoryLotCost {
+  id?: number;
+  date: Date;
+  direction: string;
+  itemId: number;
+  quantity: number;
+  rate: number;
+  remaining: number;
+  cost: number;
+  transactionType: string;
+  transactionId: number;
+  costAccountId: number;
+  entryId: number;
+  createdAt: Date;
+
+  exchangeRate: number;
+  currencyCode: string;
+  item?: IItem;
+
+  invoice?: ISaleInvoice;
+  receipt?: ISaleReceipt;
+}
+
+export interface IItemsQuantityChanges {
+  itemId: number;
+  balanceChange: number;
+}
+
+export interface IInventoryTransactionsCreatedPayload {
+  tenantId: number;
+  inventoryTransactions: IInventoryTransaction[];
+  trx: Knex.Transaction;
+}
+
+export interface IInventoryTransactionsDeletedPayload {
+  tenantId: number;
+  oldInventoryTransactions: IInventoryTransaction[];
+  transactionId: number;
+  transactionType: string;
+  trx: Knex.Transaction;
+}
+
+export interface IInventoryItemCostScheduledPayload {
+  startingDate: Date | string;
+  itemId: number;
+  tenantId: number;
+}
+
+export interface IComputeItemCostJobStartedPayload {
+  startingDate: Date | string;
+  itemId: number;
+  tenantId: number;
+}
+export interface IComputeItemCostJobCompletedPayload {
+  startingDate: Date | string;
+  itemId: number;
+  tenantId: number;
+}
diff --git a/packages/server/src/interfaces/Item.ts b/packages/server/src/interfaces/Item.ts
new file mode 100644
index 000000000..748fccefb
--- /dev/null
+++ b/packages/server/src/interfaces/Item.ts
@@ -0,0 +1,130 @@
+import { Knex } from 'knex';
+import { AbilitySubject } from '@/interfaces';
+import { IFilterRole } from '@/interfaces/DynamicFilter';
+
+export interface IItem {
+  id: number;
+  name: string;
+  type: string;
+  code: string;
+
+  sellable: boolean;
+  purchasable: boolean;
+
+  costPrice: number;
+  sellPrice: number;
+  currencyCode: string;
+
+  costAccountId: number;
+  sellAccountId: number;
+  inventoryAccountId: number;
+
+  sellDescription: string;
+  purchaseDescription: string;
+
+  quantityOnHand: number;
+
+  note: string;
+  active: boolean;
+
+  categoryId: number;
+  userId: number;
+
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface IItemDTO {
+  name: string;
+  type: string;
+  code: string;
+
+  sellable: boolean;
+  purchasable: boolean;
+
+  costPrice: number;
+  sellPrice: number;
+
+  currencyCode: string;
+
+  costAccountId: number;
+  sellAccountId: number;
+  inventoryAccountId: number;
+
+  sellDescription: string;
+  purchaseDescription: string;
+
+  quantityOnHand: number;
+
+  note: string;
+  active: boolean;
+
+  categoryId: number;
+}
+
+export interface IItemCreateDTO extends IItemDTO {}
+export interface IItemEditDTO extends IItemDTO {}
+
+export interface IItemsService {
+  getItem(tenantId: number, itemId: number): Promise<IItem>;
+  deleteItem(tenantId: number, itemId: number): Promise<void>;
+  editItem(tenantId: number, itemId: number, itemDTO: IItemDTO): Promise<IItem>;
+  newItem(tenantId: number, itemDTO: IItemDTO): Promise<IItem>;
+  itemsList(
+    tenantId: number,
+    itemsFilter: IItemsFilter
+  ): Promise<{ items: IItem[] }>;
+}
+
+export interface IItemsFilter extends IDynamicListFilterDTO {
+  stringifiedFilterRoles?: string;
+  page: number;
+  pageSize: number;
+  inactiveMode: boolean;
+  viewSlug?: string;
+}
+
+export interface IItemsAutoCompleteFilter {
+  limit: number;
+  keyword: string;
+  filterRoles?: IFilterRole[];
+  columnSortBy: string;
+  sortOrder: string;
+}
+
+export interface IItemEventCreatedPayload {
+  tenantId: number;
+  item: IItem;
+  itemId: number;
+  trx: Knex.Transaction;
+}
+
+export interface IItemEventEditedPayload {
+  tenantId: number;
+  item: IItem;
+  oldItem: IItem;
+  itemId: number;
+  trx: Knex.Transaction;
+}
+
+export interface IItemEventDeletingPayload {
+  tenantId: number;
+  trx: Knex.Transaction;
+  oldItem: IItem;
+}
+
+export interface IItemEventDeletedPayload {
+  tenantId: number;
+  oldItem: IItem;
+  itemId: number;
+  trx: Knex.Transaction;
+}
+
+export enum ItemAction {
+  CREATE = 'Create',
+  EDIT = 'Edit',
+  DELETE = 'Delete',
+  VIEW = 'View',
+}
+
+export type ItemAbility = [ItemAction, AbilitySubject.Item];
diff --git a/packages/server/src/interfaces/ItemCategory.ts b/packages/server/src/interfaces/ItemCategory.ts
new file mode 100644
index 000000000..7113573e9
--- /dev/null
+++ b/packages/server/src/interfaces/ItemCategory.ts
@@ -0,0 +1,87 @@
+import Knex from 'knex';
+import { IDynamicListFilterDTO } from './DynamicFilter';
+import { ISystemUser } from './User';
+
+export interface IItemCategory {
+  id: number;
+  name: string;
+  description?: string;
+  userId: number;
+
+  costAccountId?: number;
+  sellAccountId?: number;
+  inventoryAccountId?: number;
+
+  costMethod?: string;
+}
+
+export interface IItemCategoryOTD {
+  name: string;
+
+  description?: string;
+  userId: number;
+
+  costAccountId?: number;
+  sellAccountId?: number;
+  inventoryAccountId?: number;
+
+  costMethod?: string;
+}
+
+export interface IItemCategoriesFilter extends IDynamicListFilterDTO {
+  stringifiedFilterRoles?: string;
+}
+
+export interface IItemCategoriesService {
+  newItemCategory(
+    tenantId: number,
+    itemCategoryOTD: IItemCategoryOTD,
+    authorizedUser: ISystemUser
+  ): Promise<IItemCategory>;
+  editItemCategory(
+    tenantId: number,
+    itemCategoryId: number,
+    itemCategoryOTD: IItemCategoryOTD,
+    authorizedUser: ISystemUser
+  ): Promise<IItemCategory>;
+
+  deleteItemCategory(
+    tenantId: number,
+    itemCategoryId: number,
+    authorizedUser: ISystemUser
+  ): Promise<void>;
+  deleteItemCategories(
+    tenantId: number,
+    itemCategoriesIds: number[],
+    authorizedUser: ISystemUser
+  ): Promise<void>;
+
+  getItemCategory(
+    tenantId: number,
+    itemCategoryId: number,
+    authorizedUser: ISystemUser
+  ): Promise<void>;
+  getItemCategoriesList(
+    tenantId: number,
+    itemCategoriesFilter: IItemCategoriesFilter,
+    authorizedUser: ISystemUser
+  ): Promise<void>;
+}
+
+export interface IItemCategoryCreatedPayload {
+  tenantId: number;
+  itemCategory: IItemCategory;
+  trx: Knex.Transaction;
+}
+
+export interface IItemCategoryEditedPayload {
+  oldItemCategory: IItemCategory;
+  tenantId: number;
+  trx: Knex.Transaction;
+}
+
+export interface IItemCategoryDeletedPayload {
+  tenantId: number;
+  itemCategoryId: number;
+  oldItemCategory: IItemCategory;
+}
diff --git a/packages/server/src/interfaces/ItemEntry.ts b/packages/server/src/interfaces/ItemEntry.ts
new file mode 100644
index 000000000..135f52e21
--- /dev/null
+++ b/packages/server/src/interfaces/ItemEntry.ts
@@ -0,0 +1,55 @@
+import { IItem } from './Item';
+import { IBillLandedCostEntry } from './LandedCost';
+
+export type IItemEntryTransactionType = 'SaleInvoice' | 'Bill' | 'SaleReceipt';
+
+export interface IItemEntry {
+  id?: number;
+
+  referenceType: string;
+  referenceId: number;
+
+  index: number;
+
+  itemId: number;
+  description: string;
+  discount: number;
+  quantity: number;
+  rate: number;
+  amount: number;
+
+  landedCost: number;
+  allocatedCostAmount: number;
+  unallocatedCostAmount: number;
+
+  sellAccountId: number;
+  costAccountId: number;
+
+  warehouseId: number;
+  projectId: number;
+
+  projectRefId?: number;
+  projectRefType?: ProjectLinkRefType;
+  projectRefInvoicedAmount?: number;
+
+  item?: IItem;
+
+  allocatedCostEntries?: IBillLandedCostEntry[];
+}
+
+export interface IItemEntryDTO {
+  id?: number;
+  itemId: number;
+  landedCost?: boolean;
+  warehouseId?: number;
+
+  projectRefId?: number;
+  projectRefType?: ProjectLinkRefType;
+  projectRefInvoicedAmount?: number;
+}
+
+export enum ProjectLinkRefType {
+  Task = 'TASK',
+  Bill = 'BILL',
+  Expense = 'EXPENSE',
+}
diff --git a/packages/server/src/interfaces/Jobs.ts b/packages/server/src/interfaces/Jobs.ts
new file mode 100644
index 000000000..9c40bcd43
--- /dev/null
+++ b/packages/server/src/interfaces/Jobs.ts
@@ -0,0 +1,14 @@
+export interface IJobMeta {
+  id: string;
+  nextRunAt: Date;
+  lastModifiedBy: null | Date;
+  lockedAt: null | Date;
+  lastRunAt: null | Date;
+  failCount: number;
+  failedAt: null | Date;
+  lastFinishedAt: Date | null;
+  running: boolean;
+  queued: boolean;
+  completed: boolean;
+  failed: boolean;
+}
diff --git a/packages/server/src/interfaces/Journal.ts b/packages/server/src/interfaces/Journal.ts
new file mode 100644
index 000000000..b4020b296
--- /dev/null
+++ b/packages/server/src/interfaces/Journal.ts
@@ -0,0 +1,55 @@
+export interface IJournalEntry {
+  id: number;
+  index?: number;
+
+  date: Date;
+  credit: number;
+  debit: number;
+  account: number;
+  referenceType: string;
+  referenceId: number;
+
+  referenceTypeFormatted: string;
+
+  itemId?: number;
+  transactionNumber?: string;
+  referenceNumber?: string;
+
+  transactionType?: string;
+  note?: string;
+  userId?: number;
+  contactType?: string;
+  contactId?: number;
+  branchId: number;
+}
+
+export interface IJournalPoster {
+  entries: IJournalEntry[];
+
+  credit(entry: IJournalEntry): void;
+  debit(entry: IJournalEntry): void;
+
+  removeEntries(ids: number[]): void;
+
+  saveEntries(): void;
+  saveBalance(): void;
+  deleteEntries(): void;
+
+  getAccountBalance(
+    accountId: number,
+    closingDate?: Date | string,
+    dateType?: string
+  ): number;
+  getAccountEntries(accountId: number): IJournalEntry[];
+}
+
+export type TEntryType = 'credit' | 'debit';
+
+export interface IAccountChange {
+  credit: number;
+  debit: number;
+}
+
+export interface IAccountsChange {
+  [key: string]: IAccountChange;
+}
diff --git a/packages/server/src/interfaces/JournalReport.ts b/packages/server/src/interfaces/JournalReport.ts
new file mode 100644
index 000000000..9786e1634
--- /dev/null
+++ b/packages/server/src/interfaces/JournalReport.ts
@@ -0,0 +1,36 @@
+import { IJournalEntry } from './Journal';
+
+export interface IJournalReportQuery {
+  fromDate: Date | string,
+  toDate: Date | string,
+  numberFormat: {
+    noCents: boolean,
+    divideOn1000: boolean,
+  },
+  transactionType: string,
+  transactionId: string,
+
+  accountsIds: number | number[],
+  fromRange: number,
+  toRange: number,
+}
+
+export interface IJournalReportEntriesGroup {
+  id: string,
+  entries: IJournalEntry[],
+  currencyCode: string,
+  credit: number,
+  debit: number,
+  formattedCredit: string,
+  formattedDebit: string,
+}
+
+export interface IJournalReport {
+  entries: IJournalReportEntriesGroup[],
+}
+
+export interface IJournalSheetMeta {
+  isCostComputeRunning: boolean,
+  organizationName: string,
+  baseCurrency: string,
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/LandedCost.ts b/packages/server/src/interfaces/LandedCost.ts
new file mode 100644
index 000000000..9653be8cc
--- /dev/null
+++ b/packages/server/src/interfaces/LandedCost.ts
@@ -0,0 +1,153 @@
+import { IBill } from '@/interfaces';
+import Knex from 'knex';
+import { IItemEntry } from './ItemEntry';
+
+export interface IBillLandedCost {
+  id?: number;
+
+  fromTransactionId: number;
+  fromTransactionType: string;
+  fromTransactionEntryId: number;
+  allocationMethod: string;
+  costAccountId: number;
+  description: string;
+
+  amount: number;
+  localAmount?: number;
+  exchangeRate: number;
+  currencyCode: string;
+
+  billId: number;
+  allocateEntries: IBillLandedCostEntry[]
+}
+
+export interface IBillLandedCostEntry {
+  id?: number;
+  cost: number;
+  entryId: number;
+  billLocatedCostId: number;
+
+  itemEntry?: IItemEntry;
+}
+
+export interface ILandedCostItemDTO {
+  entryId: number;
+  cost: number;
+}
+export type ILandedCostType = 'Expense' | 'Bill';
+
+export interface ILandedCostDTO {
+  transactionType: ILandedCostType;
+  transactionId: number;
+  transactionEntryId: number;
+  allocationMethod: string;
+  description: string;
+  items: ILandedCostItemDTO[];
+}
+
+export interface ILandedCostQueryDTO {
+  vendorId: number;
+  fromDate: Date;
+  toDate: Date;
+}
+
+export interface IUnallocatedListCost {
+  costNumber: string;
+  costAmount: number;
+  unallocatedAmount: number;
+}
+
+export interface ILandedCostTransactionsQueryDTO {
+  transactionType: string;
+  date: Date;
+}
+
+export interface ILandedCostEntriesQueryDTO {
+  transactionType: string;
+  transactionId: number;
+}
+
+export interface ILandedCostTransaction {
+  id: number;
+  name: string;
+  amount: number;
+  allocatedCostAmount: number;
+  unallocatedCostAmount: number;
+  currencyCode: string;
+  exchangeRate: number;
+  // formattedAllocatedCostAmount: string;
+  // formattedAmount: string;
+  // formattedUnallocatedCostAmount: string;
+  transactionType: string;
+  entries?: ILandedCostTransactionEntry[];
+}
+
+export interface ILandedCostTransactionEntry {
+  id: number;
+  name: string;
+  code: string;
+  amount: number;
+  unallocatedCostAmount: number;
+  allocatedCostAmount: number;
+  description: string;
+  costAccountId: number;
+}
+
+export interface ILandedCostTransactionEntryDOJO
+  extends ILandedCostTransactionEntry {
+  formattedAmount: string;
+  formattedUnallocatedCostAmount: string;
+  formattedAllocatedCostAmount: string;
+}
+export interface ILandedCostTransactionDOJO extends ILandedCostTransaction {
+  formattedAmount: string;
+  formattedUnallocatedCostAmount: string;
+  formattedAllocatedCostAmount: string;
+}
+
+interface ILandedCostEntry {
+  id: number;
+  landedCost?: boolean;
+}
+
+export interface IBillLandedCostTransaction {
+  id: number;
+  fromTransactionId: number;
+  fromTransactionType: string;
+  fromTransactionEntryId: number;
+
+  billId: number;
+  allocationMethod: string;
+  costAccountId: number;
+  description: string;
+
+  amount: number;
+  localAmount?: number;
+  currencyCode: string;
+  exchangeRate: number;
+
+  allocateEntries?: IBillLandedCostTransactionEntry[];
+}
+
+export interface IBillLandedCostTransactionEntry {
+  cost: number;
+  entryId: number;
+  billLocatedCostId: number;
+}
+
+export interface IAllocatedLandedCostDeletedPayload {
+  tenantId: number;
+  oldBillLandedCost: IBillLandedCostTransaction;
+  billId: number;
+  trx: Knex.Transaction;
+}
+
+export interface IAllocatedLandedCostCreatedPayload {
+  tenantId: number;
+  bill: IBill;
+  billLandedCostId: number;
+  billLandedCost: IBillLandedCostTransaction;
+  trx: Knex.Transaction;
+}
+
+export interface IBillAssociatedLandedCostTransactions {}
diff --git a/packages/server/src/interfaces/Ledger.ts b/packages/server/src/interfaces/Ledger.ts
new file mode 100644
index 000000000..49419e680
--- /dev/null
+++ b/packages/server/src/interfaces/Ledger.ts
@@ -0,0 +1,71 @@
+import { Knex } from 'knex';
+export interface ILedger {
+  entries: ILedgerEntry[];
+
+  getEntries(): ILedgerEntry[];
+
+  whereAccountId(accountId: number): ILedger;
+  whereContactId(contactId: number): ILedger;
+  whereFromDate(fromDate: Date | string): ILedger;
+  whereToDate(toDate: Date | string): ILedger;
+  whereCurrencyCode(currencyCode: string): ILedger;
+  whereBranch(branchId: number): ILedger;
+  whereItem(itemId: number): ILedger;
+
+  getClosingBalance(): number;
+  getForeignClosingBalance(): number;
+
+  getContactsIds(): number[];
+  getAccountsIds(): number[];
+}
+
+export interface ILedgerEntry {
+  credit: number;
+  debit: number;
+  currencyCode: string;
+  exchangeRate: number;
+
+  accountId?: number;
+  accountNormal: string;
+  contactId?: number;
+  date: Date | string;
+
+  transactionType: string;
+  transactionId: number;
+
+  transactionNumber?: string;
+
+  referenceNumber?: string;
+  index: number;
+  indexGroup?: number;
+
+  userId?: number;
+  itemId?: number;
+  branchId?: number;
+  projectId?: number;
+
+  entryId?: number;
+  createdAt?: Date;
+
+  costable?: boolean;
+}
+
+export interface ISaveLedgerEntryQueuePayload {
+  tenantId: number;
+  entry: ILedgerEntry;
+  trx?: Knex.Transaction;
+}
+
+export interface ISaveAccountsBalanceQueuePayload {
+  ledger: ILedger;
+  tenantId: number;
+  accountId: number;
+  trx?: Knex.Transaction;
+}
+
+export interface ISaleContactsBalanceQueuePayload {
+  ledger: ILedger;
+  tenantId: number;
+  contactId: number;
+  trx?: Knex.Transaction;
+}
diff --git a/packages/server/src/interfaces/License.ts b/packages/server/src/interfaces/License.ts
new file mode 100644
index 000000000..e58e9a6ea
--- /dev/null
+++ b/packages/server/src/interfaces/License.ts
@@ -0,0 +1,25 @@
+
+
+export interface ILicense {
+  id?: number,
+  licenseCode: string,
+  licensePeriod: number,
+  sent: boolean,
+  disabled: boolean,
+  used: boolean,
+};
+
+export interface ILicensesFilter {
+  active: boolean,
+  disabld: boolean,
+  used: boolean,
+  sent: boolean,
+};
+
+export interface ISendLicenseDTO {
+  phoneNumber: string,
+  email: string,
+  period: string,
+  periodInterval: string,
+  planSlug: string,
+};
\ No newline at end of file
diff --git a/packages/server/src/interfaces/Mailable.ts b/packages/server/src/interfaces/Mailable.ts
new file mode 100644
index 000000000..36cc3c81f
--- /dev/null
+++ b/packages/server/src/interfaces/Mailable.ts
@@ -0,0 +1,16 @@
+
+export interface IMailable {
+  constructor(
+    view: string,
+    data?: { [key: string]: string | number },
+  );
+  send(): Promise<any>;
+  build(): void;
+  setData(data: { [key: string]: string | number }): IMailable;
+  setTo(to: string): IMailable;
+  setFrom(from: string): IMailable;
+  setSubject(subject: string): IMailable;
+  setView(view: string): IMailable;
+  render(data?: { [key: string]: string | number }): string;
+  getViewContent(): string;
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/ManualJournal.ts b/packages/server/src/interfaces/ManualJournal.ts
new file mode 100644
index 000000000..863a23bdd
--- /dev/null
+++ b/packages/server/src/interfaces/ManualJournal.ts
@@ -0,0 +1,172 @@
+import { Knex } from 'knex';
+import { IDynamicListFilterDTO } from './DynamicFilter';
+import { ISystemUser } from './User';
+import { IAccount } from './Account';
+
+export interface IManualJournal {
+  id?: number;
+  date: Date;
+  journalNumber: string;
+  journalType: string;
+  reference: string;
+  amount: number;
+  currencyCode: string;
+  exchangeRate: number | null;
+  publishedAt: Date | null;
+  description: string;
+  userId?: number;
+  entries: IManualJournalEntry[];
+  createdAt?: Date;
+  updatedAt?: Date;
+  isPublished?: boolean;
+}
+
+export interface IManualJournalEntry {
+  index: number;
+  credit: number;
+  debit: number;
+  accountId: number;
+  note: string;
+  contactId?: number;
+  account?: IAccount
+
+  branchId?: number;
+  projectId?: number;
+}
+
+export interface IManualJournalEntryDTO {
+  index: number;
+  credit: number;
+  debit: number;
+  accountId: number;
+  note: string;
+  contactId?: number;
+  branchId?: number
+  projectId?: number;
+}
+
+export interface IManualJournalDTO {
+  date: Date;
+  currencyCode?: string;
+  exchangeRate?: number;
+  journalNumber: string;
+  journalType: string;
+  reference?: string;
+  description?: string;
+  publish?: boolean;
+  branchId?: number;
+  entries: IManualJournalEntryDTO[];
+}
+
+export interface IManualJournalsFilter extends IDynamicListFilterDTO {
+  stringifiedFilterRoles?: string;
+  page: number;
+  pageSize: number;
+}
+
+export interface IManualJournalsService {
+  makeJournalEntries(
+    tenantId: number,
+    manualJournalDTO: IManualJournalDTO,
+    authorizedUser: ISystemUser
+  ): Promise<{ manualJournal: IManualJournal }>;
+
+  editJournalEntries(
+    tenantId: number,
+    manualJournalId: number,
+    manualJournalDTO: IManualJournalDTO,
+    authorizedUser
+  ): Promise<{ manualJournal: IManualJournal }>;
+
+  deleteManualJournal(tenantId: number, manualJournalId: number): Promise<void>;
+
+  deleteManualJournals(
+    tenantId: number,
+    manualJournalsIds: number[]
+  ): Promise<void>;
+
+  publishManualJournals(
+    tenantId: number,
+    manualJournalsIds: number[]
+  ): Promise<{
+    meta: {
+      alreadyPublished: number;
+      published: number;
+      total: number;
+    };
+  }>;
+
+  publishManualJournal(
+    tenantId: number,
+    manualJournalId: number
+  ): Promise<void>;
+
+  getManualJournals(
+    tenantId: number,
+    filter: IManualJournalsFilter
+  ): Promise<{
+    manualJournals: IManualJournal;
+    pagination: IPaginationMeta;
+    filterMeta: IFilterMeta;
+  }>;
+}
+
+export interface IManualJournalEventPublishedPayload {
+  tenantId: number;
+  manualJournal: IManualJournal;
+  manualJournalId: number;
+  oldManualJournal: IManualJournal;
+  trx: Knex.Transaction;
+}
+
+export interface IManualJournalPublishingPayload {
+  oldManualJournal: IManualJournal;
+  trx: Knex.Transaction;
+  tenantId: number;
+}
+
+export interface IManualJournalEventDeletedPayload {
+  tenantId: number;
+  manualJournalId: number;
+  oldManualJournal: IManualJournal;
+  trx: Knex.Transaction;
+}
+
+export interface IManualJournalDeletingPayload {
+  tenantId: number;
+  oldManualJournal: IManualJournal;
+  trx: Knex.Transaction;
+}
+
+export interface IManualJournalEventEditedPayload {
+  tenantId: number;
+  manualJournal: IManualJournal;
+  oldManualJournal: IManualJournal;
+  trx: Knex.Transaction;
+}
+export interface IManualJournalEditingPayload {
+  tenantId: number;
+  oldManualJournal: IManualJournal;
+  manualJournalDTO: IManualJournalDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IManualJournalCreatingPayload {
+  tenantId: number;
+  manualJournalDTO: IManualJournalDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IManualJournalEventCreatedPayload {
+  tenantId: number;
+  manualJournal: IManualJournal;
+  manualJournalId: number;
+  trx: Knex.Transaction;
+}
+
+export enum ManualJournalAction {
+  Create = 'Create',
+  View = 'View',
+  Edit = 'Edit',
+  Delete = 'Delete',
+}
diff --git a/packages/server/src/interfaces/Media.ts b/packages/server/src/interfaces/Media.ts
new file mode 100644
index 000000000..6cd338583
--- /dev/null
+++ b/packages/server/src/interfaces/Media.ts
@@ -0,0 +1,25 @@
+
+
+export interface IMedia {
+  id?: number,
+  attachmentFile: string,
+  createdAt?: Date,
+};
+
+export interface IMediaLink {
+  mediaId: number,
+  modelName: string,
+  modelId: number,
+};
+
+export interface IMediaLinkDTO {
+  modelName: string,
+  modelId: number,
+};
+
+export interface IMediaService {
+  linkMedia(tenantId: number, mediaId: number, modelId?: number, modelName?: string): Promise<void>;
+  getMedia(tenantId: number, mediaId: number): Promise<IMedia>;
+  deleteMedia(tenantId: number, mediaId: number | number[]): Promise<void>;
+  upload(tenantId: number, attachment: any, modelName?: string, modelId?: number): Promise<IMedia>;
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/Metable.ts b/packages/server/src/interfaces/Metable.ts
new file mode 100644
index 000000000..8a16d3055
--- /dev/null
+++ b/packages/server/src/interfaces/Metable.ts
@@ -0,0 +1,28 @@
+
+
+export interface IMetadata {
+  key: string,
+  value: string|boolean|number,
+  group: string,
+  _markAsDeleted?: boolean,
+  _markAsInserted?: boolean,
+  _markAsUpdated?: boolean,
+};
+
+export interface IMetaQuery {
+  key: string,
+  group?: string,
+};
+
+export interface IMetableStore {
+  find(query: string|IMetaQuery): IMetadata;
+  all(): IMetadata[];
+  get(query: string|IMetaQuery, defaultValue: any): string|number|boolean;
+  remove(query: string|IMetaQuery): void;
+  removeAll(): void;
+  toArray(): IMetadata[];
+};
+
+export interface IMetableStoreStorage {
+  save(): Promise<void>;
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/Model.ts b/packages/server/src/interfaces/Model.ts
new file mode 100644
index 000000000..67b90e872
--- /dev/null
+++ b/packages/server/src/interfaces/Model.ts
@@ -0,0 +1,81 @@
+export interface IModel {
+  name: string;
+  tableName: string;
+  fields: { [key: string]: any };
+}
+
+export interface IFilterMeta {
+  sortOrder: string;
+  sortBy: string;
+}
+
+export interface IPaginationMeta {
+  pageSize: number;
+  page: number;
+}
+
+export interface IModelMetaDefaultSort {
+  sortOrder: ISortOrder;
+  sortField: string;
+}
+
+export type IModelColumnType =
+  | 'text'
+  | 'number'
+  | 'enumeration'
+  | 'boolean'
+  | 'relation';
+
+export type ISortOrder = 'DESC' | 'ASC';
+
+export interface IModelMetaFieldCommon {
+  name: string;
+  column: string;
+  columnable?: boolean;
+  fieldType: IModelColumnType;
+  customQuery?: Function;
+}
+
+export interface IModelMetaFieldNumber {
+  fieldType: 'number';
+  minLength?: number;
+  maxLength?: number;
+}
+
+export interface IModelMetaFieldOther {
+  fieldType: 'text' | 'boolean';
+}
+
+export type IModelMetaField = IModelMetaFieldCommon &
+  (IModelMetaFieldOther | IModelMetaEnumerationField | IModelMetaRelationField);
+
+export interface IModelMetaEnumerationOption {
+  key: string;
+  label: string;
+}
+
+export interface IModelMetaEnumerationField {
+  fieldType: 'enumeration';
+  options: IModelMetaEnumerationOption[];
+}
+
+export interface IModelMetaRelationFieldCommon {
+  fieldType: 'relation';
+}
+
+export interface IModelMetaRelationEnumerationField {
+  relationType: 'enumeration';
+  relationKey: string;
+  relationEntityLabel: string;
+  relationEntityKey: string;
+}
+
+export type IModelMetaRelationField = IModelMetaRelationFieldCommon & (
+  IModelMetaRelationEnumerationField
+);
+
+export interface IModelMeta {
+  defaultFilterField: string;
+  defaultSort: IModelMetaDefaultSort;
+  fields: { [key: string]: IModelMetaField };
+}
diff --git a/packages/server/src/interfaces/Options.ts b/packages/server/src/interfaces/Options.ts
new file mode 100644
index 000000000..51a4e7834
--- /dev/null
+++ b/packages/server/src/interfaces/Options.ts
@@ -0,0 +1,11 @@
+
+
+export interface IOptionDTO {
+  key: string,
+  value: string|number,
+  group: string,
+};
+
+export interface IOptionsDTO {
+  options: IOptionDTO[],
+};
\ No newline at end of file
diff --git a/packages/server/src/interfaces/Payment.ts b/packages/server/src/interfaces/Payment.ts
new file mode 100644
index 000000000..4d5317319
--- /dev/null
+++ b/packages/server/src/interfaces/Payment.ts
@@ -0,0 +1,20 @@
+
+
+export interface IPaymentModel {}
+
+export interface ILicensePaymentModel extends IPaymentModel {
+  licenseCode: string;
+}
+
+export interface IPaymentMethod {
+  makePayment(paymentModel: IPaymentModel): Promise<boolean>;
+}
+
+export interface ILicensePaymentMethod {
+  makePayment(paymentModel: ILicensePaymentModel): Promise<boolean>;
+}
+
+export interface IPaymentContext<PaymentModel> {
+  paymentMethod: IPaymentMethod;
+  makePayment(paymentModel: PaymentModel): Promise<boolean>;
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/PaymentReceive.ts b/packages/server/src/interfaces/PaymentReceive.ts
new file mode 100644
index 000000000..658113fb3
--- /dev/null
+++ b/packages/server/src/interfaces/PaymentReceive.ts
@@ -0,0 +1,168 @@
+import { ISystemUser } from '@/interfaces';
+import { Knex } from 'knex';
+import { pick } from 'lodash';
+import { ILedgerEntry } from './Ledger';
+import { ISaleInvoice } from './SaleInvoice';
+
+export interface IPaymentReceive {
+  id?: number;
+  customerId: number;
+  paymentDate: Date;
+  amount: number;
+  currencyCode: string;
+  exchangeRate: number;
+  referenceNo: string;
+  depositAccountId: number;
+  paymentReceiveNo: string;
+  statement: string;
+  entries: IPaymentReceiveEntry[];
+  userId: number;
+  createdAt: Date;
+  updatedAt: Date;
+  localAmount?: number;
+  branchId?: number
+}
+export interface IPaymentReceiveCreateDTO {
+  customerId: number;
+  paymentDate: Date;
+  amount: number;
+  exchangeRate: number;
+  referenceNo: string;
+  depositAccountId: number;
+  paymentReceiveNo?: string;
+  statement: string;
+  entries: IPaymentReceiveEntryDTO[];
+
+  branchId?: number;
+}
+
+export interface IPaymentReceiveEditDTO {
+  customerId: number;
+  paymentDate: Date;
+  amount: number;
+  exchangeRate: number;
+  referenceNo: string;
+  depositAccountId: number;
+  paymentReceiveNo?: string;
+  statement: string;
+  entries: IPaymentReceiveEntryDTO[];
+  branchId?: number;
+}
+
+export interface IPaymentReceiveEntry {
+  id?: number;
+  paymentReceiveId: number;
+  invoiceId: number;
+  paymentAmount: number;
+
+  invoice?: ISaleInvoice;
+}
+
+export interface IPaymentReceiveEntryDTO {
+  id?: number;
+  index: number;
+  paymentReceiveId: number;
+  invoiceId: number;
+  paymentAmount: number;
+}
+
+export interface IPaymentReceivesFilter extends IDynamicListFilterDTO {
+  stringifiedFilterRoles?: string;
+}
+
+export interface IPaymentReceivePageEntry {
+  invoiceId: number;
+  entryType: string;
+  invoiceNo: string;
+  dueAmount: number;
+  amount: number;
+  totalPaymentAmount: number;
+  paymentAmount: number;
+  currencyCode: string;
+  date: Date | string;
+}
+
+export interface IPaymentReceiveEditPage {
+  paymentReceive: IPaymentReceive;
+  entries: IPaymentReceivePageEntry[];
+}
+
+export interface IPaymentsReceiveService {
+  validateCustomerHasNoPayments(
+    tenantId: number,
+    customerId: number
+  ): Promise<void>;
+}
+
+export interface IPaymentReceiveSmsDetails {
+  customerName: string;
+  customerPhoneNumber: string;
+  smsMessage: string;
+}
+
+export interface IPaymentReceiveCreatingPayload {
+  tenantId: number;
+  paymentReceiveDTO: IPaymentReceiveCreateDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IPaymentReceiveCreatedPayload {
+  tenantId: number;
+  paymentReceive: IPaymentReceive;
+  paymentReceiveId: number;
+  authorizedUser: ISystemUser;
+  trx: Knex.Transaction;
+}
+
+export interface IPaymentReceiveEditedPayload {
+  tenantId: number;
+  paymentReceiveId: number;
+  paymentReceive: IPaymentReceive;
+  oldPaymentReceive: IPaymentReceive;
+  authorizedUser: ISystemUser;
+  trx: Knex.Transaction;
+}
+
+export interface IPaymentReceiveEditingPayload {
+  tenantId: number;
+  oldPaymentReceive: IPaymentReceive;
+  paymentReceiveDTO: IPaymentReceiveEditDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IPaymentReceiveDeletingPayload {
+  tenantId: number;
+  oldPaymentReceive: IPaymentReceive;
+  trx: Knex.Transaction;
+}
+export interface IPaymentReceiveDeletedPayload {
+  tenantId: number;
+  paymentReceiveId: number;
+  oldPaymentReceive: IPaymentReceive;
+  authorizedUser: ISystemUser;
+  trx: Knex.Transaction;
+}
+
+export enum PaymentReceiveAction {
+  Create = 'Create',
+  Edit = 'Edit',
+  Delete = 'Delete',
+  View = 'View',
+  NotifyBySms = 'NotifyBySms',
+}
+
+export type IPaymentReceiveGLCommonEntry = Pick<
+  ILedgerEntry,
+  | 'debit'
+  | 'credit'
+  | 'currencyCode'
+  | 'exchangeRate'
+  | 'transactionId'
+  | 'transactionType'
+  | 'transactionNumber'
+  | 'referenceNumber'
+  | 'date'
+  | 'userId'
+  | 'createdAt'
+  | 'branchId'
+>;
diff --git a/packages/server/src/interfaces/Preferences.ts b/packages/server/src/interfaces/Preferences.ts
new file mode 100644
index 000000000..0017d6458
--- /dev/null
+++ b/packages/server/src/interfaces/Preferences.ts
@@ -0,0 +1,6 @@
+
+
+
+export enum PreferencesAction {
+  Mutate = 'Mutate'
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/ProfitLossSheet.ts b/packages/server/src/interfaces/ProfitLossSheet.ts
new file mode 100644
index 000000000..4f2eec656
--- /dev/null
+++ b/packages/server/src/interfaces/ProfitLossSheet.ts
@@ -0,0 +1,179 @@
+import {
+  IFinancialSheetBranchesQuery,
+  INumberFormatQuery,
+} from './FinancialStatements';
+
+export enum ProfitLossAggregateNodeId {
+  INCOME = 'INCOME',
+  COS = 'COST_OF_SALES',
+  GROSS_PROFIT = 'GROSS_PROFIT',
+  EXPENSES = 'EXPENSES',
+  OTHER_INCOME = 'OTHER_INCOME',
+  OTHER_EXPENSES = 'OTHER_EXPENSES',
+  OPERATING_PROFIT = 'OPERATING_PROFIT',
+  NET_OTHER_INCOME = 'NET_OTHER_INCOME',
+  NET_INCOME = 'NET_INCOME',
+  NET_OPERATING_INCOME = 'NET_OPERATING_INCOME',
+}
+
+export enum ProfitLossNodeType {
+  EQUATION = 'EQUATION',
+  ACCOUNTS = 'ACCOUNTS',
+  ACCOUNT = 'ACCOUNT',
+  AGGREGATE = 'AGGREGATE',
+}
+interface FinancialDateMeta {
+  date: Date;
+  formattedDate: string;
+}
+export interface IFinancialNodeWithPreviousPeriod {
+  previousPeriodFromDate?: FinancialDateMeta;
+  previousPeriodToDate?: FinancialDateMeta;
+
+  previousPeriod?: IProfitLossSheetTotal;
+  previousPeriodChange?: IProfitLossSheetTotal;
+  previousPeriodPercentage?: IProfitLossSheetPercentage;
+}
+export interface IFinancialNodeWithPreviousYear {
+  previousYearFromDate: FinancialDateMeta;
+  previousYearToDate: FinancialDateMeta;
+
+  previousYear?: IProfitLossSheetTotal;
+  previousYearChange?: IProfitLossSheetTotal;
+  previousYearPercentage?: IProfitLossSheetPercentage;
+}
+export interface IFinancialCommonNode {
+  total: IProfitLossSheetTotal;
+}
+export interface IFinancialCommonHorizDatePeriodNode {
+  fromDate: FinancialDateMeta;
+  toDate: FinancialDateMeta;
+  total: IProfitLossSheetTotal;
+}
+export interface IProfitLossSheetQuery extends IFinancialSheetBranchesQuery {
+  basis: string;
+  fromDate: Date;
+  toDate: Date;
+  numberFormat: INumberFormatQuery;
+  noneZero: boolean;
+  noneTransactions: boolean;
+  accountsIds: number[];
+
+  displayColumnsType: 'total' | 'date_periods';
+  displayColumnsBy: string;
+
+  percentageColumn: boolean;
+  percentageRow: boolean;
+
+  percentageIncome: boolean;
+  percentageExpense: boolean;
+
+  previousPeriod: boolean;
+  previousPeriodAmountChange: boolean;
+  previousPeriodPercentageChange: boolean;
+
+  previousYear: boolean;
+  previousYearAmountChange: boolean;
+  previousYearPercentageChange: boolean;
+}
+
+export interface IProfitLossSheetTotal {
+  amount: number;
+  formattedAmount: string;
+  currencyCode: string;
+}
+
+export interface IProfitLossSheetPercentage {
+  amount: number;
+  formattedAmount: string;
+}
+
+export interface IProfitLossHorizontalDatePeriodNode
+  extends IFinancialNodeWithPreviousYear,
+    IFinancialNodeWithPreviousPeriod {
+  fromDate: FinancialDateMeta;
+  toDate: FinancialDateMeta;
+
+  total: IProfitLossSheetTotal;
+
+  percentageRow?: IProfitLossSheetPercentage;
+  percentageColumn?: IProfitLossSheetPercentage;
+}
+
+export interface IProfitLossSheetCommonNode
+  extends IFinancialNodeWithPreviousYear,
+    IFinancialNodeWithPreviousPeriod {
+  id: ProfitLossAggregateNodeId;
+  name: string;
+
+  children?: IProfitLossSheetNode[];
+
+  total: IProfitLossSheetTotal;
+  horizontalTotals?: IProfitLossHorizontalDatePeriodNode[];
+
+  percentageRow?: IProfitLossSheetPercentage;
+  percentageColumn?: IProfitLossSheetPercentage;
+}
+export interface IProfitLossSheetAccountNode
+  extends IProfitLossSheetCommonNode {
+  nodeType: ProfitLossNodeType.ACCOUNT;
+}
+export interface IProfitLossSheetEquationNode
+  extends IProfitLossSheetCommonNode {
+  nodeType: ProfitLossNodeType.EQUATION;
+}
+
+export interface IProfitLossSheetAccountsNode
+  extends IProfitLossSheetCommonNode {
+  nodeType: ProfitLossNodeType.ACCOUNTS;
+}
+
+export type IProfitLossSheetNode =
+  | IProfitLossSheetAccountsNode
+  | IProfitLossSheetEquationNode
+  | IProfitLossSheetAccountNode;
+
+export interface IProfitLossSheetMeta {
+  isCostComputeRunning: boolean;
+  organizationName: string;
+  baseCurrency: string;
+}
+
+// ------------------------------------------------
+// # SCHEMA NODES
+// ------------------------------------------------
+export interface IProfitLossCommonSchemaNode {
+  id: ProfitLossAggregateNodeId;
+  name: string;
+  nodeType: ProfitLossNodeType;
+  children?: IProfitLossSchemaNode[];
+  alwaysShow?: boolean;
+}
+
+export interface IProfitLossEquationSchemaNode
+  extends IProfitLossCommonSchemaNode {
+  nodeType: ProfitLossNodeType.EQUATION;
+  equation: string;
+}
+
+export interface IProfitLossAccountsSchemaNode
+  extends IProfitLossCommonSchemaNode {
+  nodeType: ProfitLossNodeType.ACCOUNTS;
+  accountsTypes: string[];
+}
+
+export type IProfitLossSchemaNode =
+  | IProfitLossCommonSchemaNode
+  | IProfitLossAccountsSchemaNode
+  | IProfitLossEquationSchemaNode;
+
+// ------------------------------
+// # Table
+// ------------------------------
+
+export enum ProfitLossSheetRowType {
+  AGGREGATE = 'AGGREGATE',
+  ACCOUNTS = 'ACCOUNTS',
+  ACCOUNT = 'ACCOUNT',
+  TOTAL = 'TOTAL',
+}
diff --git a/packages/server/src/interfaces/Project.ts b/packages/server/src/interfaces/Project.ts
new file mode 100644
index 000000000..231eb69a7
--- /dev/null
+++ b/packages/server/src/interfaces/Project.ts
@@ -0,0 +1,160 @@
+import { Knex } from 'knex';
+
+export interface IProjectCommonDTO {
+  contactId: number;
+  name: string;
+  deadline: Date;
+  costEstimate: number;
+}
+
+export interface IProject {
+  id?: number;
+  name: string;
+  contactId: number;
+  deadline: number;
+  costEstimate: number;
+  status: string;
+}
+
+export interface IProjectCreateDTO extends IProjectCommonDTO {}
+export interface IProjectEditDTO extends IProjectCommonDTO {}
+
+export interface IProjectCreatePOJO extends IProject {}
+export interface IProjectEditPOJO extends IProject {}
+
+export interface IProjectGetPOJO {
+  costEstimate: number;
+  costEstimateFormatted: string;
+
+  deadlineFormatted: string;
+  contactDisplayName: string;
+  statusFormatted: string;
+
+  totalActualHours: number;
+  totalEstimateHours: number;
+  totalInvoicedHours: number;
+  totalBillableHours: number;
+
+  totalActualHoursAmount: number;
+  totalActualHoursAmountFormatted: string;
+
+  totalEstimateHoursAmount: number;
+  totalEstimateHoursAmountFormatted: string;
+
+  totalInvoicedHoursAmount: number;
+  totalInvoicedHoursAmountFormatted: string;
+
+  totalBillableHoursAmount: number;
+  totalBillableHoursAmountFormatted: string;
+
+  totalExpenses: number;
+  totalExpensesFormatted: string;
+
+  totalInvoicedExpenses: number;
+  totalInvoicedExpensesFormatted: string;
+
+  totalBillableExpenses: number;
+  totalBillableExpensesFormatted: string;
+
+  totalInvoiced: number;
+  totalInvoicedFormatted: string;
+
+  totalBillable: number;
+  totalBillableFormatted: string;
+}
+
+export interface IProjectCreateEventPayload {
+  tenantId: number;
+  projectDTO: IProjectCreateDTO;
+}
+
+export interface IProjectCreatedEventPayload {
+  tenantId: number;
+  projectDTO: IProjectCreateDTO;
+  project: IProject;
+  trx: Knex.Transaction;
+}
+
+export interface IProjectCreatingEventPayload {
+  tenantId: number;
+  projectDTO: IProjectCreateDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IProjectDeleteEventPayload {
+  tenantId: number;
+  projectId: number;
+}
+
+export interface IProjectDeletingEventPayload {
+  tenantId: number;
+  oldProject: IProject;
+  trx: Knex.Transaction;
+}
+
+export interface IProjectDeletedEventPayload
+  extends IProjectDeletingEventPayload {}
+
+export interface IProjectEditEventPayload {
+  tenantId: number;
+  oldProject: IProject;
+  projectDTO: IProjectEditDTO;
+}
+export interface IProjectEditingEventPayload {
+  tenantId: number;
+  oldProject: IProject;
+  projectDTO: IProjectEditDTO;
+  trx: Knex.Transaction;
+}
+export interface IProjectEditedEventPayload {
+  tenantId: number;
+  project: IProject;
+  oldProject: IProject;
+  projectDTO: IProjectEditDTO;
+  trx: Knex.Transaction;
+}
+
+export enum IProjectStatus {
+  Closed = 'Closed',
+  InProgress = 'InProgress',
+}
+
+export interface ProjectBillableEntriesQuery {
+  toDate?: Date;
+  billableType?: ProjectBillableType[];
+}
+
+export interface ProjectBillableEntry {
+  billableType: string;
+  billableId: number;
+  billableAmount: number;
+  billableCurrency: string;
+  billableTransactionNo: string;
+}
+
+export enum ProjectBillableType {
+  Task = 'Task',
+  Expense = 'Expense',
+  Bill = 'Bill',
+}
+
+export enum ProjectAction {
+  CREATE = 'Create',
+  EDIT = 'Edit',
+  DELETE = 'Delete',
+  VIEW = 'View',
+}
+
+export enum ProjectTaskAction {
+  CREATE = 'Create',
+  EDIT = 'Edit',
+  DELETE = 'Delete',
+  VIEW = 'View',
+}
+
+export enum ProjectTimeAction {
+  CREATE = 'Create',
+  EDIT = 'Edit',
+  DELETE = 'Delete',
+  VIEW = 'View',
+}
diff --git a/packages/server/src/interfaces/ProjectProfitabilitySummary.ts b/packages/server/src/interfaces/ProjectProfitabilitySummary.ts
new file mode 100644
index 000000000..ed213a2c5
--- /dev/null
+++ b/packages/server/src/interfaces/ProjectProfitabilitySummary.ts
@@ -0,0 +1,54 @@
+export class ProjectProfitabilitySummaryQuery {
+  fromDate: Date;
+  toDate: Date;
+  projectsIds?: number[];
+}
+
+export interface IProjectProfitabilitySummaryTotal {
+  amount: number;
+  formattedAmount: string;
+  currencyCode: string;
+}
+
+export interface IProjectProfitabilitySummaryProjectNode {
+  projectId: number;
+  projectName: string;
+  projectStatus: any;
+
+  customerName: string;
+  customerId: number;
+
+  income: IProjectProfitabilitySummaryTotal;
+  expenses: IProjectProfitabilitySummaryTotal;
+
+  profit: IProjectProfitabilitySummaryTotal;
+}
+
+export interface IProjectProfitabilitySummaryTotalNode {
+  income: IProjectProfitabilitySummaryTotal;
+  expenses: IProjectProfitabilitySummaryTotal;
+
+  profit: IProjectProfitabilitySummaryTotal;
+}
+
+export interface IProjectProfitabilitySummaryData {
+  projects: IProjectProfitabilitySummaryProjectNode[];
+  total: IProjectProfitabilitySummaryTotalNode;
+}
+
+export interface IProjectProfitabilitySummaryMeta {
+  organizationName: string;
+  baseCurrency: string;
+}
+
+export interface IProjectProfitabilitySummaryPOJO {
+  data: IProjectProfitabilitySummaryData;
+  query: ProjectProfitabilitySummaryQuery;
+  meta: IProjectProfitabilitySummaryMeta;
+}
+
+
+export enum IProjectProfitabilitySummaryRowType {
+  TOTAL = 'TOTAL',
+  PROJECT = 'PROJECT'
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/Resource.ts b/packages/server/src/interfaces/Resource.ts
new file mode 100644
index 000000000..d193a94c7
--- /dev/null
+++ b/packages/server/src/interfaces/Resource.ts
@@ -0,0 +1,22 @@
+
+
+export interface IResource {
+  id: number,
+  key: string,
+}
+
+export interface IResourceField {
+  labelName: string,
+  key: string,
+  dataType: string,
+  helpText?: string | null,
+  default?: string,
+  predefined: boolean,
+  active: boolean,
+  builtin: boolean,
+  columnable: boolean,
+  index: number,
+  dataResource: string,
+  resourceId: number,
+  options: any;
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/Roles.ts b/packages/server/src/interfaces/Roles.ts
new file mode 100644
index 000000000..cfa7276ad
--- /dev/null
+++ b/packages/server/src/interfaces/Roles.ts
@@ -0,0 +1,121 @@
+import { Ability, RawRuleOf, ForcedSubject } from '@casl/ability';
+import Knex from 'knex';
+
+export const actions = [
+  'manage',
+  'create',
+  'read',
+  'update',
+  'delete',
+] as const;
+export const subjects = ['Article', 'all'] as const;
+
+export type Abilities = [
+  typeof actions[number],
+  (
+    | typeof subjects[number]
+    | ForcedSubject<Exclude<typeof subjects[number], 'all'>>
+  )
+];
+
+export type AppAbility = Ability<Abilities>;
+
+export const createAbility = (rules: RawRuleOf<AppAbility>[]) =>
+  new Ability<Abilities>(rules);
+
+export interface IRoleDTO {
+  roleName: string;
+  roleDescription: string;
+  permissions: ICreateRolePermissionDTO[];
+}
+
+export interface IEditRoleDTO extends IRoleDTO {
+  permissions: IEditRolePermissionDTO[];
+}
+
+export interface IRolePermissionDTO {
+  subject: string;
+  ability: string;
+  value: boolean;
+}
+
+export interface ICreateRolePermissionDTO extends IRolePermissionDTO {}
+export interface IEditRolePermissionDTO extends IRolePermissionDTO {
+  permissionId: number;
+}
+
+export interface ICreateRoleDTO extends IRoleDTO {}
+
+export interface ISubjectAbilitySchema {
+  key: string;
+  label: string;
+  default?: boolean;
+}
+
+export interface ISubjectAbilitiesSchema {
+  subject: string;
+  subjectLabel: string;
+  description?: string;
+  abilities?: ISubjectAbilitySchema[];
+  extraAbilities?: ISubjectAbilitySchema[];
+}
+
+export interface IRole {
+  id?: number;
+  name: string;
+  slug: string;
+  description: string;
+  predefined: boolean;
+  permissions?: IRolePremission[];
+}
+
+export interface IRolePremission {
+  id?: number;
+  roleId?: number;
+  subject: string;
+  ability: string;
+  value: boolean;
+}
+
+export enum AbilitySubject {
+  Item = 'Item',
+  InventoryAdjustment = 'InventoryAdjustment',
+  Report = 'Report',
+  Account = 'Account',
+  SaleInvoice = 'SaleInvoice',
+  SaleEstimate = 'SaleEstimate',
+  SaleReceipt = 'SaleReceipt',
+  PaymentReceive = 'PaymentReceive',
+  Bill = 'Bill',
+  PaymentMade = 'PaymentMade',
+  Expense = 'Expense',
+  Customer = 'Customer',
+  Vendor = 'Vendor',
+  Cashflow = 'Cashflow',
+  ManualJournal = 'ManualJournal',
+  Preferences = 'Preferences',
+  CreditNote = 'CreditNode',
+  VendorCredit = 'VendorCredit',
+  Project = 'Project'
+}
+
+export interface IRoleCreatedPayload {
+  tenantId: number;
+  createRoleDTO: ICreateRoleDTO;
+  role: IRole;
+  trx: Knex.Transaction;
+}
+
+export interface IRoleEditedPayload {
+  editRoleDTO: IEditRoleDTO;
+  oldRole: IRole;
+  role: IRole;
+  trx: Knex.Transaction;
+}
+
+export interface IRoleDeletedPayload {
+  oldRole: IRole;
+  roleId: number;
+  tenantId: number;
+  trx: Knex.Transaction;
+}
diff --git a/packages/server/src/interfaces/SaleEstimate.ts b/packages/server/src/interfaces/SaleEstimate.ts
new file mode 100644
index 000000000..92385c046
--- /dev/null
+++ b/packages/server/src/interfaces/SaleEstimate.ts
@@ -0,0 +1,126 @@
+import { Knex } from 'knex';
+import { IItemEntry } from './ItemEntry';
+import { IDynamicListFilterDTO } from '@/interfaces/DynamicFilter';
+
+export interface ISaleEstimate {
+  id?: number;
+  amount: number;
+  currencyCode: string;
+  customerId: number;
+  estimateDate: Date;
+  estimateNumber: string;
+  reference: string;
+  note: string;
+  termsConditions: string;
+  userId: number;
+  entries: IItemEntry[];
+  sendToEmail: string;
+  createdAt?: Date;
+  deliveredAt: string | Date;
+  isConvertedToInvoice: boolean;
+  isDelivered: boolean;
+
+  branchId?: number;
+  warehouseId?: number;
+}
+export interface ISaleEstimateDTO {
+  customerId: number;
+  exchangeRate?: number;
+  estimateDate?: Date;
+  reference?: string;
+  estimateNumber?: string;
+  entries: IItemEntry[];
+  note: string;
+  termsConditions: string;
+  sendToEmail: string;
+  delivered: boolean;
+
+  branchId?: number;
+  warehouseId?: number;
+}
+
+export interface ISalesEstimatesFilter extends IDynamicListFilterDTO {
+  stringifiedFilterRoles?: string;
+}
+
+export interface ISalesEstimatesService {
+  validateCustomerHasNoEstimates(
+    tenantId: number,
+    customerId: number
+  ): Promise<void>;
+}
+
+export interface ISaleEstimateCreatedPayload {
+  tenantId: number;
+  saleEstimate: ISaleEstimate;
+  saleEstimateId: number;
+  saleEstimateDTO: ISaleEstimateDTO;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleEstimateCreatingPayload {
+  estimateDTO: ISaleEstimateDTO;
+  tenantId: number;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleEstimateEditedPayload {
+  tenantId: number;
+  estimateId: number;
+  saleEstimate: ISaleEstimate;
+  oldSaleEstimate: ISaleEstimate;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleEstimateEditingPayload {
+  tenantId: number;
+  oldSaleEstimate: ISaleEstimate;
+  estimateDTO: ISaleEstimateDTO;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleEstimateDeletedPayload {
+  tenantId: number;
+  saleEstimateId: number;
+  oldSaleEstimate: ISaleEstimate;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleEstimateDeletingPayload {
+  tenantId: number;
+  oldSaleEstimate: ISaleEstimate;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleEstimateEventDeliveredPayload {
+  tenantId: number;
+  saleEstimate: ISaleEstimate;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleEstimateEventDeliveringPayload {
+  tenantId: number;
+  oldSaleEstimate: ISaleEstimate;
+  trx: Knex.Transaction;
+}
+
+export enum SaleEstimateAction {
+  Create = 'Create',
+  Edit = 'Edit',
+  Delete = 'Delete',
+  View = 'View',
+  NotifyBySms = 'NotifyBySms',
+}
+
+export interface ISaleEstimateApprovingEvent {
+  tenantId: number;
+  oldSaleEstimate: ISaleEstimate;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleEstimateApprovedEvent {
+  tenantId: number;
+  oldSaleEstimate: ISaleEstimate;
+  saleEstimate: ISaleEstimate;
+  trx: Knex.Transaction;
+}
diff --git a/packages/server/src/interfaces/SaleInvoice.ts b/packages/server/src/interfaces/SaleInvoice.ts
new file mode 100644
index 000000000..5dc91b062
--- /dev/null
+++ b/packages/server/src/interfaces/SaleInvoice.ts
@@ -0,0 +1,174 @@
+import { Knex } from 'knex';
+import { ISystemUser, IAccount } from '@/interfaces';
+import { IDynamicListFilter } from '@/interfaces/DynamicFilter';
+import { IItemEntry, IItemEntryDTO } from './ItemEntry';
+
+export interface ISaleInvoice {
+  id: number;
+  balance: number;
+  paymentAmount: number;
+  currencyCode: string;
+  exchangeRate?: number;
+  invoiceDate: Date;
+  dueDate: Date;
+  dueAmount: number;
+  overdueDays: number;
+  customerId: number;
+  referenceNo: string;
+  invoiceNo: string;
+  isWrittenoff: boolean;
+  entries: IItemEntry[];
+  deliveredAt: string | Date;
+  userId: number;
+  createdAt: Date;
+  isDelivered: boolean;
+
+  warehouseId?: number;
+  branchId?: number;
+  projectId?: number;
+
+  localAmount?: number;
+
+  localWrittenoffAmount?: number;
+  writtenoffExpenseAccountId?: number;
+
+  writtenoffExpenseAccount?: IAccount;
+}
+
+export interface ISaleInvoiceDTO {
+  invoiceDate: Date;
+  dueDate: Date;
+  referenceNo: string;
+  invoiceNo: string;
+  customerId: number;
+  exchangeRate?: number;
+  invoiceMessage: string;
+  termsConditions: string;
+  entries: IItemEntryDTO[];
+  delivered: boolean;
+
+  warehouseId?: number | null;
+  projectId?: number;
+  branchId?: number | null;
+}
+
+export interface ISaleInvoiceCreateDTO extends ISaleInvoiceDTO {
+  fromEstimateId: number;
+}
+
+export interface ISaleInvoiceEditDTO extends ISaleInvoiceDTO {}
+
+export interface ISalesInvoicesFilter extends IDynamicListFilter {
+  page: number;
+  pageSize: number;
+  searchKeyword?: string;
+}
+
+export interface ISalesInvoicesService {
+  validateCustomerHasNoInvoices(
+    tenantId: number,
+    customerId: number
+  ): Promise<void>;
+}
+
+export interface ISaleInvoiceWriteoffDTO {
+  expenseAccountId: number;
+  date: Date;
+  reason: string;
+}
+
+export type InvoiceNotificationType = 'details' | 'reminder';
+
+export interface ISaleInvoiceCreatedPayload {
+  tenantId: number;
+  saleInvoice: ISaleInvoice;
+  saleInvoiceDTO: ISaleInvoiceCreateDTO;
+  saleInvoiceId: number;
+  authorizedUser: ISystemUser;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleInvoiceCreatingPaylaod {
+  tenantId: number;
+  saleInvoiceDTO: ISaleInvoiceCreateDTO;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleInvoiceEditedPayload {
+  tenantId: number;
+  saleInvoice: ISaleInvoice;
+  oldSaleInvoice: ISaleInvoice;
+  saleInvoiceDTO: ISaleInvoiceEditDTO;
+  saleInvoiceId: number;
+  authorizedUser: ISystemUser;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleInvoiceEditingPayload {
+  tenantId: number;
+  oldSaleInvoice: ISaleInvoice;
+  saleInvoiceDTO: ISaleInvoiceEditDTO;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleInvoiceDeletePayload {
+  tenantId: number;
+  saleInvoice: ISaleInvoice;
+  saleInvoiceId: number;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleInvoiceDeletedPayload {
+  tenantId: number;
+  oldSaleInvoice: ISaleInvoice;
+  saleInvoiceId: number;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleInvoiceWriteoffCreatePayload {
+  tenantId: number;
+  saleInvoiceId: number;
+  saleInvoice: ISaleInvoice;
+  writeoffDTO: ISaleInvoiceWriteoffDTO;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleInvoiceWriteoffCreatedPayload {
+  tenantId: number;
+  saleInvoiceId: number;
+  saleInvoice: ISaleInvoice;
+  writeoffDTO: ISaleInvoiceCreatedPayload;
+}
+
+export interface ISaleInvoiceWrittenOffCancelPayload {
+  tenantId: number;
+  saleInvoice: ISaleInvoice;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleInvoiceWrittenOffCanceledPayload {
+  tenantId: number;
+  saleInvoice: ISaleInvoice;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleInvoiceEventDeliveredPayload {
+  tenantId: number;
+  saleInvoiceId: number;
+  saleInvoice: ISaleInvoice;
+}
+
+export interface ISaleInvoiceDeliveringPayload {
+  tenantId: number;
+  oldSaleInvoice: ISaleInvoice;
+  trx: Knex.Transaction;
+}
+
+export enum SaleInvoiceAction {
+  Create = 'Create',
+  Edit = 'Edit',
+  Delete = 'Delete',
+  View = 'View',
+  Writeoff = 'Writeoff',
+  NotifyBySms = 'NotifyBySms',
+}
diff --git a/packages/server/src/interfaces/SaleReceipt.ts b/packages/server/src/interfaces/SaleReceipt.ts
new file mode 100644
index 000000000..4d319ec4f
--- /dev/null
+++ b/packages/server/src/interfaces/SaleReceipt.ts
@@ -0,0 +1,136 @@
+import { Knex } from 'knex';
+import { IItemEntry } from './ItemEntry';
+
+export interface ISaleReceipt {
+  id?: number;
+  customerId: number;
+  depositAccountId: number;
+  receiptDate: Date;
+  sendToEmail: string;
+  referenceNo: string;
+  receiptMessage: string;
+  receiptNumber: string;
+  amount: number;
+  currencyCode: string;
+  exchangeRate: number;
+  statement: string;
+  closedAt: Date | string;
+
+  createdAt: Date;
+  updatedAt: Date;
+  userId: number;
+
+  branchId?: number;
+  warehouseId?: number;
+
+  localAmount?: number;
+  entries?: IItemEntry[];
+}
+
+export interface ISalesReceiptsFilter {}
+
+export interface ISaleReceiptDTO {
+  customerId: number;
+  exchangeRate?: number;
+  depositAccountId: number;
+  receiptDate: Date;
+  sendToEmail: string;
+  referenceNo?: string;
+  receiptNumber?: string;
+  receiptMessage: string;
+  statement: string;
+  closed: boolean;
+  entries: any[];
+  branchId?: number;
+}
+
+export interface ISalesReceiptsService {
+  createSaleReceipt(
+    tenantId: number,
+    saleReceiptDTO: ISaleReceiptDTO
+  ): Promise<void>;
+
+  editSaleReceipt(tenantId: number, saleReceiptId: number): Promise<void>;
+
+  deleteSaleReceipt(tenantId: number, saleReceiptId: number): Promise<void>;
+
+  salesReceiptsList(
+    tennatid: number,
+    salesReceiptsFilter: ISalesReceiptsFilter
+  ): Promise<{
+    salesReceipts: ISaleReceipt[];
+    pagination: IPaginationMeta;
+    filterMeta: IFilterMeta;
+  }>;
+
+  validateCustomerHasNoReceipts(
+    tenantId: number,
+    customerId: number
+  ): Promise<void>;
+}
+
+export interface ISaleReceiptSmsDetails {
+  customerName: string;
+  customerPhoneNumber: string;
+  smsMessage: string;
+}
+export interface ISaleReceiptCreatingPayload {
+  saleReceiptDTO: ISaleReceiptDTO;
+  tenantId: number;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleReceiptCreatedPayload {
+  tenantId: number;
+  saleReceipt: ISaleReceipt;
+  saleReceiptId: number;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleReceiptEditedPayload {
+  tenantId: number;
+  oldSaleReceipt: number;
+  saleReceipt: ISaleReceipt;
+  saleReceiptId: number;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleReceiptEditingPayload {
+  tenantId: number;
+  oldSaleReceipt: ISaleReceipt;
+  saleReceiptDTO: ISaleReceiptDTO;
+  trx: Knex.Transaction;
+}
+export interface ISaleReceiptEventClosedPayload {
+  tenantId: number;
+  saleReceiptId: number;
+  saleReceipt: ISaleReceipt;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleReceiptEventClosingPayload {
+  tenantId: number;
+  oldSaleReceipt: ISaleReceipt;
+  trx: Knex.Transaction;
+}
+
+export interface ISaleReceiptEventDeletedPayload {
+  tenantId: number;
+  saleReceiptId: number;
+  oldSaleReceipt: ISaleReceipt;
+  trx: Knex.Transaction;
+}
+
+export enum SaleReceiptAction {
+  Create = 'Create',
+  Edit = 'Edit',
+  Delete = 'Delete',
+  View = 'View',
+  NotifyBySms = 'NotifyBySms',
+}
+
+export interface ISaleReceiptDeletingPayload {
+  tenantId: number;
+  oldSaleReceipt: ISaleReceipt;
+  trx: Knex.Transaction;
+}
diff --git a/packages/server/src/interfaces/SalesByItemsSheet.ts b/packages/server/src/interfaces/SalesByItemsSheet.ts
new file mode 100644
index 000000000..0e0a41f9e
--- /dev/null
+++ b/packages/server/src/interfaces/SalesByItemsSheet.ts
@@ -0,0 +1,45 @@
+import {
+  INumberFormatQuery,
+} from './FinancialStatements';
+
+export interface ISalesByItemsReportQuery {
+  fromDate: Date | string;
+  toDate: Date | string;
+  itemsIds: number[],
+  numberFormat: INumberFormatQuery;
+  noneTransactions: boolean;
+  onlyActive: boolean; 
+};
+
+export interface ISalesByItemsSheetMeta {
+  organizationName: string,
+  baseCurrency: string,
+};
+
+export interface ISalesByItemsItem {
+  id: number,
+  name: string,
+  code: string,
+  quantitySold: number,
+  soldCost: number,
+  averageSellPrice: number,
+
+  quantitySoldFormatted: string,
+  soldCostFormatted: string,
+  averageSellPriceFormatted: string,
+  currencyCode: string,
+};
+
+export interface ISalesByItemsTotal {
+  quantitySold: number,
+  soldCost: number,
+  quantitySoldFormatted: string,
+  soldCostFormatted: string,
+  currencyCode: string,
+};
+
+export type ISalesByItemsSheetStatement = {
+  items: ISalesByItemsItem[],
+  total: ISalesByItemsTotal
+} | {};
+
diff --git a/packages/server/src/interfaces/Setup.ts b/packages/server/src/interfaces/Setup.ts
new file mode 100644
index 000000000..2a0562238
--- /dev/null
+++ b/packages/server/src/interfaces/Setup.ts
@@ -0,0 +1,34 @@
+import { ISystemUser } from '@/interfaces';
+
+export interface IOrganizationSetupDTO {
+  organizationName: string;
+  baseCurrency: string;
+  fiscalYear: string;
+  industry: string;
+  timeZone: string;
+}
+
+export interface IOrganizationBuildDTO {
+  name: string;
+  industry: string;
+  location: string;
+  baseCurrency: string;
+  timezone: string;
+  fiscalYear: string;
+  dateFormat?: string;
+}
+
+export interface IOrganizationUpdateDTO {
+  name: string;
+  location: string;
+  baseCurrency: string;
+  timezone: string;
+  fiscalYear: string;
+  industry: string;
+}
+
+export interface IOrganizationBuildEventPayload {
+  tenantId: number;
+  buildDTO: IOrganizationBuildDTO;
+  systemUser: ISystemUser;
+}
diff --git a/packages/server/src/interfaces/SmsNotifications.ts b/packages/server/src/interfaces/SmsNotifications.ts
new file mode 100644
index 000000000..2649f0deb
--- /dev/null
+++ b/packages/server/src/interfaces/SmsNotifications.ts
@@ -0,0 +1,51 @@
+export interface ISmsNotificationAllowedVariable {
+  variable: string;
+  description: string;
+}
+export interface ISmsNotificationDefined {
+  notificationLabel: string;
+  notificationDescription: string;
+  key: string;
+  module: string;
+  moduleFormatted: string;
+  allowedVariables: ISmsNotificationAllowedVariable[];
+
+  defaultSmsMessage: string;
+  defaultIsNotificationEnabled: boolean;
+}
+
+export interface ISmsNotificationMeta {
+  notificationLabel: string;
+  notificationDescription: string;
+  key: string;
+  module: string;
+  moduleFormatted: string;
+  allowedVariables: ISmsNotificationAllowedVariable[];
+  smsMessage: string;
+  isNotificationEnabled: boolean;
+}
+
+export interface IEditSmsNotificationDTO {
+  notificationKey: string;
+  messageText: string;
+  isNotificationEnabled: boolean;
+}
+
+export interface ISaleInvoiceSmsDetailsDTO {
+  notificationKey: 'details' | 'reminder';
+}
+
+export interface ISaleInvoiceSmsDetails {
+  customerName: string;
+  customerPhoneNumber: string;
+  smsMessage: string;
+}
+
+export enum SMS_NOTIFICATION_KEY {
+  SALE_INVOICE_DETAILS = 'sale-invoice-details',
+  SALE_INVOICE_REMINDER = 'sale-invoice-reminder',
+  SALE_ESTIMATE_DETAILS = 'sale-estimate-details',
+  SALE_RECEIPT_DETAILS = 'sale-receipt-details',
+  PAYMENT_RECEIVE_DETAILS = 'payment-receive-details',
+  CUSTOMER_BALANCE = 'customer-balance',
+}
diff --git a/packages/server/src/interfaces/Table.ts b/packages/server/src/interfaces/Table.ts
new file mode 100644
index 000000000..28ff72f5c
--- /dev/null
+++ b/packages/server/src/interfaces/Table.ts
@@ -0,0 +1,31 @@
+export interface IColumnMapperMeta {
+  key: string;
+  accessor?: string;
+  value?: string;
+}
+
+export interface ITableCell {
+  value: string;
+  key: string;
+}
+
+export type ITableRow = {
+  rows: ITableCell[];
+};
+
+export interface ITableColumn {
+  key: string;
+  label: string;
+  cellIndex?: number;
+  children?: ITableColumn[];
+}
+
+export interface ITable {
+  columns: ITableColumn[];
+  data: ITableRow[];
+}
+
+export interface ITableColumnAccessor {
+  key: string;
+  accessor: string;
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/Tasks.ts b/packages/server/src/interfaces/Tasks.ts
new file mode 100644
index 000000000..c3b3fc70e
--- /dev/null
+++ b/packages/server/src/interfaces/Tasks.ts
@@ -0,0 +1,78 @@
+import { Knex } from 'knex';
+import { ProjectTaskChargeType } from '@/services/Projects/Tasks/constants';
+
+export interface IProjectTask {
+  id?: number;
+  name: string;
+  chargeType: string;
+  estimateHours: number;
+  actualHours: number;
+  invoicedHours: number;
+  billableHours: number;
+  projectId: number;
+
+  billableAmount?: number;
+  createdAt?: Date|string;
+}
+
+export interface BaseTaskDTO {
+  name: string;
+  rate: number;
+  chargeType: ProjectTaskChargeType;
+  estimateHours: number;
+}
+export interface ICreateTaskDTO extends BaseTaskDTO {}
+export interface IEditTaskDTO extends BaseTaskDTO {}
+
+export interface IProjectTaskCreatePOJO extends IProjectTask {}
+export interface IProjectTaskEditPOJO extends IProjectTask {}
+export interface IProjectTaskGetPOJO extends IProjectTask {}
+
+export interface ITaskCreateEventPayload {
+  tenantId: number;
+  taskDTO: ICreateTaskDTO;
+}
+export interface ITaskCreatedEventPayload {
+  tenantId: number;
+  taskDTO: ICreateTaskDTO;
+  task: any;
+  trx: Knex.Transaction;
+}
+export interface ITaskCreatingEventPayload {
+  tenantId: number;
+  taskDTO: ICreateTaskDTO;
+  trx: Knex.Transaction;
+}
+export interface ITaskDeleteEventPayload {
+  tenantId: number;
+  taskId: number;
+}
+export interface ITaskDeletingEventPayload {
+  tenantId: number;
+  oldTask: IProjectTask;
+  trx: Knex.Transaction;
+}
+export interface ITaskDeletedEventPayload {
+  tenantId: number;
+  oldTask: IProjectTask;
+  task: IProjectTask;
+  trx: Knex.Transaction;
+}
+export interface ITaskEditEventPayload {
+  tenantId: number;
+  taskId: number;
+  taskDTO: IEditTaskDTO;
+}
+export interface ITaskEditingEventPayload {
+  tenantId: number;
+  oldTask: IProjectTask;
+  taskDTO: IEditTaskDTO;
+  trx: Knex.Transaction;
+}
+export interface ITaskEditedEventPayload {
+  tenantId: number;
+  oldTask: IProjectTask;
+  task: IProjectTask;
+  taskDTO: IEditTaskDTO;
+  trx: Knex.Transaction;
+}
diff --git a/packages/server/src/interfaces/Tenancy.ts b/packages/server/src/interfaces/Tenancy.ts
new file mode 100644
index 000000000..423812b55
--- /dev/null
+++ b/packages/server/src/interfaces/Tenancy.ts
@@ -0,0 +1,55 @@
+import { Knex } from 'knex';
+
+export interface ITenantMetadata {
+  currencyCode: string;
+}
+export interface ITenant {
+  id: number,
+  organizationId: string,
+
+  initializedAt: Date|null,
+  seededAt: Date|null,
+  builtAt: Date|null,
+  createdAt: Date|null,
+
+  metadata?: ITenantMetadata
+}
+
+export interface ITenantDBManager {
+  constructor();
+
+  databaseExists(tenant: ITenant): Promise<boolean>;
+  createDatabase(tenant: ITenant): Promise<void>;
+
+  migrate(tenant: ITenant): Promise<void>;
+  seed(tenant: ITenant): Promise<void>;
+
+  setupKnexInstance(tenant: ITenant): Knex;
+  getKnexInstance(tenantId: number): Knex;
+}
+
+export interface ITenantManager {
+  tenantDBManager: ITenantDBManager;
+  tenant: ITenant;
+
+  constructor(): void;
+
+  createTenant(): Promise<ITenant>;
+  createDatabase(tenant: ITenant): Promise<void>;
+  hasDatabase(tenant: ITenant): Promise<boolean>;
+
+  dropTenant(tenant: ITenant): Promise<void>;
+
+  migrateTenant(tenant: ITenant): Promise<void>;
+  seedTenant(tenant: ITenant): Promise<void>;
+
+  setupKnexInstance(tenant: ITenant): Knex;
+  getKnexInstance(tenantId: number): Knex;
+}
+
+export interface ISystemService {
+  cache();
+  repositories();
+  knex();
+  dbManager();
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/Times.ts b/packages/server/src/interfaces/Times.ts
new file mode 100644
index 000000000..2e9f44a5b
--- /dev/null
+++ b/packages/server/src/interfaces/Times.ts
@@ -0,0 +1,72 @@
+import { Knex } from 'knex';
+
+export interface IProjectTime {
+  id?: number;
+  duration: number;
+  description: string;
+  date: string | Date;
+  taskId: number;
+  projectId: number;
+}
+export interface BaseProjectTimeDTO {
+  name: string;
+  rate: number;
+  chargeType: string;
+  estimateHours: number;
+}
+export interface IProjectTimeCreateDTO extends BaseProjectTimeDTO {}
+export interface IProjectTimeEditDTO extends BaseProjectTimeDTO {}
+
+export interface IProjectTimeCreatePOJO extends IProjectTime {}
+export interface IProjectTimeEditPOJO extends IProjectTime{}
+export interface IProjectTimeGetPOJO extends IProjectTime{}
+
+export interface IProjectTimeCreateEventPayload {
+  tenantId: number;
+  timeDTO: IProjectTimeCreateDTO;
+}
+export interface IProjectTimeCreatedEventPayload {
+  tenantId: number;
+  timeDTO: IProjectTimeEditDTO;
+  time: any;
+  trx: Knex.Transaction;
+}
+export interface IProjectTimeCreatingEventPayload {
+  tenantId: number;
+  timeDTO: IProjectTimeEditDTO;
+  trx: Knex.Transaction;
+}
+export interface IProjectTimeDeleteEventPayload {
+  tenantId: number;
+  timeId: number;
+  trx?: Knex.Transaction;
+}
+export interface IProjectTimeDeletingEventPayload {
+  tenantId: number;
+  oldTime: IProjectTime;
+  trx: Knex.Transaction;
+}
+export interface IProjectTimeDeletedEventPayload {
+  tenantId: number;
+  oldTime: IProjectTime;
+  trx: Knex.Transaction;
+}
+export interface IProjectTimeEditEventPayload {
+  tenantId: number;
+  oldTime: IProjectTime;
+  timeDTO: IProjectTimeEditDTO;
+}
+export interface IProjectTimeEditingEventPayload {
+  tenantId: number;
+  oldTime: IProjectTime;
+  timeDTO: IProjectTimeEditDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IProjectTimeEditedEventPayload {
+  tenantId: number;
+  oldTime: IProjectTime;
+  time: IProjectTime;
+  timeDTO: IProjectTimeEditDTO;
+  trx: Knex.Transaction;
+}
diff --git a/packages/server/src/interfaces/TransactionsByContacts.ts b/packages/server/src/interfaces/TransactionsByContacts.ts
new file mode 100644
index 000000000..82a38002a
--- /dev/null
+++ b/packages/server/src/interfaces/TransactionsByContacts.ts
@@ -0,0 +1,33 @@
+import { INumberFormatQuery } from './FinancialStatements';
+
+export interface ITransactionsByContactsAmount {
+  amount: number;
+  formattedAmount: string;
+  currencyCode: string;
+}
+
+export interface ITransactionsByContactsTransaction {
+  date: string|Date,
+  credit: ITransactionsByContactsAmount;
+  debit: ITransactionsByContactsAmount;
+  accountName: string,
+  runningBalance: ITransactionsByContactsAmount;
+  currencyCode: string;
+  transactionType: string;
+  transactionNumber: string;
+  createdAt: string|Date,
+};
+
+export interface ITransactionsByContactsContact {
+  openingBalance: ITransactionsByContactsAmount,
+  closingBalance: ITransactionsByContactsAmount,
+  transactions: ITransactionsByContactsTransaction[],
+}
+
+export interface ITransactionsByContactsFilter {
+  fromDate: Date|string;
+  toDate: Date|string;
+  numberFormat: INumberFormatQuery;
+  noneTransactions: boolean;
+  noneZero: boolean;
+}
diff --git a/packages/server/src/interfaces/TransactionsByCustomers.ts b/packages/server/src/interfaces/TransactionsByCustomers.ts
new file mode 100644
index 000000000..fe2fbf5e2
--- /dev/null
+++ b/packages/server/src/interfaces/TransactionsByCustomers.ts
@@ -0,0 +1,36 @@
+import {
+  ITransactionsByContactsAmount,
+  ITransactionsByContactsTransaction,
+  ITransactionsByContactsFilter,
+} from './TransactionsByContacts';
+
+export interface ITransactionsByCustomersAmount
+  extends ITransactionsByContactsAmount {}
+
+export interface ITransactionsByCustomersTransaction
+  extends ITransactionsByContactsTransaction {}
+
+export interface ITransactionsByCustomersCustomer {
+  customerName: string;
+  openingBalance: ITransactionsByCustomersAmount;
+  closingBalance: ITransactionsByCustomersAmount;
+  transactions: ITransactionsByCustomersTransaction[];
+}
+
+export interface ITransactionsByCustomersFilter
+  extends ITransactionsByContactsFilter {
+  customersIds: number[];
+}
+
+export type ITransactionsByCustomersData = ITransactionsByCustomersCustomer[];
+
+export interface ITransactionsByCustomersStatement {
+  data: ITransactionsByCustomersData;
+}
+
+export interface ITransactionsByCustomersService {
+  transactionsByCustomers(
+    tenantId: number,
+    filter: ITransactionsByCustomersFilter
+  ): Promise<ITransactionsByCustomersStatement>;
+}
diff --git a/packages/server/src/interfaces/TransactionsByReference.ts b/packages/server/src/interfaces/TransactionsByReference.ts
new file mode 100644
index 000000000..214fbb09e
--- /dev/null
+++ b/packages/server/src/interfaces/TransactionsByReference.ts
@@ -0,0 +1,31 @@
+
+
+export interface ITransactionsByReferenceQuery {
+  referenceType: string;
+  referenceId: string;
+}
+
+export interface ITransactionsByReferenceAmount {
+    amount: number;
+    formattedAmount: string;
+    currencyCode: string;
+}
+
+export interface ITransactionsByReferenceTransaction{
+    credit: ITransactionsByReferenceAmount;
+    debit: ITransactionsByReferenceAmount;
+
+    contactType: string;
+    formattedContactType: string;
+
+    contactId: number;
+
+    referenceType: string;
+    formattedReferenceType: string;
+
+    referenceId: number;
+
+    accountName: string;
+    accountCode: string;
+    accountId: number;
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/TransactionsByVendors.ts b/packages/server/src/interfaces/TransactionsByVendors.ts
new file mode 100644
index 000000000..107c7662e
--- /dev/null
+++ b/packages/server/src/interfaces/TransactionsByVendors.ts
@@ -0,0 +1,36 @@
+import {
+  ITransactionsByContactsAmount,
+  ITransactionsByContactsTransaction,
+  ITransactionsByContactsFilter,
+} from './TransactionsByContacts';
+
+export interface ITransactionsByVendorsAmount
+  extends ITransactionsByContactsAmount {}
+
+export interface ITransactionsByVendorsTransaction
+  extends ITransactionsByContactsTransaction {}
+
+export interface ITransactionsByVendorsVendor {
+  vendorName: string;
+  openingBalance: ITransactionsByVendorsAmount;
+  closingBalance: ITransactionsByVendorsAmount;
+  transactions: ITransactionsByVendorsTransaction[];
+}
+
+export interface ITransactionsByVendorsFilter
+  extends ITransactionsByContactsFilter {
+  vendorsIds: number[];
+}
+
+export type ITransactionsByVendorsData = ITransactionsByVendorsVendor[];
+
+export interface ITransactionsByVendorsStatement {
+  data: ITransactionsByVendorsData;
+}
+
+export interface ITransactionsByVendorsService {
+  transactionsByVendors(
+    tenantId: number,
+    filter: ITransactionsByVendorsFilter
+  ): Promise<ITransactionsByVendorsStatement>;
+}
diff --git a/packages/server/src/interfaces/TransactionsLocking.ts b/packages/server/src/interfaces/TransactionsLocking.ts
new file mode 100644
index 000000000..9b57d9b23
--- /dev/null
+++ b/packages/server/src/interfaces/TransactionsLocking.ts
@@ -0,0 +1,71 @@
+export interface ITransactionsLockingAllDTO {
+  lockToDate: Date;
+  reason: string;
+}
+export interface ITransactionsLockingCashflowDTO {}
+export interface ITransactionsLockingSalesDTO {}
+export interface ITransactionsLockingPurchasesDTO {}
+
+export enum TransactionsLockingGroup {
+  All = 'all',
+  Sales = 'sales',
+  Purchases = 'purchases',
+  Financial = 'financial',
+}
+
+export enum TransactionsLockingType {
+  Partial = 'partial',
+  All = 'all',
+}
+
+export interface ITransactionsLockingPartialUnlocked {
+  tenantId: number;
+  module: TransactionsLockingGroup;
+  transactionLockingDTO: ITransactionsLockingAllDTO;
+}
+
+export interface ITransactionsLockingCanceled {
+  tenantId: number;
+  module: TransactionsLockingGroup;
+  cancelLockingDTO: ICancelTransactionsLockingDTO;
+}
+
+export interface ITransactionLockingPartiallyDTO {
+  unlockFromDate: Date;
+  unlockToDate: Date;
+  reason: string;
+}
+export interface ICancelTransactionsLockingDTO {
+  reason: string;
+}
+export interface ITransactionMeta {
+  isEnabled: boolean;
+  isPartialUnlock: boolean;
+  lockToDate: Date;
+  unlockFromDate: string;
+  unlockToDate: string;
+  lockReason: string;
+  unlockReason: string;
+  partialUnlockReason: string;
+}
+
+export interface ITransactionLockingMetaPOJO {
+  module: string;
+  formattedModule: string;
+  description: string;
+
+  formattedLockToDate: Date;
+  formattedUnlockFromDate: string;
+  formattedunlockToDate: string;
+}
+export interface ITransactionsLockingListPOJO {
+  lockingType: string;
+  all: ITransactionLockingMetaPOJO;
+  modules: ITransactionLockingMetaPOJO[];
+}
+
+export interface ITransactionsLockingSchema {
+  module: TransactionsLockingGroup;
+  formattedModule: string;
+  description: string;
+}
diff --git a/packages/server/src/interfaces/TrialBalanceSheet.ts b/packages/server/src/interfaces/TrialBalanceSheet.ts
new file mode 100644
index 000000000..bd6c19331
--- /dev/null
+++ b/packages/server/src/interfaces/TrialBalanceSheet.ts
@@ -0,0 +1,49 @@
+import { INumberFormatQuery } from './FinancialStatements';
+
+export interface ITrialBalanceSheetQuery {
+  fromDate: Date | string;
+  toDate: Date | string;
+  numberFormat: INumberFormatQuery;
+  basis: 'cash' | 'accural';
+  noneZero: boolean;
+  noneTransactions: boolean;
+  onlyActive: boolean;
+  accountIds: number[];
+  branchesIds?: number[];
+}
+
+export interface ITrialBalanceTotal {
+  credit: number;
+  debit: number;
+  balance: number;
+  currencyCode: string;
+
+  formattedCredit: string;
+  formattedDebit: string;
+  formattedBalance: string;
+}
+
+export interface ITrialBalanceSheetMeta {
+  isCostComputeRunning: boolean;
+  organizationName: string;
+  baseCurrency: string;
+}
+
+export interface ITrialBalanceAccount extends ITrialBalanceTotal {
+  id: number;
+  parentAccountId: number;
+  name: string;
+  code: string;
+  accountNormal: string;
+}
+
+export type ITrialBalanceSheetData = {
+  accounts: ITrialBalanceAccount[];
+  total: ITrialBalanceTotal;
+};
+
+export interface ITrialBalanceStatement {
+  data: ITrialBalanceSheetData;
+  query: ITrialBalanceSheetQuery;
+  meta: ITrialBalanceSheetMeta;
+}
diff --git a/packages/server/src/interfaces/User.ts b/packages/server/src/interfaces/User.ts
new file mode 100644
index 000000000..9782f1a91
--- /dev/null
+++ b/packages/server/src/interfaces/User.ts
@@ -0,0 +1,157 @@
+import { AnyObject } from '@casl/ability/dist/types/types';
+import { ITenant } from '@/interfaces';
+import { Model } from 'objection';
+
+export interface ISystemUser extends Model {
+  id: number;
+  firstName: string;
+  lastName: string;
+  active: boolean;
+  password: string;
+  email: string;
+  phoneNumber: string;
+
+  roleId: number;
+  tenantId: number;
+
+  inviteAcceptAt: Date;
+  lastLoginAt: Date;
+  deletedAt: Date;
+
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface ISystemUserDTO {
+  firstName: string;
+  lastName: string;
+  password: string;
+  phoneNumber: string;
+  active: boolean;
+  email: string;
+  roleId?: number;
+}
+
+export interface IEditUserDTO {
+  firstName: string;
+  lastName: string;
+  phoneNumber: string;
+  active: boolean;
+  email: string;
+  roleId: number;
+}
+
+export interface IInviteUserInput {
+  firstName: string;
+  lastName: string;
+  phoneNumber: string;
+  password: string;
+}
+export interface IUserInvite {
+  id: number;
+  email: string;
+  token: string;
+  tenantId: number;
+  userId: number;
+  createdAt?: Date;
+}
+
+export interface IInviteUserService {
+  acceptInvite(token: string, inviteUserInput: IInviteUserInput): Promise<void>;
+  resendInvite(
+    tenantId: number,
+    userId: number,
+    authorizedUser: ISystemUser
+  ): Promise<{
+    invite: IUserInvite;
+  }>;
+  sendInvite(
+    tenantId: number,
+    email: string,
+    authorizedUser: ISystemUser
+  ): Promise<{
+    invite: IUserInvite;
+  }>;
+  checkInvite(
+    token: string
+  ): Promise<{ inviteToken: IUserInvite; orgName: object }>;
+}
+
+export interface ITenantUser {}
+
+export interface ITenantUserEditedPayload {
+  tenantId: number;
+  userId: number;
+  editUserDTO: IEditUserDTO;
+  tenantUser: ITenantUser;
+  oldTenantUser: ITenantUser;
+}
+
+export interface ITenantUserActivatedPayload {
+  tenantId: number;
+  userId: number;
+  authorizedUser: ISystemUser;
+  tenantUser: ITenantUser;
+}
+
+export interface ITenantUserInactivatedPayload {
+  tenantId: number;
+  userId: number;
+  authorizedUser: ISystemUser;
+  tenantUser: ITenantUser;
+}
+
+export interface ITenantUserDeletedPayload {
+  tenantId: number;
+  userId: number;
+  tenantUser: ITenantUser;
+}
+
+export interface ITenantUser {
+  id?: number;
+  firstName: string;
+  lastName: string;
+  phoneNumber: string;
+  active: boolean;
+  email: string;
+  roleId?: number;
+  systemUserId: number;
+  invitedAt: Date | null;
+  inviteAcceptedAt: Date | null;
+}
+
+export interface IUserInvitedEventPayload {
+  inviteToken: string;
+  authorizedUser: ISystemUser;
+  tenantId: number;
+  user: ITenantUser;
+}
+export interface IUserInviteTenantSyncedEventPayload{
+  invite: IUserInvite;
+  authorizedUser: ISystemUser;
+  tenantId: number;
+  user: ITenantUser;
+}
+
+export interface IUserInviteResendEventPayload {
+  inviteToken: string;
+  authorizedUser: ISystemUser;
+  tenantId: number;
+  user: ITenantUser;
+}
+
+export interface IAcceptInviteEventPayload {
+  inviteToken: IUserInvite;
+  user: ISystemUser;
+  inviteUserDTO: IInviteUserInput;
+}
+
+export interface ICheckInviteEventPayload {
+  inviteToken: IUserInvite;
+  tenant: ITenant
+}
+
+export interface IUserSendInviteDTO {
+  email: string;
+  roleId: number;
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/VendorBalanceSummary.ts b/packages/server/src/interfaces/VendorBalanceSummary.ts
new file mode 100644
index 000000000..af75b2d67
--- /dev/null
+++ b/packages/server/src/interfaces/VendorBalanceSummary.ts
@@ -0,0 +1,50 @@
+import { INumberFormatQuery } from './FinancialStatements';
+
+export interface IVendorBalanceSummaryQuery {
+  asDate: Date;
+  vendorsIds: number[],
+  numberFormat: INumberFormatQuery;
+  percentageColumn: boolean;
+  noneTransactions: boolean;
+  noneZero: boolean;
+}
+
+export interface IVendorBalanceSummaryAmount {
+  amount: number;
+  formattedAmount: string;
+  currencyCode: string;
+}
+export interface IVendorBalanceSummaryPercentage {
+  amount: number;
+  formattedAmount: string;
+}
+
+export interface IVendorBalanceSummaryVendor {
+  id: number;
+  vendorName: string;
+  total: IVendorBalanceSummaryAmount;
+  percentageOfColumn?: IVendorBalanceSummaryPercentage;
+}
+
+export interface IVendorBalanceSummaryTotal {
+  total: IVendorBalanceSummaryAmount;
+  percentageOfColumn?: IVendorBalanceSummaryPercentage;
+}
+
+export interface IVendorBalanceSummaryData {
+  vendors: IVendorBalanceSummaryVendor[];
+  total: IVendorBalanceSummaryTotal;
+}
+
+export interface IVendorBalanceSummaryStatement {
+  data: IVendorBalanceSummaryData;
+  columns: {};
+  query: IVendorBalanceSummaryQuery;
+}
+
+export interface IVendorBalanceSummaryService {
+  vendorBalanceSummary(
+    tenantId: number,
+    query: IVendorBalanceSummaryQuery,
+  ): Promise<IVendorBalanceSummaryStatement>;
+}
diff --git a/packages/server/src/interfaces/VendorCredit.ts b/packages/server/src/interfaces/VendorCredit.ts
new file mode 100644
index 000000000..dd8f6b6e4
--- /dev/null
+++ b/packages/server/src/interfaces/VendorCredit.ts
@@ -0,0 +1,240 @@
+import { IDynamicListFilter, IItemEntry, IItemEntryDTO } from '@/interfaces';
+import { Knex } from 'knex';
+
+export enum VendorCreditAction {
+  Create = 'Create',
+  Edit = 'Edit',
+  Delete = 'Delete',
+  View = 'View',
+  Refund = 'Refund',
+}
+
+export interface IVendorCredit {
+  id: number | null;
+  vendorId: number;
+  amount: number;
+  localAmount?: number;
+  currencyCode: string;
+  exchangeRate: number;
+  vendorCreditNumber: string;
+  vendorCreditDate: Date;
+  referenceNo: string;
+  entries?: IItemEntry[];
+  openedAt: Date | null;
+  isOpen: boolean;
+  isPublished: boolean;
+  isClosed: boolean;
+  isDraft: boolean;
+  creditsRemaining: number;
+  branchId?: number;
+  warehouseId?: number,
+}
+
+export interface IVendorCreditEntryDTO extends IItemEntryDTO {}
+
+export interface IRefundVendorCredit {
+  id?: number | null;
+  date: Date;
+  referenceNo: string;
+  amount: number;
+  currencyCode: string;
+  exchangeRate: number;
+  depositAccountId: number;
+  description: string;
+  vendorCreditId: number;
+  createdAt: Date | null;
+  userId: number;
+  branchId?: number;
+
+  vendorCredit?: IVendorCredit
+}
+
+export interface IVendorCreditDTO {
+  vendorId: number;
+  exchangeRate?: number;
+  vendorCreditNumber: string;
+  referenceNo: string;
+  vendorCreditDate: Date;
+  note: string;
+  open: boolean;
+  entries: IVendorCreditEntryDTO[];
+
+  branchId?: number;
+  warehouseId?: number;
+}
+
+export interface IVendorCreditCreateDTO extends IVendorCreditDTO {}
+export interface IVendorCreditEditDTO extends IVendorCreditDTO {}
+export interface IVendorCreditCreatePayload {
+  tenantId: number;
+  refundVendorCreditDTO: IRefundVendorCreditDTO;
+  vendorCreditId: number;
+}
+
+export interface IVendorCreditCreatingPayload {
+  tenantId: number;
+  vendorCredit: IVendorCredit;
+  vendorCreditId: number;
+  vendorCreditCreateDTO: IVendorCreditCreateDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IVendorCreditCreatedPayload {
+  tenantId: number;
+  vendorCredit: IVendorCredit;
+  vendorCreditCreateDTO: IVendorCreditCreateDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IVendorCreditCreatedPayload {}
+export interface IVendorCreditDeletedPayload {
+  trx: Knex.Transaction;
+  tenantId: number;
+  vendorCreditId: number;
+  oldVendorCredit: IVendorCredit;
+}
+
+export interface IVendorCreditDeletingPayload {
+  trx: Knex.Transaction;
+  tenantId: number;
+  oldVendorCredit: IVendorCredit;
+}
+
+export interface IVendorCreditsQueryDTO extends IDynamicListFilter {
+  page: number;
+  pageSize: number;
+  searchKeyword?: string;
+}
+
+export interface IVendorCreditEditingPayload {
+  tenantId: number;
+  oldVendorCredit: IVendorCredit;
+  vendorCreditDTO: IVendorCreditEditDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IVendorCreditEditedPayload {
+  tenantId: number;
+  oldVendorCredit: IVendorCredit;
+  vendorCredit: IVendorCredit;
+  vendorCreditId: number;
+  trx: Knex.Transaction;
+}
+
+export interface IRefundVendorCreditDTO {
+  amount: number;
+  exchangeRate?: number;
+  depositAccountId: number;
+  description: string;
+  date: Date;
+  branchId?: number;
+}
+
+export interface IRefundVendorCreditDeletedPayload {
+  trx: Knex.Transaction;
+  refundCreditId: number;
+  oldRefundCredit: IRefundVendorCredit;
+  tenantId: number;
+}
+
+export interface IRefundVendorCreditDeletePayload {
+  trx: Knex.Transaction;
+  refundCreditId: number;
+  oldRefundCredit: IRefundVendorCredit;
+  tenantId: number;
+}
+export interface IRefundVendorCreditDeletingPayload {
+  trx: Knex.Transaction;
+  refundCreditId: number;
+  oldRefundCredit: IRefundVendorCredit;
+  tenantId: number;
+}
+
+export interface IRefundVendorCreditCreatingPayload {
+  trx: Knex.Transaction;
+  vendorCredit: IVendorCredit;
+  refundVendorCreditDTO: IRefundVendorCreditDTO;
+  tenantId: number;
+}
+
+export interface IRefundVendorCreditCreatedPayload {
+  refundVendorCredit: IRefundVendorCredit;
+  vendorCredit: IVendorCredit;
+  trx: Knex.Transaction;
+  tenantId: number;
+}
+export interface IRefundVendorCreditPOJO {}
+
+export interface IApplyCreditToBillEntryDTO {
+  amount: number;
+  billId: number;
+}
+
+export interface IApplyCreditToBillsDTO {
+  entries: IApplyCreditToBillEntryDTO[];
+}
+
+export interface IVendorCreditOpenedPayload {
+  tenantId: number;
+  vendorCreditId: number;
+  vendorCredit: IVendorCredit;
+  trx: Knex.Transaction;
+}
+
+export interface IVendorCreditOpenPayload {
+  tenantId: number;
+  vendorCreditId: number;
+  oldVendorCredit: IVendorCredit;
+}
+
+export interface IVendorCreditOpeningPayload {
+  tenantId: number;
+  vendorCreditId: number;
+  oldVendorCredit: IVendorCredit;
+  trx: Knex.Transaction;
+}
+
+export interface IVendorCreditApplyToBillsCreatedPayload {
+  tenantId: number;
+  vendorCredit: IVendorCredit;
+  vendorCreditAppliedBills: IVendorCreditAppliedBill[];
+  trx: Knex.Transaction;
+}
+export interface IVendorCreditApplyToBillsCreatingPayload {
+  trx: Knex.Transaction;
+}
+export interface IVendorCreditApplyToBillsCreatePayload {
+  trx: Knex.Transaction;
+}
+export interface IVendorCreditApplyToBillDeletedPayload {
+  tenantId: number;
+  vendorCredit: IVendorCredit;
+  oldCreditAppliedToBill: IVendorCreditAppliedBill;
+  trx: Knex.Transaction;
+}
+
+export interface IVendorCreditApplyToInvoiceDTO {
+  amount: number;
+  billId: number;
+}
+
+export interface IVendorCreditApplyToInvoicesDTO {
+  entries: IVendorCreditApplyToInvoiceDTO[];
+}
+
+export interface IVendorCreditApplyToInvoiceModel {
+  billId: number;
+  amount: number;
+  vendorCreditId: number;
+}
+
+export interface IVendorCreditApplyToInvoicesModel {
+  entries: IVendorCreditApplyToInvoiceModel[];
+  amount: number;
+}
+
+export interface IVendorCreditAppliedBill {
+  billId: number;
+  amount: number;
+  vendorCreditId: number;
+}
diff --git a/packages/server/src/interfaces/View.ts b/packages/server/src/interfaces/View.ts
new file mode 100644
index 000000000..39c32190c
--- /dev/null
+++ b/packages/server/src/interfaces/View.ts
@@ -0,0 +1,68 @@
+
+export interface IView {
+  id: number,
+  name: string,
+  slug: string;
+  predefined: boolean,
+  resourceModel: string,
+  favourite: boolean,
+  rolesLogicExpression: string,
+
+  roles: IViewRole[],
+  columns: IViewHasColumn[],
+};
+
+export interface IViewRole {
+  id: number,
+  fieldKey: string,
+  index: number, 
+  comparator: string,
+  value: string,
+  viewId: number,
+};
+
+export interface IViewHasColumn {
+  id :number,
+  viewId: number,
+  fieldId: number,
+  index: number,
+}
+
+export interface IViewRoleDTO {
+  index: number,
+  fieldKey: string,
+  comparator: string,
+  value: string,
+  viewId: number,
+}
+
+export interface IViewColumnDTO {
+  id: number,
+  index: number,
+  viewId: number,
+  fieldKey: string,
+};
+
+export interface IViewDTO {
+  name: string,
+  logicExpression: string,
+  resourceModel: string,
+
+  roles: IViewRoleDTO[],
+  columns: IViewColumnDTO[],
+};
+
+export interface IViewEditDTO {
+  name: string,
+  logicExpression: string,
+
+  roles: IViewRoleDTO[],
+  columns: IViewColumnDTO[],
+};
+
+export interface IViewsService {
+  listResourceViews(tenantId: number, resourceModel: string): Promise<IView[]>;
+  newView(tenantId: number, viewDTO: IViewDTO): Promise<void>;
+  editView(tenantId: number, viewId: number, viewEditDTO: IViewEditDTO): Promise<void>;
+  deleteView(tenantId: number, viewId: number): Promise<void>;
+}
\ No newline at end of file
diff --git a/packages/server/src/interfaces/Warehouses.ts b/packages/server/src/interfaces/Warehouses.ts
new file mode 100644
index 000000000..7cfd8d803
--- /dev/null
+++ b/packages/server/src/interfaces/Warehouses.ts
@@ -0,0 +1,212 @@
+import { Knex } from 'knex';
+
+export interface IWarehouse {
+  id?: number;
+}
+export interface IWarehouseTransfer {
+  id?: number;
+  date: Date;
+  fromWarehouseId: number;
+  toWarehouseId: number;
+  reason?: string;
+  transactionNumber: string;
+  entries: IWarehouseTransferEntry[];
+  transferInitiatedAt?: Date;
+  transferDeliveredAt?: Date;
+
+  isInitiated?: boolean;
+  isTransferred?: boolean; 
+}
+export interface IWarehouseTransferEntry {
+  id?: number;
+  index?: number;
+  itemId: number;
+  description: string;
+  quantity: number;
+  cost: number;
+}
+export interface ICreateWarehouseDTO {
+  name: string;
+  code: string;
+
+  city?: string;
+  country?: string;
+  address?: string;
+
+  primary?: boolean;
+}
+export interface IEditWarehouseDTO {
+  name: string;
+  code: string;
+
+  city: string;
+  country: string;
+  address: string;
+}
+
+export interface IWarehouseTransferEntryDTO {
+  index?: number;
+  itemId: number;
+  description: string;
+  quantity: number;
+  cost?: number;
+}
+
+export interface ICreateWarehouseTransferDTO {
+  fromWarehouseId: number;
+  toWarehouseId: number;
+  transactionNumber: string;
+  date: Date;
+  transferInitiated: boolean;
+  transferDelivered: boolean;
+  entries: IWarehouseTransferEntryDTO[];
+}
+export interface IEditWarehouseTransferDTO {
+  fromWarehouseId: number;
+  toWarehouseId: number;
+  transactionNumber: string;
+  date: Date;
+  entries: {
+    id?: number;
+    itemId: number;
+    description: string;
+    quantity: number;
+  }[];
+}
+
+export interface IWarehouseEditPayload {
+  tenantId: number;
+  warehouseId: number;
+  warehouseDTO: IEditWarehouseDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IWarehouseEditedPayload {
+  tenantId: number;
+  warehouse: IWarehouse;
+  warehouseDTO: IEditWarehouseDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IWarehouseDeletePayload {
+  tenantId: number;
+  warehouseId: number;
+  trx: Knex.Transaction;
+}
+export interface IWarehouseDeletedPayload {
+  tenantId: number;
+  warehouseId: number;
+  trx: Knex.Transaction;
+}
+export interface IWarehouseCreatePayload {
+  tenantId: number;
+  warehouseDTO: ICreateWarehouseDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IWarehouseCreatedPayload {
+  tenantId: number;
+  warehouse: IWarehouse;
+  warehouseDTO: ICreateWarehouseDTO;
+  trx: Knex.Transaction;
+}
+
+export interface IWarehouseTransferCreate {
+  trx: Knex.Transaction;
+  warehouseTransferDTO: ICreateWarehouseTransferDTO;
+  tenantId: number;
+}
+
+export interface IWarehouseTransferCreated {
+  trx: Knex.Transaction;
+  warehouseTransfer: IWarehouseTransfer;
+  warehouseTransferDTO: ICreateWarehouseTransferDTO;
+  tenantId: number;
+}
+
+export interface IWarehouseTransferEditPayload {
+  tenantId: number;
+  editWarehouseDTO: IEditWarehouseTransferDTO;
+  oldWarehouseTransfer: IWarehouseTransfer;
+  trx: Knex.Transaction;
+}
+
+export interface IWarehouseTransferEditedPayload {
+  tenantId: number;
+  editWarehouseDTO: IEditWarehouseTransferDTO;
+  oldWarehouseTransfer: IWarehouseTransfer;
+  warehouseTransfer: IWarehouseTransfer;
+  trx: Knex.Transaction;
+}
+
+export interface IWarehouseTransferDeletePayload {
+  tenantId: number;
+  oldWarehouseTransfer: IWarehouseTransfer;
+  trx: Knex.Transaction;
+}
+
+export interface IWarehouseTransferDeletedPayload {
+  tenantId: number;
+  warehouseTransfer: IWarehouseTransfer;
+  oldWarehouseTransfer: IWarehouseTransfer;
+  trx: Knex.Transaction;
+}
+
+export interface IGetWarehousesTransfersFilterDTO {
+  page: number;
+  pageSize: number;
+  searchKeyword: string;
+}
+
+export interface IItemWarehouseQuantityChange {
+  itemId: number;
+  warehouseId: number;
+  amount: number;
+}
+
+export interface IWarehousesActivatePayload {
+  tenantId: number;
+}
+export interface IWarehousesActivatedPayload {
+  tenantId: number;
+  primaryWarehouse: IWarehouse;
+}
+
+export interface IWarehouseMarkAsPrimaryPayload {
+  tenantId: number;
+  oldWarehouse: IWarehouse;
+  trx: Knex.Transaction;
+}
+export interface IWarehouseMarkedAsPrimaryPayload {
+  tenantId: number;
+  oldWarehouse: IWarehouse;
+  markedWarehouse: IWarehouse;
+  trx: Knex.Transaction;
+}
+
+export interface IWarehouseTransferInitiatePayload {
+  tenantId: number;
+  oldWarehouseTransfer: IWarehouseTransfer;
+  trx: Knex.Transaction;
+}
+
+
+export interface IWarehouseTransferInitiatedPayload {
+  tenantId: number;
+  warehouseTransfer: IWarehouseTransfer;
+  oldWarehouseTransfer: IWarehouseTransfer;
+  trx: Knex.Transaction;
+}
+
+export interface IWarehouseTransferTransferingPayload {
+  tenantId: number;
+  oldWarehouseTransfer: IWarehouseTransfer;
+  trx: Knex.Transaction;
+}
+
+export interface IWarehouseTransferTransferredPayload {
+  tenantId: number;
+  warehouseTransfer: IWarehouseTransfer;
+  oldWarehouseTransfer: IWarehouseTransfer;
+  trx: Knex.Transaction;
+}
diff --git a/packages/server/src/interfaces/index.ts b/packages/server/src/interfaces/index.ts
new file mode 100644
index 000000000..7cd789457
--- /dev/null
+++ b/packages/server/src/interfaces/index.ts
@@ -0,0 +1,79 @@
+export * from './Model';
+export * from './InventoryTransaction';
+export * from './BillPayment';
+export * from './Bill';
+export * from './InventoryCostMethod';
+export * from './ItemEntry';
+export * from './Item';
+export * from './License';
+export * from './ItemCategory';
+export * from './Payment';
+export * from './SaleInvoice';
+export * from './SaleReceipt';
+export * from './PaymentReceive';
+export * from './SaleEstimate';
+export * from './Authentication';
+export * from './User';
+export * from './Metable';
+export * from './Options';
+export * from './Account';
+export * from './DynamicFilter';
+export * from './Journal';
+export * from './Contact';
+export * from './Expenses';
+export * from './Tenancy';
+export * from './View';
+export * from './ManualJournal';
+export * from './Currency';
+export * from './ExchangeRate';
+export * from './Media';
+export * from './SaleEstimate';
+export * from './FinancialStatements';
+export * from './BalanceSheet';
+export * from './TrialBalanceSheet';
+export * from './GeneralLedgerSheet';
+export * from './ProfitLossSheet';
+export * from './JournalReport';
+export * from './AgingReport';
+export * from './ARAgingSummaryReport';
+export * from './APAgingSummaryReport';
+export * from './Mailable';
+export * from './InventoryAdjustment';
+export * from './Setup';
+export * from './IInventoryValuationSheet';
+export * from './SalesByItemsSheet';
+export * from './CustomerBalanceSummary';
+export * from './VendorBalanceSummary';
+export * from './ContactBalanceSummary';
+export * from './TransactionsByCustomers';
+export * from './TransactionsByContacts';
+export * from './TransactionsByVendors';
+export * from './Table';
+export * from './Ledger';
+export * from './CashFlow';
+export * from './InventoryDetails';
+export * from './LandedCost';
+export * from './Entry';
+export * from './TransactionsByReference';
+export * from './Jobs';
+export * from './CashflowService';
+export * from './FinancialReports/CashflowAccountTransactions';
+export * from './SmsNotifications';
+export * from './Roles';
+export * from './TransactionsLocking';
+export * from './User';
+export * from './Preferences';
+export * from './CreditNote';
+export * from './VendorCredit';
+export * from './Warehouses';
+export * from './Branches';
+export * from './Features';
+export * from './InventoryCost';
+export * from './Project';
+export * from './Tasks';
+export * from './Times';
+export * from './ProjectProfitabilitySummary';
+
+export interface I18nService {
+  __: (input: string) => string;
+}
diff --git a/packages/server/src/jobs/ComputeItemCost.ts b/packages/server/src/jobs/ComputeItemCost.ts
new file mode 100644
index 000000000..07479258d
--- /dev/null
+++ b/packages/server/src/jobs/ComputeItemCost.ts
@@ -0,0 +1,73 @@
+import { Container } from 'typedi';
+import events from '@/subscribers/events';
+import InventoryService from '@/services/Inventory/Inventory';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import {
+  IComputeItemCostJobCompletedPayload,
+  IComputeItemCostJobStartedPayload,
+} from '@/interfaces';
+
+export default class ComputeItemCostJob {
+  agenda: any;
+  eventPublisher: EventPublisher;
+
+  /**
+   * Constructor method.
+   * @param agenda
+   */
+  constructor(agenda) {
+    this.agenda = agenda;
+    this.eventPublisher = Container.get(EventPublisher);
+
+    agenda.define(
+      'compute-item-cost',
+      { priority: 'high', concurrency: 1 },
+      this.handler.bind(this)
+    );
+    this.agenda.on('start:compute-item-cost', this.onJobStart.bind(this));
+    this.agenda.on(
+      'complete:compute-item-cost',
+      this.onJobCompleted.bind(this)
+    );
+  }
+
+  /**
+   * The job handler.
+   */
+  public async handler(job, done: Function): Promise<void> {
+    const { startingDate, itemId, tenantId } = job.attrs.data;
+    const inventoryService = Container.get(InventoryService);
+
+    try {
+      await inventoryService.computeItemCost(tenantId, startingDate, itemId);
+      done();
+    } catch (e) {
+      done(e);
+    }
+  }
+
+  /**
+   * Handle the job started.
+   */
+  async onJobStart(job) {
+    const { startingDate, itemId, tenantId } = job.attrs.data;
+
+    await this.eventPublisher.emitAsync(
+      events.inventory.onComputeItemCostJobStarted,
+      { startingDate, itemId, tenantId } as IComputeItemCostJobStartedPayload
+    );
+  }
+
+  /**
+   * Handle job complete items cost finished.
+   * @param {Job} job -
+   */
+  async onJobCompleted(job) {
+    const { startingDate, itemId, tenantId } = job.attrs.data;
+
+    await this.eventPublisher.emitAsync(
+      events.inventory.onComputeItemCostJobCompleted,
+      { startingDate, itemId, tenantId } as IComputeItemCostJobCompletedPayload
+    );
+  }
+}
diff --git a/packages/server/src/jobs/MailNotificationSubscribeEnd.ts b/packages/server/src/jobs/MailNotificationSubscribeEnd.ts
new file mode 100644
index 000000000..a2b54778b
--- /dev/null
+++ b/packages/server/src/jobs/MailNotificationSubscribeEnd.ts
@@ -0,0 +1,34 @@
+import Container from 'typedi';
+import SubscriptionService from '@/services/Subscription/Subscription';
+
+export default class MailNotificationSubscribeEnd {
+  /**
+   * Job handler.
+   * @param {Job} job -
+   */
+  handler(job) {
+    const { tenantId, phoneNumber, remainingDays } = job.attrs.data;
+
+    const subscriptionService = Container.get(SubscriptionService);
+    const Logger = Container.get('logger');
+
+    Logger.info(
+      `Send mail notification subscription end soon - started: ${job.attrs.data}`
+    );
+
+    try {
+      subscriptionService.mailMessages.sendRemainingTrialPeriod(
+        phoneNumber,
+        remainingDays
+      );
+      Logger.info(
+        `Send mail notification subscription end soon - finished: ${job.attrs.data}`
+      );
+    } catch (error) {
+      Logger.info(
+        `Send mail notification subscription end soon - failed: ${job.attrs.data}, error: ${e}`
+      );
+      done(e);
+    }
+  }
+}
diff --git a/packages/server/src/jobs/MailNotificationTrialEnd.ts b/packages/server/src/jobs/MailNotificationTrialEnd.ts
new file mode 100644
index 000000000..82d8bd53c
--- /dev/null
+++ b/packages/server/src/jobs/MailNotificationTrialEnd.ts
@@ -0,0 +1,34 @@
+import Container from 'typedi';
+import SubscriptionService from '@/services/Subscription/Subscription';
+
+export default class MailNotificationTrialEnd {
+  /**
+   *
+   * @param {Job} job -
+   */
+  handler(job) {
+    const { tenantId, phoneNumber, remainingDays } = job.attrs.data;
+
+    const subscriptionService = Container.get(SubscriptionService);
+    const Logger = Container.get('logger');
+
+    Logger.info(
+      `Send mail notification subscription end soon - started: ${job.attrs.data}`
+    );
+
+    try {
+      subscriptionService.mailMessages.sendRemainingTrialPeriod(
+        phoneNumber,
+        remainingDays
+      );
+      Logger.info(
+        `Send mail notification subscription end soon - finished: ${job.attrs.data}`
+      );
+    } catch (error) {
+      Logger.info(
+        `Send mail notification subscription end soon - failed: ${job.attrs.data}, error: ${e}`
+      );
+      done(e);
+    }
+  }
+}
diff --git a/packages/server/src/jobs/OrganizationSetup.ts b/packages/server/src/jobs/OrganizationSetup.ts
new file mode 100644
index 000000000..1945b6e2b
--- /dev/null
+++ b/packages/server/src/jobs/OrganizationSetup.ts
@@ -0,0 +1,34 @@
+import { Container } from 'typedi';
+import OrganizationService from '@/services/Organization/OrganizationService';
+
+export default class OrganizationSetupJob {
+  /**
+   * Constructor method.
+   */
+  constructor(agenda) {
+    agenda.define(
+      'organization-setup',
+      { priority: 'high', concurrency: 1 },
+      this.handler
+    );
+  }
+
+  /**
+   * Handle job action.
+   */
+  async handler(job, done: Function): Promise<void> {
+    const { tenantId, buildDTO, authorizedUser, _id } = job.attrs.data;
+    const organizationService = Container.get(OrganizationService);
+
+    try {
+      await organizationService.build(tenantId, buildDTO, authorizedUser);
+      done();
+    } catch (e) {
+      // Unlock build status of the tenant.
+      await organizationService.revertBuildRunJob(tenantId, _id);
+
+      console.error(e);
+      done(e);
+    }
+  }
+}
diff --git a/packages/server/src/jobs/OrganizationUpgrade.ts b/packages/server/src/jobs/OrganizationUpgrade.ts
new file mode 100644
index 000000000..1ea911baf
--- /dev/null
+++ b/packages/server/src/jobs/OrganizationUpgrade.ts
@@ -0,0 +1,31 @@
+import { Container } from 'typedi';
+import OrganizationUpgrade from '@/services/Organization/OrganizationUpgrade';
+
+export default class OrganizationUpgradeJob {
+  /**
+   * Constructor method.
+   */
+  constructor(agenda) {
+    agenda.define(
+      'organization-upgrade',
+      { priority: 'high', concurrency: 1 },
+      this.handler
+    );
+  }
+
+  /**
+   * Handle job action.
+   */
+  async handler(job, done: Function): Promise<void> {
+    const { tenantId, _id } = job.attrs.data;
+    const organizationUpgrade = Container.get(OrganizationUpgrade);
+
+    try {
+      await organizationUpgrade.upgradeJob(tenantId);
+      done();
+    } catch (e) {
+      console.error(e);
+      done(e);
+    }
+  }
+}
diff --git a/packages/server/src/jobs/ResetPasswordMail.ts b/packages/server/src/jobs/ResetPasswordMail.ts
new file mode 100644
index 000000000..cd33e49b3
--- /dev/null
+++ b/packages/server/src/jobs/ResetPasswordMail.ts
@@ -0,0 +1,39 @@
+import { Container, Inject } from 'typedi';
+import AuthenticationService from '@/services/Authentication';
+
+export default class WelcomeEmailJob {
+  /**
+   * Constructor method.
+   * @param {Agenda} agenda 
+   */
+  constructor(agenda) {
+    agenda.define(
+      'reset-password-mail',
+      { priority: 'high' },
+      this.handler.bind(this),
+    );
+  }
+
+  /**
+   * Handle send welcome mail job.
+   * @param {Job} job 
+   * @param {Function} done 
+   */
+  public async handler(job, done: Function): Promise<void> {
+    const { data } = job.attrs;
+    const { user, token } = data;
+    const Logger = Container.get('logger');
+    const authService = Container.get(AuthenticationService);
+
+    Logger.info(`[send_reset_password] started.`, { data });
+  
+    try {
+      await authService.mailMessages.sendResetPasswordMessage(user, token);
+      Logger.info(`[send_reset_password] finished.`, { data });
+      done()
+    } catch (error) {
+      Logger.error(`[send_reset_password] error.`, { data, error });
+      done(error);
+    }
+  }
+}
diff --git a/packages/server/src/jobs/SMSNotificationSubscribeEnd.ts b/packages/server/src/jobs/SMSNotificationSubscribeEnd.ts
new file mode 100644
index 000000000..d203c1d6b
--- /dev/null
+++ b/packages/server/src/jobs/SMSNotificationSubscribeEnd.ts
@@ -0,0 +1,28 @@
+import Container from 'typedi';
+import SubscriptionService from '@/services/Subscription/Subscription';
+
+export default class SMSNotificationSubscribeEnd {
+
+  /**
+   * 
+   * @param {Job}job 
+   */
+  handler(job) {
+    const { tenantId, phoneNumber, remainingDays } = job.attrs.data;
+
+    const subscriptionService = Container.get(SubscriptionService);
+    const Logger = Container.get('logger');
+
+    Logger.info(`Send SMS notification subscription end soon - started: ${job.attrs.data}`);
+
+    try {
+      subscriptionService.smsMessages.sendRemainingSubscriptionPeriod(
+        phoneNumber, remainingDays,
+      );
+      Logger.info(`Send SMS notification subscription end soon - finished: ${job.attrs.data}`);
+    } catch(error) {
+      Logger.info(`Send SMS notification subscription end soon - failed: ${job.attrs.data}, error: ${e}`);
+      done(e);
+    }
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/jobs/SMSNotificationTrialEnd.ts b/packages/server/src/jobs/SMSNotificationTrialEnd.ts
new file mode 100644
index 000000000..a3e5c5420
--- /dev/null
+++ b/packages/server/src/jobs/SMSNotificationTrialEnd.ts
@@ -0,0 +1,28 @@
+import Container from 'typedi';
+import SubscriptionService from '@/services/Subscription/Subscription';
+
+export default class SMSNotificationTrialEnd {
+
+  /**
+   * 
+   * @param {Job}job 
+   */
+  handler(job) {
+    const { tenantId, phoneNumber, remainingDays } = job.attrs.data;
+
+    const subscriptionService = Container.get(SubscriptionService);
+    const Logger = Container.get('logger');
+
+    Logger.info(`Send notification subscription end soon - started: ${job.attrs.data}`);
+
+    try {
+      subscriptionService.smsMessages.sendRemainingTrialPeriod(
+        phoneNumber, remainingDays,
+      );
+      Logger.info(`Send notification subscription end soon - finished: ${job.attrs.data}`);
+    } catch(error) {
+      Logger.info(`Send notification subscription end soon - failed: ${job.attrs.data}, error: ${e}`);
+      done(e);
+    }
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/jobs/SendLicenseEmail.ts b/packages/server/src/jobs/SendLicenseEmail.ts
new file mode 100644
index 000000000..d28c07afe
--- /dev/null
+++ b/packages/server/src/jobs/SendLicenseEmail.ts
@@ -0,0 +1,33 @@
+import { Container } from 'typedi';
+import LicenseService from '@/services/Payment/License';
+
+export default class SendLicenseViaEmailJob {
+  /**
+   * Constructor method.
+   * @param agenda 
+   */
+  constructor(agenda) {
+    agenda.define(
+      'send-license-via-email',
+      { priority: 'high', concurrency: 1, },
+      this.handler,
+    );
+  }
+
+  public async handler(job, done: Function): Promise<void> {
+    const Logger = Container.get('logger');
+    const licenseService = Container.get(LicenseService);
+    const { email, licenseCode } = job.attrs.data;
+
+    Logger.info(`[send_license_via_mail] started: ${job.attrs.data}`);
+
+    try {
+      await licenseService.mailMessages.sendMailLicense(licenseCode, email);
+      Logger.info(`[send_license_via_mail] completed: ${job.attrs.data}`);
+      done();
+    } catch(e) {
+      Logger.error(`[send_license_via_mail] ${job.attrs.data}, error: ${e}`);
+      done(e);  
+    } 
+  }
+}
diff --git a/packages/server/src/jobs/SendLicensePhone.ts b/packages/server/src/jobs/SendLicensePhone.ts
new file mode 100644
index 000000000..adc5429fb
--- /dev/null
+++ b/packages/server/src/jobs/SendLicensePhone.ts
@@ -0,0 +1,33 @@
+import { Container } from 'typedi';
+import LicenseService from '@/services/Payment/License';
+
+export default class SendLicenseViaPhoneJob {
+  /**
+   * Constructor method.
+   */
+  constructor(agenda) {
+    agenda.define(
+      'send-license-via-phone',
+      { priority: 'high', concurrency: 1, },
+      this.handler,
+    );
+  }
+
+  public async handler(job, done: Function): Promise<void> {
+    const { phoneNumber, licenseCode } = job.attrs.data;
+
+    const Logger = Container.get('logger');
+    const licenseService = Container.get(LicenseService);
+
+    Logger.debug(`Send license via phone number - started: ${job.attrs.data}`);
+
+    try {
+      await licenseService.smsMessages.sendLicenseSMSMessage(phoneNumber, licenseCode);
+      Logger.debug(`Send license via phone number - completed: ${job.attrs.data}`);
+      done();
+    } catch(e) {
+      Logger.error(`Send license via phone number: ${job.attrs.data}, error: ${e}`);
+      done(e);  
+    }
+  }
+}
diff --git a/packages/server/src/jobs/SmsNotification.ts b/packages/server/src/jobs/SmsNotification.ts
new file mode 100644
index 000000000..65730daff
--- /dev/null
+++ b/packages/server/src/jobs/SmsNotification.ts
@@ -0,0 +1,22 @@
+import { Container } from 'typedi';
+
+export default class SmsNotification {
+  constructor(agenda) {
+    agenda.define('sms-notification', { priority: 'high' }, this.handler);
+  }
+
+  /**
+   *
+   * @param {Job}job
+   */
+  async handler(job) {
+    const { message, to } = job.attrs.data;
+    const smsClient = Container.get('SMSClient');
+
+    try {
+      await smsClient.sendMessage(to, message);
+    } catch (error) {
+      done(e);
+    }
+  }
+}
diff --git a/packages/server/src/jobs/UserInviteMail.ts b/packages/server/src/jobs/UserInviteMail.ts
new file mode 100644
index 000000000..1b07ebc5d
--- /dev/null
+++ b/packages/server/src/jobs/UserInviteMail.ts
@@ -0,0 +1,45 @@
+import { Container, Inject } from 'typedi';
+import InviteUserService from '@/services/InviteUsers/AcceptInviteUser';
+
+export default class UserInviteMailJob {
+  /**
+   * Constructor method.
+   * @param {Agenda} agenda
+   */
+  constructor(agenda) {
+    agenda.define(
+      'user-invite-mail',
+      { priority: 'high' },
+      this.handler.bind(this)
+    );
+  }
+
+  /**
+   * Handle invite user job.
+   * @param {Job} job
+   * @param {Function} done
+   */
+  public async handler(job, done: Function): Promise<void> {
+    const { invite, authorizedUser, tenantId } = job.attrs.data;
+
+    const Logger = Container.get('logger');
+    const inviteUsersService = Container.get(InviteUserService);
+
+    Logger.info(`Send invite user mail - started: ${job.attrs.data}`);
+
+    try {
+      await inviteUsersService.mailMessages.sendInviteMail(
+        tenantId,
+        authorizedUser,
+        invite
+      );
+      Logger.info(`Send invite user mail - finished: ${job.attrs.data}`);
+      done();
+    } catch (error) {
+      Logger.info(
+        `Send invite user mail - error: ${job.attrs.data}, error: ${error}`
+      );
+      done(error);
+    }
+  }
+}
diff --git a/packages/server/src/jobs/WelcomeSMS.ts b/packages/server/src/jobs/WelcomeSMS.ts
new file mode 100644
index 000000000..4dc135db7
--- /dev/null
+++ b/packages/server/src/jobs/WelcomeSMS.ts
@@ -0,0 +1,35 @@
+import { Container, Inject } from 'typedi';
+import AuthenticationService from '@/services/Authentication';
+
+export default class WelcomeSMSJob {
+  /**
+   * Constructor method.
+   * @param {Agenda} agenda 
+   */
+  constructor(agenda) {
+    agenda.define('welcome-sms', { priority: 'high' }, this.handler);
+  }
+
+  /**
+   * Handle send welcome mail job.
+   * @param {Job} job 
+   * @param {Function} done 
+   */
+  public async handler(job, done: Function): Promise<void> {
+    const { tenant, user } = job.attrs.data;
+
+    const Logger = Container.get('logger');
+    const authService = Container.get(AuthenticationService);
+
+    Logger.info(`[welcome_sms] started: ${job.attrs.data}`);
+
+    try {
+      await authService.smsMessages.sendWelcomeMessage(tenant, user);
+      Logger.info(`[welcome_sms] finished`, { tenant, user });
+      done();
+    } catch (error) {
+      Logger.info(`[welcome_sms] error`, { error, tenant, user });
+      done(error);
+    }
+  }
+}
diff --git a/packages/server/src/jobs/welcomeEmail.ts b/packages/server/src/jobs/welcomeEmail.ts
new file mode 100644
index 000000000..b9c8bbde9
--- /dev/null
+++ b/packages/server/src/jobs/welcomeEmail.ts
@@ -0,0 +1,39 @@
+import { Container } from 'typedi';
+import AuthenticationService from '@/services/Authentication';
+
+export default class WelcomeEmailJob {
+  /**
+   * Constructor method.
+   * @param {Agenda} agenda - 
+   */
+  constructor(agenda) {
+    // Welcome mail and SMS message.
+    agenda.define(
+      'welcome-email',
+      { priority: 'high' },
+      this.handler.bind(this),
+    );
+  }
+
+  /**
+   * Handle send welcome mail job.
+   * @param {Job} job 
+   * @param {Function} done 
+   */
+  public async handler(job, done: Function): Promise<void> {
+    const { organizationId, user } = job.attrs.data;
+    const Logger: any = Container.get('logger');
+    const authService = Container.get(AuthenticationService);
+
+    Logger.info(`[welcome_mail] started: ${job.attrs.data}`);
+
+    try {
+      await authService.mailMessages.sendWelcomeMessage(user, organizationId);
+      Logger.info(`[welcome_mail] finished: ${job.attrs.data}`);
+      done();
+    } catch (error) {
+      Logger.error(`[welcome_mail] error: ${job.attrs.data}, error: ${error}`);
+      done(error);
+    }
+  }
+}
diff --git a/packages/server/src/jobs/writeInvoicesJEntries.ts b/packages/server/src/jobs/writeInvoicesJEntries.ts
new file mode 100644
index 000000000..c3982fc22
--- /dev/null
+++ b/packages/server/src/jobs/writeInvoicesJEntries.ts
@@ -0,0 +1,50 @@
+import { Container } from 'typedi';
+import events from '@/subscribers/events';
+import SalesInvoicesCost from '@/services/Sales/SalesInvoicesCost';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+export default class WriteInvoicesJournalEntries {
+  eventPublisher: EventPublisher;
+
+  /**
+   * Constructor method.
+   */
+  constructor(agenda) {
+    const eventName = 'rewrite-invoices-journal-entries';
+    this.eventPublisher = Container.get(EventPublisher);
+
+    agenda.define(
+      eventName,
+      { priority: 'normal', concurrency: 1 },
+      this.handler.bind(this)
+    );
+    agenda.on(`complete:${eventName}`, this.onJobCompleted.bind(this));
+  }
+
+  /**
+   * Handle the job execuation.
+   */
+  public async handler(job, done: Function): Promise<void> {
+    const { startingDate, tenantId } = job.attrs.data;
+    const salesInvoicesCost = Container.get(SalesInvoicesCost);
+
+    try {
+      await salesInvoicesCost.writeCostLotsGLEntries(tenantId, startingDate);
+      done();
+    } catch (e) {
+      done(e);
+    }
+  }
+
+  /**
+   * Handle the job complete.
+   */
+  async onJobCompleted(job) {
+    const { startingDate, itemId, tenantId } = job.attrs.data;
+
+    await this.eventPublisher.emitAsync(
+      events.inventory.onInventoryCostEntriesWritten,
+      { startingDate, itemId, tenantId }
+    );
+  }
+}
diff --git a/packages/server/src/lib/AccountTypes/index.ts b/packages/server/src/lib/AccountTypes/index.ts
new file mode 100644
index 000000000..2084d4b8d
--- /dev/null
+++ b/packages/server/src/lib/AccountTypes/index.ts
@@ -0,0 +1,101 @@
+import { get } from 'lodash';
+import { ACCOUNT_TYPES } from '@/data/AccountTypes';
+
+export default class AccountTypesUtils {
+  /**
+   * Retrieve account types list.
+   */
+  static getList() {
+    return ACCOUNT_TYPES;
+  }
+
+  /**
+   * Retrieve accounts types by the given root type.
+   * @param {string} rootType -
+   * @return {string}
+   */
+  static getTypesByRootType(rootType: string) {
+    return ACCOUNT_TYPES.filter((type) => type.rootType === rootType);
+  }
+
+  /**
+   * Retrieve account type by the given account type key.
+   * @param {string} key 
+   * @param {string} accessor 
+   */
+  static getType(key: string, accessor?: string) {
+    const type = ACCOUNT_TYPES.find((type) => type.key === key);
+
+    if (accessor) {
+      return get(type, accessor);
+    }
+    return type;
+  }
+
+  /**
+   * Retrieve accounts types by the parent account type.
+   * @param {string} parentType 
+   */
+  static getTypesByParentType(parentType: string) {
+    return ACCOUNT_TYPES.filter((type) => type.parentType === parentType);
+  }
+
+  /**
+   * Retrieve accounts types by the given account normal.
+   * @param {string} normal 
+   */
+  static getTypesByNormal(normal: string) {
+    return ACCOUNT_TYPES.filter((type) => type.normal === normal);
+  }
+
+  /**
+   * Detarmines whether the root type equals the account type. 
+   * @param {string} key 
+   * @param {string} rootType 
+   */
+  static isRootTypeEqualsKey(key: string, rootType: string): boolean {
+    return ACCOUNT_TYPES.some((type) => {
+      const isType = type.key === key;
+      const isRootType = type.rootType === rootType;
+
+      return isType && isRootType;
+    });
+  }
+
+  /**
+   * Detarmines whether the parent account type equals the account type key.
+   * @param {string} key - Account type key.
+   * @param {string} parentType - Account parent type.
+   */
+  static isParentTypeEqualsKey(key: string, parentType: string): boolean {
+    return ACCOUNT_TYPES.some((type) => {
+      const isType = type.key === key;
+      const isParentType = type.parentType === parentType;
+
+      return isType && isParentType;
+    });
+  }
+
+  /**
+   * Detarmines whether account type has balance sheet.
+   * @param {string} key - Account type key.
+   * 
+   */
+  static isTypeBalanceSheet(key: string): boolean {
+    return ACCOUNT_TYPES.some((type) => {
+      const isType = type.key === key;
+      return isType && type.balanceSheet;
+    });
+  }
+
+  /**
+   * Detarmines whether account type has profit/loss sheet.
+   * @param {string} key - Account type key.
+   */
+  static isTypePLSheet(key: string): boolean {
+    return ACCOUNT_TYPES.some((type) => {
+      const isType = type.key === key;
+      return isType && type.incomeSheet;
+    });
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/lib/Cachable/CachableModel.js b/packages/server/src/lib/Cachable/CachableModel.js
new file mode 100644
index 000000000..e5ff8bfd5
--- /dev/null
+++ b/packages/server/src/lib/Cachable/CachableModel.js
@@ -0,0 +1,16 @@
+import BaseModel from 'models/Model';
+import CacheService from '@/services/Cache';
+
+export default (Model) => {
+  return class CachableModel extends Model{
+    static flushCache(key) {
+      const modelName = this.name;
+
+      if (key) {
+        CacheService.del(`${modelName}.${key}`);
+      } else {
+        CacheService.delStartWith(modelName);
+      }
+    }
+  };
+} 
\ No newline at end of file
diff --git a/packages/server/src/lib/Cachable/CachableQueryBuilder.js b/packages/server/src/lib/Cachable/CachableQueryBuilder.js
new file mode 100644
index 000000000..41fa8fbea
--- /dev/null
+++ b/packages/server/src/lib/Cachable/CachableQueryBuilder.js
@@ -0,0 +1,69 @@
+import { QueryBuilder } from 'objection';
+import crypto from 'crypto';
+import CacheService from '@/services/Cache';
+
+export default class CachableQueryBuilder extends QueryBuilder{
+
+  async then(...args) {
+    // Flush model cache after insert, delete or update transaction.
+    if (this.isInsert() || this.isDelete() || this.isUpdate()) {
+      this.modelClass().flushCache();
+    }
+    if (this.cacheTag && this.isFind()) {
+      this.setCacheKey();
+      return this.getOrStoreCache().then(...args);
+    } else {
+      const promise = this.execute();
+    
+      return promise.then((result) => {
+        this.setCache(result);
+        return result;
+      }).then(...args);
+    }
+  }
+
+  getOrStoreCache() {
+    const storeFunction = () => this.execute();
+
+    return new Promise((resolve, reject) => {
+      CacheService.get(this.cacheKey, storeFunction)
+        .then((result) => { resolve(result); });
+    });
+  }
+
+  setCache(results) {
+    CacheService.set(`${this.cacheKey}`, results, this.cacheSeconds);
+  }
+
+  generateCacheKey() {
+    const knexSql = this.toKnexQuery().toSQL();
+    const hashedQuery = crypto.createHash('md5').update(knexSql.sql).digest("hex");
+
+    return hashedQuery;
+  }
+
+  remember(key, seconds) {
+    const modelName = this.modelClass().name;
+
+    this.cacheSeconds = seconds;
+    this.cacheTag = (key) ? `${modelName}.${key}` : modelName;
+
+    return this;
+  }
+
+  withGraphFetched(relation, settings) {
+    if (!this.graphAppends) {
+      this.graphAppends = [relation];
+    } else {
+      this.graphAppends.push(relation);
+    }
+    return super.withGraphFetched(relation, settings);
+  }
+
+  setCacheKey() {
+    const hashedQuery = this.generateCacheKey();
+    const appends = (this.graphAppends || []).join(this.graphAppends, ',');
+
+    this.cacheKey = `${this.cacheTag}.${hashedQuery}.${appends}`;
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/lib/DependencyGraph/index.js b/packages/server/src/lib/DependencyGraph/index.js
new file mode 100644
index 000000000..0785f5e9c
--- /dev/null
+++ b/packages/server/src/lib/DependencyGraph/index.js
@@ -0,0 +1,350 @@
+/**
+ * A simple dependency graph
+ */
+
+/**
+ * Helper for creating a Topological Sort using Depth-First-Search on a set of edges.
+ *
+ * Detects cycles and throws an Error if one is detected (unless the "circular"
+ * parameter is "true" in which case it ignores them).
+ *
+ * @param edges The set of edges to DFS through
+ * @param leavesOnly Whether to only return "leaf" nodes (ones who have no edges)
+ * @param result An array in which the results will be populated
+ * @param circular A boolean to allow circular dependencies
+ */
+function createDFS(edges, leavesOnly, result, circular) {
+  var visited = {};
+  return function (start) {
+    if (visited[start]) {
+      return;
+    }
+    var inCurrentPath = {};
+    var currentPath = [];
+    var todo = []; // used as a stack
+    todo.push({ node: start, processed: false });
+    while (todo.length > 0) {
+      var current = todo[todo.length - 1]; // peek at the todo stack
+      var processed = current.processed;
+      var node = current.node;
+      if (!processed) {
+        // Haven't visited edges yet (visiting phase)
+        if (visited[node]) {
+          todo.pop();
+          continue;
+        } else if (inCurrentPath[node]) {
+          // It's not a DAG
+          if (circular) {
+            todo.pop();
+            // If we're tolerating cycles, don't revisit the node
+            continue;
+          }
+          currentPath.push(node);
+          throw new DepGraphCycleError(currentPath);
+        }
+
+        inCurrentPath[node] = true;
+        currentPath.push(node);
+        var nodeEdges = edges[node];
+        // (push edges onto the todo stack in reverse order to be order-compatible with the old DFS implementation)
+        for (var i = nodeEdges.length - 1; i >= 0; i--) {
+          todo.push({ node: nodeEdges[i], processed: false });
+        }
+        current.processed = true;
+      } else {
+        // Have visited edges (stack unrolling phase)
+        todo.pop();
+        currentPath.pop();
+        inCurrentPath[node] = false;
+        visited[node] = true;
+        if (!leavesOnly || edges[node].length === 0) {
+          result.push(node);
+        }
+      }
+    }
+  };
+}
+
+/**
+ * Simple Dependency Graph
+ */
+var DepGraph = (DepGraph = function DepGraph(opts) {
+  this.nodes = {}; // Node -> Node/Data (treated like a Set)
+  this.outgoingEdges = {}; // Node -> [Dependency Node]
+  this.incomingEdges = {}; // Node -> [Dependant Node]
+  this.circular = opts && !!opts.circular; // Allows circular deps
+});
+
+DepGraph.fromArray = (
+  items,
+  options = { itemId: 'id', parentItemId: 'parent_id' }
+) => {
+  const depGraph = new DepGraph();
+
+  items.forEach((item) => {
+    depGraph.addNode(item[options.itemId], item);
+  });
+  items.forEach((item) => {
+    if (item[options.parentItemId]) {
+      depGraph.addDependency(item[options.parentItemId], item[options.itemId]);
+    }
+  });
+  return depGraph;
+};
+
+DepGraph.prototype = {
+  /**
+   * The number of nodes in the graph.
+   */
+  size: function () {
+    return Object.keys(this.nodes).length;
+  },
+  /**
+   * Add a node to the dependency graph. If a node already exists, this method will do nothing.
+   */
+  addNode: function (node, data) {
+    if (!this.hasNode(node)) {
+      // Checking the arguments length allows the user to add a node with undefined data
+      if (arguments.length === 2) {
+        this.nodes[node] = data;
+      } else {
+        this.nodes[node] = node;
+      }
+      this.outgoingEdges[node] = [];
+      this.incomingEdges[node] = [];
+    }
+  },
+  /**
+   * Remove a node from the dependency graph. If a node does not exist, this method will do nothing.
+   */
+  removeNode: function (node) {
+    if (this.hasNode(node)) {
+      delete this.nodes[node];
+      delete this.outgoingEdges[node];
+      delete this.incomingEdges[node];
+      [this.incomingEdges, this.outgoingEdges].forEach(function (edgeList) {
+        Object.keys(edgeList).forEach(function (key) {
+          var idx = edgeList[key].indexOf(node);
+          if (idx >= 0) {
+            edgeList[key].splice(idx, 1);
+          }
+        }, this);
+      });
+    }
+  },
+  /**
+   * Check if a node exists in the graph
+   */
+  hasNode: function (node) {
+    return this.nodes.hasOwnProperty(node);
+  },
+  /**
+   * Get the data associated with a node name
+   */
+  getNodeData: function (node) {
+    if (this.hasNode(node)) {
+      return this.nodes[node];
+    } else {
+      throw new Error('Node does not exist: ' + node);
+    }
+  },
+
+  /**
+   * Set the associated data for a given node name. If the node does not exist, this method will throw an error
+   */
+  setNodeData: function (node, data) {
+    if (this.hasNode(node)) {
+      this.nodes[node] = data;
+    } else {
+      throw new Error('Node does not exist: ' + node);
+    }
+  },
+  /**
+   * Add a dependency between two nodes. If either of the nodes does not exist,
+   * an Error will be thrown.
+   */
+  addDependency: function (from, to) {
+    if (!this.hasNode(from)) {
+      throw new Error('Node does not exist: ' + from);
+    }
+    if (!this.hasNode(to)) {
+      throw new Error('Node does not exist: ' + to);
+    }
+    if (this.outgoingEdges[from].indexOf(to) === -1) {
+      this.outgoingEdges[from].push(to);
+    }
+    if (this.incomingEdges[to].indexOf(from) === -1) {
+      this.incomingEdges[to].push(from);
+    }
+    return true;
+  },
+  /**
+   * Remove a dependency between two nodes.
+   */
+  removeDependency: function (from, to) {
+    var idx;
+    if (this.hasNode(from)) {
+      idx = this.outgoingEdges[from].indexOf(to);
+      if (idx >= 0) {
+        this.outgoingEdges[from].splice(idx, 1);
+      }
+    }
+
+    if (this.hasNode(to)) {
+      idx = this.incomingEdges[to].indexOf(from);
+      if (idx >= 0) {
+        this.incomingEdges[to].splice(idx, 1);
+      }
+    }
+  },
+  /**
+   * Return a clone of the dependency graph. If any custom data is attached
+   * to the nodes, it will only be shallow copied.
+   */
+  clone: function () {
+    var source = this;
+    var result = new DepGraph();
+    var keys = Object.keys(source.nodes);
+    keys.forEach(function (n) {
+      result.nodes[n] = source.nodes[n];
+      result.outgoingEdges[n] = source.outgoingEdges[n].slice(0);
+      result.incomingEdges[n] = source.incomingEdges[n].slice(0);
+    });
+    return result;
+  },
+  /**
+   * Get an array containing the nodes that the specified node depends on (transitively).
+   *
+   * Throws an Error if the graph has a cycle, or the specified node does not exist.
+   *
+   * If `leavesOnly` is true, only nodes that do not depend on any other nodes will be returned
+   * in the array.
+   */
+  dependenciesOf: function (node, leavesOnly) {
+    if (this.hasNode(node)) {
+      var result = [];
+      var DFS = createDFS(
+        this.outgoingEdges,
+        leavesOnly,
+        result,
+        this.circular
+      );
+      DFS(node);
+      var idx = result.indexOf(node);
+      if (idx >= 0) {
+        result.splice(idx, 1);
+      }
+      return result;
+    } else {
+      throw new Error('Node does not exist: ' + node);
+    }
+  },
+  /**
+   * get an array containing the nodes that depend on the specified node (transitively).
+   *
+   * Throws an Error if the graph has a cycle, or the specified node does not exist.
+   *
+   * If `leavesOnly` is true, only nodes that do not have any dependants will be returned in the array.
+   */
+  dependantsOf: function (node, leavesOnly) {
+    if (this.hasNode(node)) {
+      var result = [];
+      var DFS = createDFS(
+        this.incomingEdges,
+        leavesOnly,
+        result,
+        this.circular
+      );
+      DFS(node);
+      var idx = result.indexOf(node);
+      if (idx >= 0) {
+        result.splice(idx, 1);
+      }
+      return result;
+    } else {
+      throw new Error('Node does not exist: ' + node);
+    }
+  },
+  /**
+   * Construct the overall processing order for the dependency graph.
+   *
+   * Throws an Error if the graph has a cycle.
+   *
+   * If `leavesOnly` is true, only nodes that do not depend on any other nodes will be returned.
+   */
+  overallOrder: function (leavesOnly) {
+    var self = this;
+    var result = [];
+    var keys = Object.keys(this.nodes);
+    if (keys.length === 0) {
+      return result; // Empty graph
+    } else {
+      if (!this.circular) {
+        // Look for cycles - we run the DFS starting at all the nodes in case there
+        // are several disconnected subgraphs inside this dependency graph.
+        var CycleDFS = createDFS(this.outgoingEdges, false, [], this.circular);
+        keys.forEach(function (n) {
+          CycleDFS(n);
+        });
+      }
+
+      var DFS = createDFS(
+        this.outgoingEdges,
+        leavesOnly,
+        result,
+        this.circular
+      );
+      // Find all potential starting points (nodes with nothing depending on them) an
+      // run a DFS starting at these points to get the order
+      keys
+        .filter(function (node) {
+          return self.incomingEdges[node].length === 0;
+        })
+        .forEach(function (n) {
+          DFS(n);
+        });
+
+      // If we're allowing cycles - we need to run the DFS against any remaining
+      // nodes that did not end up in the initial result (as they are part of a
+      // subgraph that does not have a clear starting point)
+      if (this.circular) {
+        keys
+          .filter(function (node) {
+            return result.indexOf(node) === -1;
+          })
+          .forEach(function (n) {
+            DFS(n);
+          });
+      }
+
+      return result;
+    }
+  },
+
+  mapNodes(mapper) {},
+};
+
+/**
+ * Cycle error, including the path of the cycle.
+ */
+var DepGraphCycleError = (exports.DepGraphCycleError = function (cyclePath) {
+  var message = 'Dependency Cycle Found: ' + cyclePath.join(' -> ');
+  var instance = new Error(message);
+  instance.cyclePath = cyclePath;
+  Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(instance, DepGraphCycleError);
+  }
+  return instance;
+});
+DepGraphCycleError.prototype = Object.create(Error.prototype, {
+  constructor: {
+    value: Error,
+    enumerable: false,
+    writable: true,
+    configurable: true,
+  },
+});
+Object.setPrototypeOf(DepGraphCycleError, Error);
+
+export default DepGraph;
diff --git a/packages/server/src/lib/DynamicFilter/DynamicFilter.ts b/packages/server/src/lib/DynamicFilter/DynamicFilter.ts
new file mode 100644
index 000000000..2af4d7c4f
--- /dev/null
+++ b/packages/server/src/lib/DynamicFilter/DynamicFilter.ts
@@ -0,0 +1,91 @@
+import { forEach, uniqBy } from 'lodash';
+import DynamicFilterAbstructor from './DynamicFilterAbstructor';
+import { IDynamicFilter, IFilterRole, IModel } from '@/interfaces';
+
+export default class DynamicFilter extends DynamicFilterAbstructor{
+  private model: IModel;
+  private tableName: string;
+  private dynamicFilters: IDynamicFilter[];
+
+  /**
+   * Constructor.
+   * @param {String} tableName -
+   */
+  constructor(model) {
+    super();
+
+    this.model = model;
+    this.tableName = model.tableName;
+    this.dynamicFilters = [];
+  }
+
+  /**
+   * Registers the given dynamic filter.
+   * @param {IDynamicFilter} filterRole - Filter role.
+   */
+  public setFilter = (dynamicFilter: IDynamicFilter) => {
+    dynamicFilter.setModel(this.model);
+
+    dynamicFilter.onInitialize();
+
+    this.dynamicFilters.push(dynamicFilter);
+  }
+
+  /**
+   * Retrieve dynamic filter build queries.
+   * @returns 
+   */
+  private dynamicFiltersBuildQuery = () => {
+    return this.dynamicFilters.map((filter) => {
+      return filter.buildQuery()
+    });
+  }
+
+  /**
+   * Retrieve dynamic filter roles.
+   * @returns {IFilterRole[]}
+   */
+  private dynamicFilterTableColumns = (): IFilterRole[] => {
+    const localFilterRoles = [];
+
+    this.dynamicFilters.forEach((dynamicFilter) => {
+      const { filterRoles } = dynamicFilter;
+
+      localFilterRoles.push(
+        ...(Array.isArray(filterRoles) ? filterRoles : [filterRoles])
+      );
+    });
+    return localFilterRoles;
+  }
+
+  /**
+   * Builds queries of filter roles.
+   */
+  public buildQuery = () => {
+    const buildersCallbacks = this.dynamicFiltersBuildQuery();
+    const tableColumns = this.dynamicFilterTableColumns();
+
+    return (builder) => {
+      buildersCallbacks.forEach((builderCallback) => {
+        builderCallback(builder);
+      });
+      this.buildFilterRolesJoins(builder);
+    };
+  }
+
+  /**
+   * Retrieve response metadata from all filters adapters.
+   */
+  public getResponseMeta = () => {
+    const responseMeta = {};
+
+    this.dynamicFilters.forEach((filter) => {
+      const { responseMeta: filterMeta } = filter;
+
+      forEach(filterMeta, (value, key) => {
+        responseMeta[key] = value;
+      });
+    });
+    return responseMeta;
+  }
+}
diff --git a/packages/server/src/lib/DynamicFilter/DynamicFilterAbstructor.ts b/packages/server/src/lib/DynamicFilter/DynamicFilterAbstructor.ts
new file mode 100644
index 000000000..3b3f6dee1
--- /dev/null
+++ b/packages/server/src/lib/DynamicFilter/DynamicFilterAbstructor.ts
@@ -0,0 +1,50 @@
+
+export default class DynamicFilterAbstructor {
+  /**
+   * Extract relation table name from relation.
+   * @param {String} column -
+   * @return {String} - join relation table.
+   */
+  protected getTableFromRelationColumn = (column: string) => {
+    const splitedColumn = column.split('.');
+    return splitedColumn.length > 0 ? splitedColumn[0] : '';
+  };
+
+  /**
+   * Builds view roles join queries.
+   * @param {String} tableName - Table name.
+   * @param {Array} roles - Roles.
+   */
+  protected buildFilterRolesJoins = (builder) => {
+    this.dynamicFilters.forEach((dynamicFilter) => {
+      const relationsFields = dynamicFilter.relationFields;
+
+      this.buildFieldsJoinQueries(builder, relationsFields);
+    });
+  };
+
+  /**
+   * Builds join queries of fields.
+   * @param builder - 
+   * @param {string[]} fieldsRelations -
+   */
+  private buildFieldsJoinQueries = (builder, fieldsRelations: string[]) => {
+    fieldsRelations.forEach((fieldRelation) => {
+      const relation = this.model.relationMappings[fieldRelation];
+
+      if (relation) {
+        const splitToRelation = relation.join.to.split('.');
+        const relationTable = splitToRelation[0] || '';
+
+        builder.join(relationTable, relation.join.from, '=', relation.join.to);
+      }
+    });
+  };
+
+  /**
+   * Retrieve the dynamic filter mode.
+   */
+  protected getModel() {
+    return this.model;
+  }
+}
diff --git a/packages/server/src/lib/DynamicFilter/DynamicFilterAdvancedFilter.ts b/packages/server/src/lib/DynamicFilter/DynamicFilterAdvancedFilter.ts
new file mode 100644
index 000000000..e18560208
--- /dev/null
+++ b/packages/server/src/lib/DynamicFilter/DynamicFilterAdvancedFilter.ts
@@ -0,0 +1,27 @@
+import { IFilterRole } from '@/interfaces';
+import DynamicFilterFilterRoles from './DynamicFilterFilterRoles';
+
+export default class DynamicFilterAdvancedFilter extends DynamicFilterFilterRoles {
+  private filterRoles: IFilterRole[];
+
+  /**
+   * Constructor method.
+   * @param {Array} filterRoles -
+   * @param {Array} resourceFields -
+   */
+  constructor(filterRoles: IFilterRole[]) {
+    super();
+
+    this.filterRoles = filterRoles;
+    this.setResponseMeta();
+  }
+
+  /**
+   * Sets response meta.
+   */
+  private setResponseMeta() {
+    this.responseMeta = {
+      filterRoles: this.filterRoles,
+    };
+  }
+}
diff --git a/packages/server/src/lib/DynamicFilter/DynamicFilterFilterRoles.ts b/packages/server/src/lib/DynamicFilter/DynamicFilterFilterRoles.ts
new file mode 100644
index 000000000..ae0502e7e
--- /dev/null
+++ b/packages/server/src/lib/DynamicFilter/DynamicFilterFilterRoles.ts
@@ -0,0 +1,52 @@
+import DynamicFilterRoleAbstructor from './DynamicFilterRoleAbstructor';
+import { IFilterRole } from '@/interfaces';
+
+export default class FilterRoles extends DynamicFilterRoleAbstructor {
+  private filterRoles: IFilterRole[];
+
+  /**
+   * On initialize filter roles.
+   */
+  public onInitialize() {
+    super.onInitialize();
+    this.setFilterRolesRelations();
+  }
+
+  /**
+   * Builds filter roles logic expression.
+   * @return {string}
+   */
+  private buildLogicExpression(): string {
+    let expression = '';
+
+    this.filterRoles.forEach((role, index) => {
+      expression +=
+        index === 0 ? `${role.index} ` : `${role.condition} ${role.index} `;
+    });
+    return expression.trim();
+  }
+
+  /**
+   * Builds database query of view roles.
+   */
+  protected buildQuery() {
+    const logicExpression = this.buildLogicExpression();
+
+    return (builder) => {
+      this.buildFilterQuery(
+        this.model,
+        this.filterRoles,
+        logicExpression
+      )(builder);
+    };
+  }
+
+  /**
+   * Sets filter roles relations if field was relation type.
+   */
+  private setFilterRolesRelations() {
+    this.filterRoles.forEach((relationRole) => {
+      this.setRelationIfRelationField(relationRole.fieldKey);
+    });
+  }
+}
diff --git a/packages/server/src/lib/DynamicFilter/DynamicFilterQueryParser.ts b/packages/server/src/lib/DynamicFilter/DynamicFilterQueryParser.ts
new file mode 100644
index 000000000..d57f82030
--- /dev/null
+++ b/packages/server/src/lib/DynamicFilter/DynamicFilterQueryParser.ts
@@ -0,0 +1,72 @@
+import { OPERATION } from '../LogicEvaluation/Parser';
+
+export default class QueryParser {
+  constructor(tree, queries) {
+    this.tree = tree;
+    this.queries = queries;
+    this.query = null;
+  }
+
+  setQuery(query) {
+    this.query = query.clone();
+  }
+
+  parse() {
+    return this.parseNode(this.tree);
+  }
+
+  parseNode(node) {
+    if (typeof node === 'string') {
+      const nodeQuery = this.getQuery(node);
+      return (query) => {
+        nodeQuery(query);
+      };
+    }
+    if (OPERATION[node.operation] === undefined) {
+      throw new Error(`unknow expression ${node.operation}`);
+    }
+    const leftQuery = this.getQuery(node.left);
+    const rightQuery = this.getQuery(node.right);
+
+    switch (node.operation) {
+      case '&&':
+      case 'AND':
+      default:
+        return (nodeQuery) =>
+          nodeQuery.where((query) => {
+            query.where((q) => {
+              leftQuery(q);
+            });
+            query.andWhere((q) => {
+              rightQuery(q);
+            });
+          });
+      case '||':
+      case 'OR':
+        return (nodeQuery) =>
+          nodeQuery.where((query) => {
+            query.where((q) => {
+              leftQuery(q);
+            });
+            query.orWhere((q) => {
+              rightQuery(q);
+            });
+          });
+    }
+  }
+
+  getQuery(node) {
+    if (typeof node !== 'string' && node !== null) {
+      return this.parseNode(node);
+    }
+    const value = parseFloat(node);
+
+    if (!isNaN(value)) {
+      if (typeof this.queries[node] === 'undefined') {
+        throw new Error(`unknow query under index ${node}`);
+      }
+      return this.queries[node];
+    }
+    return null;
+  }
+}
diff --git a/packages/server/src/lib/DynamicFilter/DynamicFilterRoleAbstructor.ts b/packages/server/src/lib/DynamicFilter/DynamicFilterRoleAbstructor.ts
new file mode 100644
index 000000000..1dbc4f889
--- /dev/null
+++ b/packages/server/src/lib/DynamicFilter/DynamicFilterRoleAbstructor.ts
@@ -0,0 +1,387 @@
+import moment from 'moment';
+import * as R from 'ramda';
+import { IFilterRole, IDynamicFilter, IModel } from '@/interfaces';
+import Parser from '../LogicEvaluation/Parser';
+import DynamicFilterQueryParser from './DynamicFilterQueryParser';
+import { Lexer } from '../LogicEvaluation/Lexer';
+import { COMPARATOR_TYPE, FIELD_TYPE } from './constants';
+
+export default abstract class DynamicFilterAbstructor
+  implements IDynamicFilter
+{
+  protected filterRoles: IFilterRole[] = [];
+  protected tableName: string;
+  protected model: IModel;
+  protected responseMeta: { [key: string]: any } = {};
+  public relationFields = [];
+
+  /**
+   * Sets model the dynamic filter service.
+   * @param {IModel} model
+   */
+  public setModel(model: IModel) {
+    this.model = model;
+    this.tableName = model.tableName;
+  }
+
+  /**
+   * Transformes filter roles to map by index.
+   * @param {IModel} model
+   * @param {IFilterRole[]} roles
+   * @returns
+   */
+  protected convertRolesMapByIndex = (model, roles) => {
+    const rolesIndexSet = {};
+
+    roles.forEach((role) => {
+      rolesIndexSet[role.index] = this.buildRoleQuery(model, role);
+    });
+    return rolesIndexSet;
+  };
+
+  /**
+   * Builds database query from stored view roles.
+   * @param {Array} roles -
+   * @return {Function}
+   */
+  protected buildFilterRolesQuery = (
+    model: IModel,
+    roles: IFilterRole[],
+    logicExpression: string = ''
+  ) => {
+    const rolesIndexSet = this.convertRolesMapByIndex(model, roles);
+
+    // Lexer for logic expression.
+    const lexer = new Lexer(logicExpression);
+    const tokens = lexer.getTokens();
+
+    // Parse the logic expression.
+    const parser = new Parser(tokens);
+    const parsedTree = parser.parse();
+
+    const queryParser = new DynamicFilterQueryParser(parsedTree, rolesIndexSet);
+
+    return queryParser.parse();
+  };
+
+  /**
+   * Parses the logic expression to base expression.
+   * @param {string} logicExpression - 
+   * @return {string}
+   */
+  private parseLogicExpression(logicExpression: string): string {
+    return R.compose(
+      R.replace(/or|OR/g, '||'),
+      R.replace(/and|AND/g, '&&'),
+    )(logicExpression);
+  }
+
+  /**
+   * Builds filter query for query builder.
+   * @param {String} tableName - Table name.
+   * @param {Array} roles - Filter roles.
+   * @param {String} logicExpression - Logic expression.
+   */
+  protected buildFilterQuery = (
+    model: IModel,
+    roles: IFilterRole[],
+    logicExpression: string
+  ) => {
+    const basicExpression = this.parseLogicExpression(logicExpression);
+
+    return (builder) => {
+      this.buildFilterRolesQuery(model, roles, basicExpression)(builder);
+    };
+  };
+
+  /**
+   * Retrieve relation column of comparator fieldز
+   */
+  private getFieldComparatorRelationColumn(field) {
+    const relation = this.model.relationMappings[field.relationKey];
+
+    if (relation) {
+      const relationModel = relation.modelClass;
+      const relationColumn =
+        field.relationEntityKey === 'id'
+          ? 'id'
+          : relationModel.getField(field.relationEntityKey, 'column');
+
+      return `${relationModel.tableName}.${relationColumn}`;
+    }
+  }
+
+  /**
+   * Retrieve the comparator field column.
+   * @param {IModel} model -
+   * @param {} -
+   */
+  private getFieldComparatorColumn = (field) => {
+    return field.fieldType === FIELD_TYPE.RELATION
+      ? this.getFieldComparatorRelationColumn(field)
+      : `${this.tableName}.${field.column}`;
+  };
+
+  /**
+   * Builds roles queries.
+   * @param {IModel} model -
+   * @param {Object} role -
+   */
+  protected buildRoleQuery = (model: IModel, role: IFilterRole) => {
+    const field = model.getField(role.fieldKey);
+    const comparatorColumn = this.getFieldComparatorColumn(field);
+
+    // Field relation custom query.
+    if (typeof field.filterCustomQuery !== 'undefined') {
+      return (builder) => {
+        field.filterCustomQuery(builder, role);
+      };
+    }
+    switch (field.fieldType) {
+      case FIELD_TYPE.BOOLEAN:
+      case FIELD_TYPE.ENUMERATION:
+        return this.booleanRoleQueryBuilder(role, comparatorColumn);
+      case FIELD_TYPE.NUMBER:
+        return this.numberRoleQueryBuilder(role, comparatorColumn);
+      case FIELD_TYPE.DATE:
+        return this.dateQueryBuilder(role, comparatorColumn);
+      case FIELD_TYPE.TEXT:
+      default:
+        return this.textRoleQueryBuilder(role, comparatorColumn);
+    }
+  };
+
+  /**
+   * Boolean column query builder.
+   * @param {IFilterRole} role
+   * @param {string} comparatorColumn
+   * @returns
+   */
+  protected booleanRoleQueryBuilder = (
+    role: IFilterRole,
+    comparatorColumn: string
+  ) => {
+    switch (role.comparator) {
+      case COMPARATOR_TYPE.EQUALS:
+      case COMPARATOR_TYPE.EQUAL:
+      case COMPARATOR_TYPE.IS:
+      default:
+        return (builder) => {
+          builder.where(comparatorColumn, '=', role.value);
+        };
+      case COMPARATOR_TYPE.NOT_EQUAL:
+      case COMPARATOR_TYPE.NOT_EQUALS:
+      case COMPARATOR_TYPE.IS_NOT:
+        return (builder) => {
+          builder.where(comparatorColumn, '<>', role.value);
+        };
+    }
+  };
+
+  /**
+   * Numeric column query builder.
+   * @param {IFilterRole} role
+   * @param {string} comparatorColumn
+   * @returns
+   */
+  protected numberRoleQueryBuilder = (
+    role: IFilterRole,
+    comparatorColumn: string
+  ) => {
+    switch (role.comparator) {
+      case COMPARATOR_TYPE.EQUALS:
+      case COMPARATOR_TYPE.EQUAL:
+      default:
+        return (builder) => {
+          builder.where(comparatorColumn, '=', role.value);
+        };
+      case COMPARATOR_TYPE.NOT_EQUAL:
+      case COMPARATOR_TYPE.NOT_EQUALS:
+        return (builder) => {
+          builder.whereNot(comparatorColumn, role.value);
+        };
+      case COMPARATOR_TYPE.BIGGER_THAN:
+      case COMPARATOR_TYPE.BIGGER:
+        return (builder) => {
+          builder.where(comparatorColumn, '>', role.value);
+        };
+      case COMPARATOR_TYPE.BIGGER_OR_EQUALS:
+        return (builder) => {
+          builder.where(comparatorColumn, '>=', role.value);
+        };
+      case COMPARATOR_TYPE.SMALLER_THAN:
+      case COMPARATOR_TYPE.SMALLER:
+        return (builder) => {
+          builder.where(comparatorColumn, '<', role.value);
+        };
+      case COMPARATOR_TYPE.SMALLER_OR_EQUALS:
+        return (builder) => {
+          builder.where(comparatorColumn, '<=', role.value);
+        };
+    }
+  };
+
+  /**
+   * Text column query builder.
+   * @param {IFilterRole} role
+   * @param {string} comparatorColumn
+   * @returns {Function}
+   */
+  protected textRoleQueryBuilder = (
+    role: IFilterRole,
+    comparatorColumn: string
+  ) => {
+    switch (role.comparator) {
+      case COMPARATOR_TYPE.EQUAL:
+      case COMPARATOR_TYPE.EQUALS:
+      case COMPARATOR_TYPE.IS:
+      default:
+        return (builder) => {
+          builder.where(comparatorColumn, role.value);
+        };
+      case COMPARATOR_TYPE.NOT_EQUALS:
+      case COMPARATOR_TYPE.NOT_EQUAL:
+      case COMPARATOR_TYPE.IS_NOT:
+        return (builder) => {
+          builder.whereNot(comparatorColumn, role.value);
+        };
+      case COMPARATOR_TYPE.CONTAIN:
+      case COMPARATOR_TYPE.CONTAINS:
+        return (builder) => {
+          builder.where(comparatorColumn, 'LIKE', `%${role.value}%`);
+        };
+      case COMPARATOR_TYPE.NOT_CONTAIN:
+      case COMPARATOR_TYPE.NOT_CONTAINS:
+        return (builder) => {
+          builder.whereNot(comparatorColumn, 'LIKE', `%${role.value}%`);
+        };
+      case COMPARATOR_TYPE.STARTS_WITH:
+      case COMPARATOR_TYPE.START_WITH:
+        return (builder) => {
+          builder.where(comparatorColumn, 'LIKE', `${role.value}%`);
+        };
+      case COMPARATOR_TYPE.ENDS_WITH:
+      case COMPARATOR_TYPE.END_WITH:
+        return (builder) => {
+          builder.where(comparatorColumn, 'LIKE', `%${role.value}`);
+        };
+
+    }
+  };
+
+  /**
+   * Date column query builder.
+   * @param {IFilterRole} role
+   * @param {string} comparatorColumn
+   * @returns {Function}
+   */
+  protected dateQueryBuilder = (
+    role: IFilterRole,
+    comparatorColumn: string
+  ) => {
+    switch (role.comparator) {
+      case COMPARATOR_TYPE.AFTER:
+      case COMPARATOR_TYPE.BEFORE:
+        return (builder) => {
+          this.dateQueryAfterBeforeComparator(role, comparatorColumn, builder);
+        };
+      case COMPARATOR_TYPE.IN:
+        return (builder) => {
+          this.dateQueryInComparator(role, comparatorColumn, builder);
+        };
+    }
+  };
+
+  /**
+   * Date query 'IN' comparator type.
+   * @param {IFilterRole} role
+   * @param {string} comparatorColumn
+   * @param builder
+   */
+  protected dateQueryInComparator = (
+    role: IFilterRole,
+    comparatorColumn: string,
+    builder
+  ) => {
+    const hasTimeFormat = moment(
+      role.value,
+      'YYYY-MM-DD HH:MM',
+      true
+    ).isValid();
+    const dateFormat = 'YYYY-MM-DD HH:MM:SS';
+
+    if (hasTimeFormat) {
+      const targetDateTime = moment(role.value).format(dateFormat);
+      builder.where(comparatorColumn, '=', targetDateTime);
+    } else {
+      const startDate = moment(role.value).startOf('day');
+      const endDate = moment(role.value).endOf('day');
+
+      builder.where(comparatorColumn, '>=', startDate.format(dateFormat));
+      builder.where(comparatorColumn, '<=', endDate.format(dateFormat));
+    }
+  };
+
+  /**
+   * Date query after/before comparator type.
+   * @param {IFilterRole} role
+   * @param {string} comparatorColumn - Column.
+   * @param builder
+   */
+  protected dateQueryAfterBeforeComparator = (
+    role: IFilterRole,
+    comparatorColumn: string,
+    builder
+  ) => {
+    const comparator = role.comparator === COMPARATOR_TYPE.BEFORE ? '<' : '>';
+    const hasTimeFormat = moment(
+      role.value,
+      'YYYY-MM-DD HH:MM',
+      true
+    ).isValid();
+    const targetDate = moment(role.value);
+    const dateFormat = 'YYYY-MM-DD HH:MM:SS';
+
+    if (!hasTimeFormat) {
+      if (role.comparator === COMPARATOR_TYPE.BEFORE) {
+        targetDate.startOf('day');
+      } else {
+        targetDate.endOf('day');
+      }
+    }
+    const comparatorValue = targetDate.format(dateFormat);
+    builder.where(comparatorColumn, comparator, comparatorValue);
+  };
+
+  /**
+   * Registers relation field if the given field was relation type
+   * and not registered.
+   * @param {string} fieldKey - Field key.
+   */
+  protected setRelationIfRelationField = (fieldKey: string): void => {
+    const field = this.model.getField(fieldKey);
+    const isAlreadyRegistered = this.relationFields.some(
+      (field) => field === fieldKey
+    );
+
+    if (
+      !isAlreadyRegistered &&
+      field &&
+      field.fieldType === FIELD_TYPE.RELATION
+    ) {
+      this.relationFields.push(field.relationKey);
+    }
+  };
+
+  /**
+   * Retrieve the model.
+   */
+  getModel() {
+    return this.model;
+  }
+
+  /**
+   * On initialize the registered dynamic filter.
+   */
+  onInitialize() {}
+}
diff --git a/packages/server/src/lib/DynamicFilter/DynamicFilterSearch.ts b/packages/server/src/lib/DynamicFilter/DynamicFilterSearch.ts
new file mode 100644
index 000000000..3e8650872
--- /dev/null
+++ b/packages/server/src/lib/DynamicFilter/DynamicFilterSearch.ts
@@ -0,0 +1,48 @@
+import { IFilterRole } from '@/interfaces';
+import DynamicFilterFilterRoles from './DynamicFilterFilterRoles';
+
+export default class DynamicFilterSearch extends DynamicFilterFilterRoles {
+  private searchKeyword: string;
+  private filterRoles: IFilterRole[];
+
+  /**
+   * Constructor method.
+   * @param {string} searchKeyword - Search keyword.
+   */
+  constructor(searchKeyword: string) {
+    super();
+    this.searchKeyword = searchKeyword;
+  }
+
+  /**
+   * On initialize the dynamic filter.
+   */
+  public onInitialize() {
+    super.onInitialize();
+    this.filterRoles = this.getModelSearchFilterRoles(this.searchKeyword);
+  }
+
+  /**
+   * Retrieve the filter roles from model search roles.
+   * @param {string} searchKeyword 
+   * @returns {IFilterRole[]}
+   */
+  private getModelSearchFilterRoles(searchKeyword: string): IFilterRole[] {
+    const model = this.getModel();
+
+    return model.searchRoles.map((searchRole, index) => ({
+      ...searchRole,
+      value: searchKeyword,
+      index: index + 1,
+    }));
+  }
+
+  /**
+   * 
+   */
+  setResponseMeta() {
+    this.responseMeta = {
+      searchKeyword: this.searchKeyword,
+    };
+  }
+}
diff --git a/packages/server/src/lib/DynamicFilter/DynamicFilterSortBy.ts b/packages/server/src/lib/DynamicFilter/DynamicFilterSortBy.ts
new file mode 100644
index 000000000..f1ab6c7fc
--- /dev/null
+++ b/packages/server/src/lib/DynamicFilter/DynamicFilterSortBy.ts
@@ -0,0 +1,92 @@
+import DynamicFilterRoleAbstructor from '@/lib/DynamicFilter/DynamicFilterRoleAbstructor';
+import { FIELD_TYPE } from './constants';
+
+interface ISortRole {
+  fieldKey: string;
+  order: string;
+}
+
+export default class DynamicFilterSortBy extends DynamicFilterRoleAbstructor {
+  private sortRole: ISortRole = {};
+
+  /**
+   * Constructor method.
+   * @param {string} sortByFieldKey
+   * @param {string} sortDirection
+   */
+  constructor(sortByFieldKey: string, sortDirection: string) {
+    super();
+
+    this.sortRole = {
+      fieldKey: sortByFieldKey,
+      order: sortDirection,
+    };
+    this.setResponseMeta();
+  }
+
+  /**
+   * On initialize the dyanmic sort by.
+   */
+  public onInitialize() {
+    this.setRelationIfRelationField(this.sortRole.fieldKey);
+  }
+
+  /**
+   * Retrieve field comparator relatin column.
+   * @param field 
+   * @returns {string}
+   */
+  private getFieldComparatorRelationColumn = (field): string => {
+    const relation = this.model.relationMappings[field.relationKey];
+
+    if (relation) {
+      const relationModel = relation.modelClass;
+      const relationField = relationModel.getField(field.relationEntityLabel);
+
+      return `${relationModel.tableName}.${relationField.column}`;
+    }
+    return '';
+  };
+
+  /**
+   * Retrieve the comparator field column.
+   * @param {IModel} field
+   * @returns {string}
+   */
+  private getFieldComparatorColumn = (field): string => {
+    return field.fieldType === FIELD_TYPE.RELATION
+      ? this.getFieldComparatorRelationColumn(field)
+      : `${this.tableName}.${field.column}`;
+  };
+
+  /**
+   * Builds database query of sort by column on the given direction.
+   */
+  public buildQuery = () => {
+    const field = this.model.getField(this.sortRole.fieldKey);
+    const comparatorColumn = this.getFieldComparatorColumn(field);
+
+    // Sort custom query.
+    if (typeof field.sortCustomQuery !== 'undefined') {
+      return (builder) => {
+        field.sortCustomQuery(builder, this.sortRole);
+      };
+    }
+
+    return (builder) => {
+      if (this.sortRole.fieldKey) {
+        builder.orderBy(`${comparatorColumn}`, this.sortRole.order);
+      }
+    };
+  };
+
+  /**
+   * Sets response meta.
+   */
+  public setResponseMeta() {
+    this.responseMeta = {
+      sortOrder: this.sortRole.fieldKey,
+      sortBy: this.sortRole.order,
+    };
+  }
+}
diff --git a/packages/server/src/lib/DynamicFilter/DynamicFilterViews.ts b/packages/server/src/lib/DynamicFilter/DynamicFilterViews.ts
new file mode 100644
index 000000000..40e95c5b4
--- /dev/null
+++ b/packages/server/src/lib/DynamicFilter/DynamicFilterViews.ts
@@ -0,0 +1,56 @@
+import { omit } from 'lodash';
+import { IView, IViewRole } from '@/interfaces';
+import DynamicFilterRoleAbstructor from './DynamicFilterRoleAbstructor';
+
+export default class DynamicFilterViews extends DynamicFilterRoleAbstructor {
+  private viewSlug: string;
+  private logicExpression: string;
+  private filterRoles: IViewRole[];
+  private viewColumns = [];
+
+  /**
+   * Constructor method.
+   * @param {IView} view -
+   */
+  constructor(view: IView) {
+    super();
+
+    this.viewSlug = view.slug;
+    this.filterRoles = view.roles;
+    this.viewColumns = view.columns;
+    this.logicExpression = view.rolesLogicExpression
+      .replace('AND', '&&')
+      .replace('OR', '||');
+
+    this.setResponseMeta();
+  }
+
+  /**
+   * Builds database query of view roles.
+   */
+  public buildQuery() {
+    return (builder) => {
+      this.buildFilterQuery(
+        this.model,
+        this.filterRoles,
+        this.logicExpression
+      )(builder);
+    };
+  }
+
+  /**
+   * Sets response meta.
+   */
+  public setResponseMeta() {
+    this.responseMeta = {
+      view: {
+        logicExpression: this.logicExpression,
+        filterRoles: this.filterRoles.map((filterRole) => ({
+          ...omit(filterRole, ['id', 'viewId']),
+        })),
+        viewSlug: this.viewSlug,
+        viewColumns: this.viewColumns,
+      },
+    };
+  }
+}
diff --git a/packages/server/src/lib/DynamicFilter/constants.ts b/packages/server/src/lib/DynamicFilter/constants.ts
new file mode 100644
index 000000000..f845e16c9
--- /dev/null
+++ b/packages/server/src/lib/DynamicFilter/constants.ts
@@ -0,0 +1,43 @@
+export const COMPARATOR_TYPE = {
+  EQUAL: 'equal',
+  EQUALS: 'equals',
+
+  NOT_EQUAL: 'not_equal',
+  NOT_EQUALS: 'not_equals',
+
+  BIGGER_THAN: 'bigger_than',
+  BIGGER: 'bigger',
+  BIGGER_OR_EQUALS: 'bigger_or_equals',
+
+  SMALLER_THAN: 'smaller_than',
+  SMALLER: 'smaller',
+  SMALLER_OR_EQUALS: 'smaller_or_equals',
+
+  IS: 'is',
+  IS_NOT: 'is_not',
+
+  CONTAINS: 'contains',
+  CONTAIN: 'contain',
+  NOT_CONTAINS: 'contains',
+  NOT_CONTAIN: 'contain',
+
+  AFTER: 'after',
+  BEFORE: 'before',
+  IN: 'in',
+
+  STARTS_WITH: 'starts_with',
+  START_WITH: 'start_with',
+
+  ENDS_WITH: 'ends_with',
+  END_WITH: 'end_with'
+};
+
+export const FIELD_TYPE = {
+  TEXT: 'text',
+  NUMBER: 'number',
+  ENUMERATION: 'enumeration',
+  BOOLEAN: 'boolean',
+  RELATION: 'relation',
+  DATE: 'date',
+  COMPUTED: 'computed'
+};
diff --git a/packages/server/src/lib/DynamicFilter/index.ts b/packages/server/src/lib/DynamicFilter/index.ts
new file mode 100644
index 000000000..10cc6221c
--- /dev/null
+++ b/packages/server/src/lib/DynamicFilter/index.ts
@@ -0,0 +1,13 @@
+
+
+import DynamicFilter from './DynamicFilter';
+import DynamicFilterSortBy from './DynamicFilterSortBy';
+import DynamicFilterViews from './DynamicFilterViews';
+import DynamicFilterFilterRoles from './DynamicFilterFilterRoles';
+
+export {
+  DynamicFilter,
+  DynamicFilterSortBy,
+  DynamicFilterViews,
+  DynamicFilterFilterRoles,
+};
\ No newline at end of file
diff --git a/packages/server/src/lib/EventPublisher/EventPublisher.ts b/packages/server/src/lib/EventPublisher/EventPublisher.ts
new file mode 100644
index 000000000..23a3b7103
--- /dev/null
+++ b/packages/server/src/lib/EventPublisher/EventPublisher.ts
@@ -0,0 +1,66 @@
+import { Container } from 'typedi';
+import { EventEmitter2 } from 'eventemitter2';
+
+interface IEventPublisherArgs {
+  subscribers: EventSubscriber[];
+}
+class PublishEvent {
+  constructor(public id: string) {}
+}
+
+type SubscribeListenerFunction = (event: PublishEvent) => void;
+type SubscribeFunction = (id: string, cb: SubscribeListenerFunction) => void;
+
+interface IEventBus {
+  subscribe: SubscribeFunction;
+}
+
+export abstract class EventSubscriber {
+  abstract attach(bus: IEventBus): void;
+}
+
+export class EventPublisher {
+  private emitter: EventEmitter2;
+
+  /**
+   *
+   * @param {IEventPublisherArgs} args
+   */
+  constructor() {
+    this.emitter = new EventEmitter2({ wildcard: true, delimiter: '.' });
+  }
+
+  /**
+   *
+   * @param {EventSubscriber} args
+   */
+  loadSubscribers(subscribers: EventSubscriber[]) {
+    const bus: IEventBus = {
+      subscribe: (id, cb) => {
+        this.emitter.on(id, cb);
+      },
+    };
+    for (const Subscriber of subscribers) {
+      const subscriberInstance = Container.get(Subscriber);
+      subscriberInstance.attach(bus);
+    }
+  }
+
+  /**
+   *
+   * @param event
+   * @param payload
+   */
+  emit(event: string, payload) {
+    return this.emitter.emit(event, payload);
+  }
+
+  /**
+   *
+   * @param event
+   * @param payload
+   */
+  emitAsync(event: string, payload) {
+    return this.emitter.emitAsync(event, payload);
+  }
+}
diff --git a/packages/server/src/lib/KnexFactory/index.js b/packages/server/src/lib/KnexFactory/index.js
new file mode 100644
index 000000000..866af6eae
--- /dev/null
+++ b/packages/server/src/lib/KnexFactory/index.js
@@ -0,0 +1,55 @@
+const { extend, isFunction, isObject } = require('lodash');
+
+export default class KnexFactory {
+
+  constructor(knex) {
+    this.knex = knex;
+
+    this.factories = [];
+  }
+
+  define(name, tableName, defaultAttributes) {
+    this.factories[name] = { tableName, defaultAttributes };
+  }
+
+  async build(factoryName, attributes) {
+    const factory = this.factories[factoryName];
+
+    if (!factory) {
+      throw `Unkown factory: ${factoryName}`;
+    }
+    let { defaultAttributes } = factory;
+    const insertData = {};
+    
+    if( 'function' === typeof defaultAttributes) {
+      defaultAttributes = await defaultAttributes();
+    }
+    extend(insertData, defaultAttributes, attributes);
+
+    for (let k in insertData) {
+      const v = insertData[k];
+
+      if (isFunction(v)) {
+        insertData[k] = await v();
+      } else {
+        insertData[k] = await v;
+      }
+      if (isObject(insertData[k]) && insertData[k].id) {
+        insertData[k] = insertData[k].id;
+      }
+    };
+
+    return insertData;
+  }
+
+  async create(factoryName, attributes) {
+    const factory = this.factories[factoryName];
+    const insertData = await this.build(factoryName, attributes);
+    const { tableName } = factory;
+
+    const [id] = await this.knex(tableName).insert(insertData);
+    const record = await this.knex(tableName).where({ id }).first();
+
+    return record;
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/lib/LogicEvaluation/Lexer.js b/packages/server/src/lib/LogicEvaluation/Lexer.js
new file mode 100644
index 000000000..3cfc04f41
--- /dev/null
+++ b/packages/server/src/lib/LogicEvaluation/Lexer.js
@@ -0,0 +1,172 @@
+
+const OperationType = {
+  LOGIC: 'LOGIC',
+  STRING: 'STRING',
+  COMPARISON: 'COMPARISON',
+  MATH: 'MATH',
+};
+
+export class Lexer {
+  // operation table
+  static get optable() {
+    return {
+      '=': OperationType.LOGIC,
+      '&': OperationType.LOGIC,
+      '|': OperationType.LOGIC,
+      '?': OperationType.LOGIC,
+      ':': OperationType.LOGIC,
+
+      '\'': OperationType.STRING,
+      '"': OperationType.STRING,
+
+      '!': OperationType.COMPARISON,
+      '>': OperationType.COMPARISON,
+      '<': OperationType.COMPARISON,
+
+      '(': OperationType.MATH,
+      ')': OperationType.MATH,
+      '+': OperationType.MATH,
+      '-': OperationType.MATH,
+      '*': OperationType.MATH,
+      '/': OperationType.MATH,
+      '%': OperationType.MATH,
+    };
+  }
+
+  /**
+   * Constructor
+   * @param {*} expression -
+   */
+  constructor(expression) {
+    this.currentIndex = 0;
+    this.input = expression;
+    this.tokenList = [];
+  }
+
+  getTokens() {
+    let tok;
+    do {
+      // read current token, so step should be -1
+      tok = this.pickNext(-1);
+      const pos = this.currentIndex;
+      switch (Lexer.optable[tok]) {
+        case OperationType.LOGIC:
+          // == && || ===
+          this.readLogicOpt(tok);
+          break;
+
+        case OperationType.STRING:
+          this.readString(tok);
+          break;
+
+        case OperationType.COMPARISON:
+          this.readCompare(tok);
+          break;
+
+        case OperationType.MATH:
+          this.receiveToken();
+          break;
+
+        default:
+          this.readValue(tok);
+      }
+
+      // if the pos not changed, this loop will go into a infinite loop, every step of while loop,
+      // we must move the pos forward
+      // so here we should throw error, for example `1 & 2`
+      if (pos === this.currentIndex && tok !== undefined) {
+        const err = new Error(`unkonw token ${tok} from input string ${this.input}`);
+        err.name = 'UnknowToken';
+        throw err;
+      }
+    } while (tok !== undefined)
+
+    return this.tokenList;
+  }
+
+  /**
+   * read next token, the index param can set next step, default go foward 1 step
+   *
+   * @param index next postion
+   */
+  pickNext(index = 0) {
+    return this.input[index + this.currentIndex + 1];
+  }
+
+  /**
+   * Store token into result tokenList, and move the pos index
+   *
+   * @param index
+   */
+  receiveToken(index = 1) {
+    const tok = this.input.slice(this.currentIndex, this.currentIndex + index).trim();
+    // skip empty string
+    if (tok) {
+      this.tokenList.push(tok);
+    }
+
+    this.currentIndex += index;
+  }
+
+  // ' or "
+  readString(tok) {
+    let next;
+    let index = 0;
+    do {
+      next = this.pickNext(index);
+      index += 1;
+    } while (next !== tok && next !== undefined);
+    this.receiveToken(index + 1);
+  }
+
+  // > or < or >= or <= or !==
+  // tok in (>, <, !)
+  readCompare(tok) {
+    if (this.pickNext() !== '=') {
+      this.receiveToken(1);
+      return;
+    }
+    // !==
+    if (tok === '!' && this.pickNext(1) === '=') {
+      this.receiveToken(3);
+      return;
+    }
+    this.receiveToken(2);
+  }
+
+  // === or ==
+  // && ||
+  readLogicOpt(tok) {
+    if (this.pickNext() === tok) {
+      // ===
+      if (tok === '=' && this.pickNext(1) === tok) {
+        return this.receiveToken(3);
+      }
+      // == && ||
+      return this.receiveToken(2);
+    }
+    // handle as &&
+    // a ? b : c is equal to a && b || c
+    if (tok === '?' || tok === ':') {
+      return this.receiveToken(1);
+    }
+  }
+
+  readValue(tok) {
+    if (!tok) {
+      return;
+    }
+
+    let index = 0;
+    while (!Lexer.optable[tok] && tok !== undefined) {
+      tok = this.pickNext(index);
+      index += 1;
+    }
+    this.receiveToken(index);
+  }
+}
+
+export default function token(expression) {
+  const lexer = new Lexer(expression);
+  return lexer.getTokens();
+}
diff --git a/packages/server/src/lib/LogicEvaluation/Parser.js b/packages/server/src/lib/LogicEvaluation/Parser.js
new file mode 100644
index 000000000..8e7156592
--- /dev/null
+++ b/packages/server/src/lib/LogicEvaluation/Parser.js
@@ -0,0 +1,159 @@
+export const OPERATION = {
+  '!': 5,
+  '*': 4,
+  '/': 4,
+  '%': 4,
+  '+': 3,
+  '-': 3,
+  '>': 2,
+  '<': 2,
+  '>=': 2,
+  '<=': 2,
+  '===': 2,
+  '!==': 2,
+  '==': 2,
+  '!=': 2,
+  '&&': 1,
+  '||': 1,
+  '?': 1,
+  ':': 1,
+};
+
+// export interface Node {
+//   left: Node | string | null;
+//   right: Node | string | null;
+//   operation: string;
+//   grouped?: boolean;
+// };
+
+export default class Parser {
+
+  constructor(token) {
+    this.index = -1;
+    this.blockLevel = 0;
+    this.token = token;
+  }
+
+  /**
+   * 
+   * @return {Node | string} =- 
+   */
+  parse() {
+    let tok;
+    let root = {
+      left: null,
+      right: null,
+      operation: null,
+    };
+
+    do {
+      tok = this.parseStatement();
+
+      if (tok === null || tok === undefined) {
+        break;
+      }
+
+      if (root.left === null) {
+        root.left = tok;
+        root.operation = this.nextToken();
+
+        if (!root.operation) {
+          return tok;
+        }
+
+        root.right = this.parseStatement();
+      } else {
+        if (typeof tok !== 'string') {
+          throw new Error('operation must be string, but get ' + JSON.stringify(tok));
+        }
+        root = this.addNode(tok, this.parseStatement(), root);
+      }
+    } while (tok);
+
+    return root;
+  }
+
+  nextToken() {
+    this.index += 1;
+    return this.token[this.index];
+  }
+
+  prevToken() {
+    return this.token[this.index - 1];
+  }
+
+  /**
+   * 
+   * @param {string} operation 
+   * @param {Node|String|null} right 
+   * @param {Node} root 
+   */
+  addNode(operation, right, root) {
+    let pre = root;
+    
+    if (this.compare(pre.operation, operation) < 0 && !pre.grouped) {
+      
+      while (pre.right !== null &&
+        typeof pre.right !== 'string' &&
+        this.compare(pre.right.operation, operation) < 0 && !pre.right.grouped) {
+        pre = pre.right;
+      }
+
+      pre.right = {
+        operation,
+        left: pre.right,
+        right,
+      };
+      return root;
+    }
+    return {
+      left: pre,
+      right,
+      operation,
+    }
+  }
+
+  /**
+   * 
+   * @param {String} a 
+   * @param {String} b 
+   */
+  compare(a, b) {
+    if (!OPERATION.hasOwnProperty(a) || !OPERATION.hasOwnProperty(b)) {
+      throw new Error(`unknow operation ${a} or ${b}`);
+    }
+    return OPERATION[a] - OPERATION[b];
+  }
+
+  /**
+   * @return string | Node | null
+   */
+  parseStatement() {
+    const token = this.nextToken();
+    if (token === '(') {
+      this.blockLevel += 1;
+      const node = this.parse();
+      this.blockLevel -= 1;
+
+      if (typeof node !== 'string') {
+        node.grouped = true;
+      }
+      return node;
+    }
+
+    if (token === ')') {
+      return null;
+    }
+
+    if (token === '!') {
+      return { left: null, operation: token, right: this.parseStatement() }
+    }
+
+    // 3 > -12 or -12 + 10
+    if (token === '-' && (OPERATION[this.prevToken()] > 0 || this.prevToken() === undefined)) {
+      return { left: '0', operation: token, right: this.parseStatement(), grouped: true };
+    }
+
+    return token;
+  }
+}
diff --git a/packages/server/src/lib/LogicEvaluation/QueryParser.js b/packages/server/src/lib/LogicEvaluation/QueryParser.js
new file mode 100644
index 000000000..cd31c128d
--- /dev/null
+++ b/packages/server/src/lib/LogicEvaluation/QueryParser.js
@@ -0,0 +1,61 @@
+import { OPERATION } from './Parser';
+
+export default class QueryParser {
+
+  constructor(tree, queries) {
+    this.tree = tree;
+    this.queries = queries;
+    this.query = null;
+  }
+
+  setQuery(query) {
+    this.query = query.clone();
+  }
+
+  parse() {
+    return this.parseNode(this.tree);
+  }
+
+  parseNode(node) {
+    if (typeof node === 'string') {
+      const nodeQuery = this.getQuery(node);
+      return (query) => { nodeQuery(query); };
+    }
+    if (OPERATION[node.operation] === undefined) {
+      throw new Error(`unknow expression ${node.operation}`);
+    }
+    const leftQuery = this.getQuery(node.left);
+    const rightQuery = this.getQuery(node.right);
+
+    switch (node.operation) {
+      case '&&':
+      case 'AND':
+      default:
+        return (nodeQuery) => nodeQuery.where((query) => {
+          query.where((q) => { leftQuery(q); });
+          query.andWhere((q) => { rightQuery(q); });
+        });
+      case '||':
+      case 'OR':
+        return (nodeQuery) => nodeQuery.where((query) => {
+          query.where((q) => { leftQuery(q); });
+          query.orWhere((q) => { rightQuery(q); });
+        });
+    }
+  }
+
+  getQuery(node) {
+    if (typeof node !== 'string' && node !== null) {
+      return this.parseNode(node);
+    }
+    const value = parseFloat(node);
+
+    if (!isNaN(value)) {
+      if (typeof this.queries[node] === 'undefined') {
+        throw new Error(`unknow query under index ${node}`);
+      }
+      return this.queries[node];
+    }
+    return null;
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/lib/Mail/index.ts b/packages/server/src/lib/Mail/index.ts
new file mode 100644
index 000000000..212366f33
--- /dev/null
+++ b/packages/server/src/lib/Mail/index.ts
@@ -0,0 +1,115 @@
+import fs from 'fs';
+import Mustache from 'mustache';
+import { Container } from 'typedi';
+import path from 'path';
+import { IMailable } from '@/interfaces';
+
+interface IMailAttachment {
+  filename: string;
+  path: string;
+  cid: string;
+}
+
+export default class Mail {
+  view: string;
+  subject: string;
+  to: string;
+  from: string = `${process.env.MAIL_FROM_NAME} ${process.env.MAIL_FROM_ADDRESS}`;
+  data: { [key: string]: string | number };
+  attachments: IMailAttachment[];
+
+  /**
+   * Mail options.
+   */
+  private get mailOptions() {
+    return {
+      to: this.to,
+      from: this.from,
+      subject: this.subject,
+      html: this.render(this.data),
+      attachments: this.attachments,
+    };
+  }
+
+  /**
+   * Sends the given mail to the target address.
+   */
+  public send() {
+    return new Promise((resolve, reject) => {
+      const Mail = Container.get('mail');
+
+      Mail.sendMail(this.mailOptions, (error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(true);
+      });
+    });
+  }
+
+  /**
+   * Set send mail to address.
+   * @param {string} to -
+   */
+  setTo(to: string) {
+    this.to = to;
+    return this;
+  }
+
+  /**
+   * Sets from address to the mail.
+   * @param {string} from
+   * @return {}
+   */
+  private setFrom(from: string) {
+    this.from = from;
+    return this;
+  }
+
+  setAttachments(attachments: IMailAttachment[]) {
+    this.attachments = attachments;
+    return this;
+  }
+
+  /**
+   * Set mail subject.
+   * @param {string} subject
+   */
+  setSubject(subject: string) {
+    this.subject = subject;
+    return this;
+  }
+
+  /**
+   * Set view directory.
+   * @param {string} view
+   */
+  setView(view: string) {
+    this.view = view;
+    return this;
+  }
+
+  setData(data) {
+    this.data = data;
+    return this;
+  }
+
+  /**
+   * Renders the view template with the given data.
+   * @param  {object} data
+   * @return {string}
+   */
+  render(data): string {
+    const viewContent = this.getViewContent();
+    return Mustache.render(viewContent, data);
+  }
+
+  /**
+   * Retrieve view content from the view directory.
+   */
+  private getViewContent(): string {
+    const filePath = path.join(global.__root, `../views/${this.view}`);
+    return fs.readFileSync(filePath, 'utf8');
+  }
+}
diff --git a/packages/server/src/lib/Metable/MetableConfig.ts b/packages/server/src/lib/Metable/MetableConfig.ts
new file mode 100644
index 000000000..21febaffd
--- /dev/null
+++ b/packages/server/src/lib/Metable/MetableConfig.ts
@@ -0,0 +1,40 @@
+import { get } from 'lodash';
+
+export default class MetableConfig {
+  readonly config: any;
+
+  constructor(config) {
+    this.setConfig(config);
+  }
+
+  /**
+   * Sets config. 
+   */
+  setConfig(config) {
+    this.config = config;
+  }
+ 
+  /**
+   * 
+   * @param {string} key 
+   * @param {string} group 
+   * @param {string} accessor 
+   * @returns {object|string}
+   */
+  getMetaConfig(key: string, group?: string, accessor?: string) {
+    const configGroup = get(this.config, group);
+    const config = get(configGroup, key);
+
+    return accessor ? get(config, accessor) : config;
+  }
+
+  /**
+   * 
+   * @param {string} key 
+   * @param {string} group 
+   * @returns {string}
+   */
+  getMetaType(key: string, group?: string) {
+    return this.getMetaConfig(key, group, 'type');
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/lib/Metable/MetableModel.js b/packages/server/src/lib/Metable/MetableModel.js
new file mode 100644
index 000000000..f1e489a1a
--- /dev/null
+++ b/packages/server/src/lib/Metable/MetableModel.js
@@ -0,0 +1,12 @@
+
+
+export default class Metable{
+
+  static get modifiers() {
+    return {
+      whereKey(builder, key) {
+        builder.where('key', key);
+      },
+    };
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/lib/Metable/MetableStore.ts b/packages/server/src/lib/Metable/MetableStore.ts
new file mode 100644
index 000000000..3d9400361
--- /dev/null
+++ b/packages/server/src/lib/Metable/MetableStore.ts
@@ -0,0 +1,215 @@
+import { Model } from 'objection';
+import { omit, isEmpty } from 'lodash';
+import { IMetadata, IMetaQuery, IMetableStore } from '@/interfaces';
+import { itemsStartWith } from 'utils';
+
+export default class MetableStore implements IMetableStore {
+  metadata: IMetadata[];
+  model: Model;
+  extraColumns: string[];
+
+  /**
+   * Constructor method.
+   */
+  constructor() {
+    this.metadata = [];
+    this.model = null;
+    this.extraColumns = [];
+  }
+
+  /**
+   * Sets a extra columns.
+   * @param {Array} columns -
+   */
+  setExtraColumns(columns: string[]): void {
+    this.extraColumns = columns;
+  }
+
+  /**
+   * Find the given metadata key.
+   * @param {string|IMetaQuery} query -
+   * @returns {IMetadata} - Metadata object.
+   */
+  find(query: string | IMetaQuery): IMetadata {
+    const { key, value, ...extraColumns } = this.parseQuery(query);
+
+    return this.metadata.find((meta: IMetadata) => {
+      const isSameKey = meta.key === key;
+      const sameExtraColumns = this.extraColumns.some(
+        (extraColumn: string) => extraColumns[extraColumn] === meta[extraColumn]
+      );
+
+      const isSameExtraColumns = sameExtraColumns || isEmpty(extraColumns);
+
+      return isSameKey && isSameExtraColumns;
+    });
+  }
+
+  /**
+   * Retrieve all metadata.
+   * @returns {IMetadata[]}
+   */
+  all(): IMetadata[] {
+    return this.metadata
+      .filter((meta: IMetadata) => !meta._markAsDeleted)
+      .map((meta: IMetadata) =>
+        omit(meta, itemsStartWith(Object.keys(meta), '_'))
+      );
+  }
+
+  /**
+   * Retrieve metadata of the given key.
+   * @param {String} key -
+   * @param {Mixied} defaultValue -
+   */
+  get(query: string | IMetaQuery, defaultValue: any): any | false {
+    const metadata = this.find(query);
+    return metadata
+      ? metadata.value
+      : typeof defaultValue !== 'undefined'
+      ? defaultValue
+      : false;
+  }
+
+  /**
+   * Markes the metadata to should be deleted.
+   * @param {String} key -
+   */
+  remove(query: string | IMetaQuery): void {
+    const metadata: IMetadata = this.find(query);
+
+    if (metadata) {
+      metadata._markAsDeleted = true;
+    }
+  }
+
+  /**
+   * Remove all meta data of the given group.
+   * @param {string} group
+   */
+  removeAll(group: string = 'default'): void {
+    this.metadata = this.metadata.map((meta) => ({
+      ...meta,
+      _markAsDeleted: true,
+    }));
+  }
+
+  /**
+   * Set the meta data to the stack.
+   * @param {String} key -
+   * @param {String} value -
+   */
+  set(query: IMetaQuery | IMetadata[] | string, metaValue?: any): void {
+    if (Array.isArray(query)) {
+      const metadata = query;
+
+      metadata.forEach((meta: IMetadata) => {
+        this.set(meta);
+      });
+      return;
+    }
+    const { key, value, ...extraColumns } = this.parseQuery(query);
+    const metadata = this.find(query);
+    const newValue = metaValue || value;
+
+    if (metadata) {
+      metadata.value = newValue;
+      metadata._markAsUpdated = true;
+    } else {
+      this.metadata.push({
+        value: newValue,
+        key,
+        ...extraColumns,
+        _markAsInserted: true,
+      });
+    }
+  }
+
+  /**
+   * Parses query query.
+   * @param query
+   * @param value
+   */
+  parseQuery(query: string | IMetaQuery): IMetaQuery {
+    return typeof query !== 'object' ? { key: query } : { ...query };
+  }
+
+  /**
+   * Format the metadata before saving to the database.
+   * @param {string|number|boolean} value -
+   * @param {string} valueType -
+   * @return {string|number|boolean} -
+   */
+  static formatMetaValue(
+    value: string | boolean | number,
+    valueType: string
+  ): string | number | boolean {
+    let parsedValue;
+
+    switch (valueType) {
+      case 'number':
+        parsedValue = `${value}`;
+        break;
+      case 'boolean':
+        parsedValue = value ? '1' : '0';
+        break;
+      case 'json':
+        parsedValue = JSON.stringify(parsedValue);
+        break;
+      default:
+        parsedValue = value;
+        break;
+    }
+    return parsedValue;
+  }
+
+  /**
+   * Parse the metadata to the collection.
+   * @param {Array} collection -
+   */
+  mapMetadataToCollection(metadata: IMetadata[], parseType: string = 'parse') {
+    return metadata.map((model) =>
+      this.mapMetadataToCollection(model, parseType)
+    );
+  }
+
+  /**
+   * Load metadata to the metable collection.
+   * @param {Array} meta -
+   */
+  from(meta: []) {
+    if (Array.isArray(meta)) {
+      meta.forEach((m) => {
+        this.from(m);
+      });
+      return;
+    }
+    this.metadata.push(meta);
+  }
+
+  /**
+   *
+   * @returns {array}
+   */
+  toArray(): IMetadata[] {
+    return this.metadata;
+  }
+
+  /**
+   * Static method to load metadata to the collection.
+   * @param {Array} meta
+   */
+  static from(meta) {
+    const collection = new MetableCollection();
+    collection.from(meta);
+
+    return collection;
+  }
+
+  /**
+   * Reset the momerized metadata.
+   */
+  resetMetadata() {
+    this.metadata = [];
+  }
+}
diff --git a/packages/server/src/lib/Metable/MetableStoreDB.ts b/packages/server/src/lib/Metable/MetableStoreDB.ts
new file mode 100644
index 000000000..1f5e956de
--- /dev/null
+++ b/packages/server/src/lib/Metable/MetableStoreDB.ts
@@ -0,0 +1,243 @@
+import { IMetadata, IMetableStoreStorage } from '@/interfaces';
+import MetableStore from './MetableStore';
+import { isBlank, parseBoolean } from 'utils';
+import MetableConfig from './MetableConfig';
+import config from '@/data/options'
+export default class MetableDBStore
+  extends MetableStore
+  implements IMetableStoreStorage {
+  repository: any;
+  KEY_COLUMN: string;
+  VALUE_COLUMN: string;
+  TYPE_COLUMN: string;
+  extraQuery: Function;
+  loaded: Boolean;
+  config: MetableConfig;
+
+  /**
+   * Constructor method.
+   */
+  constructor() {
+    super();
+
+    this.loaded = false;
+    this.KEY_COLUMN = 'key';
+    this.VALUE_COLUMN = 'value';
+    this.TYPE_COLUMN = 'type';
+    this.repository = null;
+
+    this.extraQuery = (meta) => {
+      return {
+        key: meta[this.KEY_COLUMN],
+        ...this.transfromMetaExtraColumns(meta),
+      };
+    };
+    this.config = new MetableConfig(config);
+  }
+
+  /**
+   * Transformes meta query.
+   * @param {IMetadata} meta
+   */
+  private transfromMetaExtraColumns(meta: IMetadata) {
+    return this.extraColumns.reduce((obj, column) => {
+      const metaValue = meta[column];
+
+      if (!isBlank(metaValue)) {
+        obj[column] = metaValue;
+      }
+      return obj;
+    }, {});
+  }
+
+  /**
+   * Set repository entity of this metadata collection.
+   * @param {Object} repository -
+   */
+  setRepository(repository) {
+    this.repository = repository;
+  }
+
+  /**
+   * Sets a extra query callback.
+   * @param callback
+   */
+  setExtraQuery(callback) {
+    this.extraQuery = callback;
+  }
+
+  /**
+   * Saves the modified, deleted and insert metadata.
+   */
+  save() {
+    this.validateStoreIsLoaded();
+
+    return Promise.all([
+      this.saveUpdated(this.metadata),
+      this.saveDeleted(this.metadata),
+      this.saveInserted(this.metadata),
+    ]);
+  }
+
+  /**
+   * Saves the updated metadata.
+   * @param {IMetadata[]} metadata -
+   * @returns {Promise}
+   */
+  saveUpdated(metadata: IMetadata[]) {
+    const updated = metadata.filter((m) => m._markAsUpdated === true);
+    const opers = [];
+
+    updated.forEach((meta) => {
+      const updateOper = this.repository
+        .update(
+          { [this.VALUE_COLUMN]: meta.value },
+          { ...this.extraQuery(meta) }
+        )
+        .then(() => {
+          meta._markAsUpdated = false;
+        });
+      opers.push(updateOper);
+    });
+    return Promise.all(opers);
+  }
+
+  /**
+   * Saves the deleted metadata.
+   * @param {IMetadata[]} metadata -
+   * @returns {Promise}
+   */
+  saveDeleted(metadata: IMetadata[]) {
+    const deleted = metadata.filter(
+      (m: IMetadata) => m._markAsDeleted === true
+    );
+    const opers: Promise<void> = [];
+
+    if (deleted.length > 0) {
+      deleted.forEach((meta) => {
+        const deleteOper = this.repository
+          .deleteBy({
+            ...this.extraQuery(meta),
+          })
+          .then(() => {
+            meta._markAsDeleted = false;
+          });
+        opers.push(deleteOper);
+      });
+    }
+    return Promise.all(opers);
+  }
+
+  /**
+   * Saves the inserted metadata.
+   * @param {IMetadata[]} metadata -
+   * @returns {Promise}
+   */
+  saveInserted(metadata: IMetadata[]) {
+    const inserted = metadata.filter(
+      (m: IMetadata) => m._markAsInserted === true
+    );
+    const opers: Promise<void> = [];
+
+    inserted.forEach((meta) => {
+      const insertData = {
+        [this.KEY_COLUMN]: meta.key,
+        [this.VALUE_COLUMN]: meta.value,
+        ...this.transfromMetaExtraColumns(meta),
+      };
+      const insertOper = this.repository.create(insertData).then(() => {
+        meta._markAsInserted = false;
+      });
+      opers.push(insertOper);
+    });
+    return Promise.all(opers);
+  }
+
+  /**
+   * Loads the metadata from the storage.
+   * @param {String|Array} key -
+   * @param {Boolean} force -
+   */
+  async load() {
+    const metadata = await this.repository.all();
+    const mappedMetadata = this.mapMetadataCollection(metadata);
+
+    this.resetMetadata();
+
+    mappedMetadata.forEach((meta: IMetadata) => {
+      this.metadata.push(meta);
+    });
+    this.loaded = true;
+  }
+
+  /**
+   * Parse the metadata values after fetching it from the storage.
+   * @param {String|Number|Boolean} value -
+   * @param {String} valueType -
+   * @return {String|Number|Boolean} -
+   */
+  static parseMetaValue(
+    value: string,
+    valueType: string | false
+  ): string | boolean | number {
+    let parsedValue: string | number | boolean;
+
+    switch (valueType) {
+      case 'number':
+        parsedValue = parseFloat(value);
+        break;
+      case 'boolean':
+        parsedValue = parseBoolean(value, false);
+        break;
+      case 'json':
+        parsedValue = JSON.stringify(parsedValue);
+        break;
+      default:
+        parsedValue = value;
+        break;
+    }
+    return parsedValue;
+  }
+
+  /**
+   * Mapping and parse metadata to collection entries.
+   * @param {Meta} attr -
+   * @param {String} parseType -
+   */
+  mapMetadata(metadata: IMetadata) {
+    const metaType = this.config.getMetaType(
+      metadata[this.KEY_COLUMN],
+      metadata['group'],
+    );
+    return {
+      key: metadata[this.KEY_COLUMN],
+      value: MetableDBStore.parseMetaValue(
+        metadata[this.VALUE_COLUMN],
+        metaType
+      ),
+      ...this.extraColumns.reduce((obj, extraCol: string) => {
+        obj[extraCol] = metadata[extraCol] || null;
+        return obj;
+      }, {}),
+    };
+  }
+
+  /**
+   * Parse the metadata to the collection.
+   * @param {Array} collection -
+   */
+  mapMetadataCollection(metadata: IMetadata[]) {
+    return metadata.map((model) => this.mapMetadata(model));
+  }
+
+  /**
+   * Throw error in case the store is not loaded yet.
+   */
+  private validateStoreIsLoaded() {
+    if (!this.loaded) {
+      throw new Error(
+        'You could not save the store before loaded from the storage.'
+      );
+    }
+  }
+}
diff --git a/packages/server/src/lib/MomentFormats/index.ts b/packages/server/src/lib/MomentFormats/index.ts
new file mode 100644
index 000000000..4b3e7103f
--- /dev/null
+++ b/packages/server/src/lib/MomentFormats/index.ts
@@ -0,0 +1,48 @@
+import moment from 'moment';
+
+moment.prototype.toMySqlDateTime = function () {
+  return this.format('YYYY-MM-DD HH:mm:ss');
+};
+
+// moment.fn.businessDiff = function (param) {
+//   param = moment(param);
+//   var signal = param.unix() < this.unix() ? 1 : -1;
+//   var start = moment.min(param, this).clone();
+//   var end = moment.max(param, this).clone();
+//   var start_offset = start.day() - 7;
+//   var end_offset = end.day();
+
+//   var end_sunday = end.clone().subtract('d', end_offset);
+//   var start_sunday = start.clone().subtract('d', start_offset);
+//   var weeks = end_sunday.diff(start_sunday, 'days') / 7;
+
+//   start_offset = Math.abs(start_offset);
+//   if (start_offset == 7)
+//     start_offset = 5;
+//   else if (start_offset == 1)
+//     start_offset = 0;
+//   else
+//     start_offset -= 2;
+
+//   if (end_offset == 6)
+//     end_offset--;
+
+//   return signal * (weeks * 5 + start_offset + end_offset);
+// };
+
+// moment.fn.businessAdd = function (days) {
+//   var signal = days < 0 ? -1 : 1;
+//   days = Math.abs(days);
+//   var d = this.clone().add(Math.floor(days / 5) * 7 * signal, 'd');
+//   var remaining = days % 5;
+//   while (remaining) {
+//     d.add(signal, 'd');
+//     if (d.day() !== 0 && d.day() !== 6)
+//       remaining--;
+//   }
+//   return d;
+// };
+
+// moment.fn.businessSubtract = function (days) {
+//   return this.businessAdd(-days);
+// };
diff --git a/packages/server/src/lib/NestedSet/NestedSetNode.js b/packages/server/src/lib/NestedSet/NestedSetNode.js
new file mode 100644
index 000000000..60655589f
--- /dev/null
+++ b/packages/server/src/lib/NestedSet/NestedSetNode.js
@@ -0,0 +1,9 @@
+
+
+class NestedSetNode {
+
+  // Saves
+  appendToNode($parent) {
+    
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/lib/QueryBuilderBulkOperations/QueryBuilder.js b/packages/server/src/lib/QueryBuilderBulkOperations/QueryBuilder.js
new file mode 100644
index 000000000..6aa08ab82
--- /dev/null
+++ b/packages/server/src/lib/QueryBuilderBulkOperations/QueryBuilder.js
@@ -0,0 +1,27 @@
+import { QueryBuilder } from "knex"
+import { QueryBuilder } from 'objection';
+
+export default class BulkOperationsQueryBuilder extends QueryBuilder {
+
+  bulkInsert(collection) {
+    const opers = [];
+
+    collection.forEach((dataset) => {
+      const insertOper = this.insert({ ...dataset });
+      opers.push(insertOper);
+    });
+    return Promise.all(opers);
+  }
+
+  bulkDelete(rowsIds) {
+
+  }
+
+  bulkUpdate(dataset, whereColumn) {
+
+  }
+
+  bulkPatch(newDataset, oldDataset) {
+
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/lib/Seeder/FsMigrations.ts b/packages/server/src/lib/Seeder/FsMigrations.ts
new file mode 100644
index 000000000..605f6b421
--- /dev/null
+++ b/packages/server/src/lib/Seeder/FsMigrations.ts
@@ -0,0 +1,100 @@
+import path from 'path';
+import { sortBy } from 'lodash';
+import fs from 'fs';
+import { promisify } from 'util';
+import { MigrateItem } from './interfaces';
+import { importWebpackSeedModule } from './Utils';
+import { DEFAULT_LOAD_EXTENSIONS } from './constants';
+import { filterMigrations } from './MigrateUtils';
+
+const readdir = promisify(fs.readdir);
+
+class FsMigrations {
+  private sortDirsSeparately: boolean;
+  private migrationsPaths: string[];
+  private loadExtensions: string[];
+
+  /**
+   * Constructor method.
+   * @param migrationDirectories
+   * @param sortDirsSeparately
+   * @param loadExtensions
+   */
+  constructor(
+    migrationDirectories: string[],
+    sortDirsSeparately: boolean,
+    loadExtensions: string[]
+  ) {
+    this.sortDirsSeparately = sortDirsSeparately;
+
+    if (!Array.isArray(migrationDirectories)) {
+      migrationDirectories = [migrationDirectories];
+    }
+    this.migrationsPaths = migrationDirectories;
+    this.loadExtensions = loadExtensions || DEFAULT_LOAD_EXTENSIONS;
+  }
+
+  /**
+   * Gets the migration names
+   * @returns Promise<MigrateItem[]>
+   */
+  public getMigrations(loadExtensions = null): Promise<MigrateItem[]> {
+    // Get a list of files in all specified migration directories
+    const readMigrationsPromises = this.migrationsPaths.map((configDir) => {
+      const absoluteDir = path.resolve(process.cwd(), configDir);
+      return readdir(absoluteDir).then((files) => ({
+        files,
+        configDir,
+        absoluteDir,
+      }));
+    });
+
+    return Promise.all(readMigrationsPromises).then((allMigrations) => {
+      const migrations = allMigrations.reduce((acc, migrationDirectory) => {
+        // When true, files inside the folder should be sorted
+        if (this.sortDirsSeparately) {
+          migrationDirectory.files = migrationDirectory.files.sort();
+        }
+        migrationDirectory.files.forEach((file) =>
+          acc.push({ file, directory: migrationDirectory.configDir })
+        );
+        return acc;
+      }, []);
+
+      // If true we have already sorted the migrations inside the folders
+      // return the migrations fully qualified
+      if (this.sortDirsSeparately) {
+        return filterMigrations(
+          this,
+          migrations,
+          loadExtensions || this.loadExtensions
+        );
+      }
+      return filterMigrations(
+        this,
+        sortBy(migrations, 'file'),
+        loadExtensions || this.loadExtensions
+      );
+    });
+  }
+
+  /**
+   * Retrieve the file name from given migrate item.
+   * @param {MigrateItem} migration
+   * @returns {string}
+   */
+  public getMigrationName(migration: MigrateItem): string {
+    return migration.file;
+  }
+
+  /**
+   * Retrieve the migrate file content from given migrate item.
+   * @param {MigrateItem} migration
+   * @returns {string}
+   */
+  public getMigration(migration: MigrateItem): string {
+    return importWebpackSeedModule(migration.file);
+  }
+}
+
+export { DEFAULT_LOAD_EXTENSIONS, FsMigrations };
diff --git a/packages/server/src/lib/Seeder/MigrateUtils.ts b/packages/server/src/lib/Seeder/MigrateUtils.ts
new file mode 100644
index 000000000..efed89f28
--- /dev/null
+++ b/packages/server/src/lib/Seeder/MigrateUtils.ts
@@ -0,0 +1,192 @@
+import { differenceWith } from 'lodash';
+import path from 'path';
+import { FsMigrations } from './FsMigrations';
+import {
+  getTable,
+  getTableName,
+  getLockTableName,
+  getLockTableNameWithSchema,
+} from './TableUtils';
+import { ISeederConfig, MigrateItem } from './interfaces';
+
+/**
+ * Get schema-aware schema builder for a given schema nam
+ * @param trxOrKnex
+ * @param {string} schemaName
+ * @returns
+ */
+function getSchemaBuilder(trxOrKnex, schemaName: string | null = null) {
+  return schemaName
+    ? trxOrKnex.schema.withSchema(schemaName)
+    : trxOrKnex.schema;
+}
+
+/**
+ * Creates migration table of the given table name.
+ * @param {string} tableName
+ * @param {string} schemaName
+ * @param trxOrKnex
+ * @returns
+ */
+function createMigrationTable(
+  tableName: string,
+  schemaName: string,
+  trxOrKnex
+) {
+  return getSchemaBuilder(trxOrKnex, schemaName).createTable(
+    getTableName(tableName),
+    (t) => {
+      t.increments();
+      t.string('name');
+      t.integer('batch');
+      t.timestamp('migration_time');
+    }
+  );
+}
+
+/**
+ * Creates a migration lock table of the given table name.
+ * @param {string} tableName
+ * @param {string} schemaName
+ * @param trxOrKnex
+ * @returns
+ */
+function createMigrationLockTable(
+  tableName: string,
+  schemaName: string,
+  trxOrKnex
+) {
+  return getSchemaBuilder(trxOrKnex, schemaName).createTable(tableName, (t) => {
+    t.increments('index').primary();
+    t.integer('is_locked');
+  });
+}
+
+/**
+ *
+ * @param tableName
+ * @param schemaName
+ * @param trxOrKnex
+ * @returns
+ */
+export function ensureMigrationTables(
+  tableName: string,
+  schemaName: string,
+  trxOrKnex
+) {
+  const lockTable = getLockTableName(tableName);
+  const lockTableWithSchema = getLockTableNameWithSchema(tableName, schemaName);
+
+  return getSchemaBuilder(trxOrKnex, schemaName)
+    .hasTable(tableName)
+    .then((exists) => {
+      return !exists && createMigrationTable(tableName, schemaName, trxOrKnex);
+    })
+    .then(() => {
+      return getSchemaBuilder(trxOrKnex, schemaName).hasTable(lockTable);
+    })
+    .then((exists) => {
+      return (
+        !exists && createMigrationLockTable(lockTable, schemaName, trxOrKnex)
+      );
+    })
+    .then(() => {
+      return getTable(trxOrKnex, lockTable, schemaName).select('*');
+    })
+    .then((data) => {
+      return (
+        !data.length &&
+        trxOrKnex.into(lockTableWithSchema).insert({ is_locked: 0 })
+      );
+    });
+}
+
+/**
+ * Lists all available migration versions, as a sorted array.
+ * @param migrationSource
+ * @param loadExtensions
+ * @returns
+ */
+function listAll(
+  migrationSource: FsMigrations,
+  loadExtensions
+): Promise<MigrateItem[]> {
+  return migrationSource.getMigrations(loadExtensions);
+}
+
+/**
+ * Lists all migrations that have been completed for the current db, as an array.
+ * @param {string} tableName
+ * @param {string} schemaName
+ * @param {} trxOrKnex
+ * @returns Promise<string[]>
+ */
+export async function listCompleted(
+  tableName: string,
+  schemaName: string,
+  trxOrKnex
+): Promise<string[]> {
+  const completedMigrations = await trxOrKnex
+    .from(getTableName(tableName, schemaName))
+    .orderBy('id')
+    .select('name');
+
+  return completedMigrations.map((migration) => {
+    return migration.name;
+  });
+}
+
+/**
+ * Gets the migration list from the migration directory specified in config, as well as
+ * the list of completed migrations to check what should be run.
+ */
+export function listAllAndCompleted(config: ISeederConfig, trxOrKnex) {
+  return Promise.all([
+    listAll(config.migrationSource, config.loadExtensions),
+    listCompleted(config.tableName, config.schemaName, trxOrKnex),
+  ]);
+}
+
+/**
+ *
+ * @param migrationSource
+ * @param all
+ * @param completed
+ * @returns
+ */
+export function getNewMigrations(
+  migrationSource: FsMigrations,
+  all: MigrateItem[],
+  completed: string[]
+): MigrateItem[] {
+  return differenceWith(all, completed, (allMigration, completedMigration) => {
+    return (
+      completedMigration === migrationSource.getMigrationName(allMigration)
+    );
+  });
+}
+
+function startsWithNumber(str) {
+  return /^\d/.test(str);
+}
+/**
+ *
+ * @param {FsMigrations} migrationSource -
+ * @param {MigrateItem[]} migrations -
+ * @param {string[]} loadExtensions -
+ * @returns
+ */
+export function filterMigrations(
+  migrationSource: FsMigrations,
+  migrations: MigrateItem[],
+  loadExtensions: string[]
+) {
+  return migrations.filter((migration) => {
+    const migrationName = migrationSource.getMigrationName(migration);
+    const extension = path.extname(migrationName);
+
+    return (
+      loadExtensions.includes(extension) && startsWithNumber(migrationName)
+    );
+  });
+}
diff --git a/packages/server/src/lib/Seeder/SeedMigration.ts b/packages/server/src/lib/Seeder/SeedMigration.ts
new file mode 100644
index 000000000..519445c36
--- /dev/null
+++ b/packages/server/src/lib/Seeder/SeedMigration.ts
@@ -0,0 +1,222 @@
+import { Knex } from 'knex';
+import Bluebird from 'bluebird';
+import { getTable, getTableName, getLockTableName } from './TableUtils';
+import getMergedConfig from './SeederConfig';
+import {
+  listAllAndCompleted,
+  getNewMigrations,
+  listCompleted,
+  ensureMigrationTables,
+} from './MigrateUtils';
+import { MigrateItem, SeedMigrationContext, ISeederConfig } from './interfaces';
+import { FsMigrations } from './FsMigrations';
+
+export class SeedMigration {
+  knex: Knex;
+  config: ISeederConfig;
+  migrationSource: FsMigrations;
+  context: SeedMigrationContext;
+
+  /**
+   * Constructor method.
+   * @param {Knex} knex - Knex instance.
+   * @param {SeedMigrationContext} context -
+   */
+  constructor(knex: Knex, context: SeedMigrationContext) {
+    this.knex = knex;
+    this.config = getMergedConfig(this.knex.client.config.seeds, undefined);
+    this.migrationSource = this.config.migrationSource;
+    this.context = context;
+  }
+
+  /**
+   * Latest migration.
+   * @returns {Promise<void>}
+   */
+  async latest(config = null): Promise<void> {
+    // Merges the configuration.
+    this.config = getMergedConfig(config, this.config);
+
+    // Ensure migration tables.
+    await ensureMigrationTables(this.config.tableName, null, this.knex);
+
+    // Retrieve all and completed migrations.
+    const [all, completed] = await listAllAndCompleted(this.config, this.knex);
+
+    // Retrieve the new migrations.
+    const migrations = getNewMigrations(this.migrationSource, all, completed);
+
+    // Run the latest migration on one batch.
+    return this.knex.transaction((trx: Knex.Transaction) => {
+      return this.runBatch(migrations, 'up', trx);
+    });
+  }
+
+  /**
+   * Add migration lock flag.
+   * @param {Knex.Transaction} trx
+   * @returns
+   */
+  private migrateLockTable(trx: Knex.Transaction) {
+    const tableName = getLockTableName(this.config.tableName);
+    return getTable(this.knex, tableName, this.config.schemaName)
+      .transacting(trx)
+      .where('is_locked', '=', 0)
+      .update({ is_locked: 1 })
+      .then((rowCount) => {
+        if (rowCount != 1) {
+          throw new Error('Migration table is already locked');
+        }
+      });
+  }
+
+  /**
+   * Add migration lock flag.
+   * @param {Knex.Transaction} trx
+   * @returns
+   */
+  private migrationLock(trx: Knex.Transaction) {
+    return this.migrateLockTable(trx);
+  }
+
+  /**
+   * Free the migration lock flag.
+   * @param {Knex.Transaction} trx
+   * @returns
+   */
+  private freeLock(trx = this.knex): Promise<void> {
+    const tableName = getLockTableName(this.config.tableName);
+
+    return getTable(trx, tableName, this.config.schemaName).update({
+      is_locked: 0,
+    });
+  }
+
+  /**
+   * Returns the latest batch number.
+   * @param trx
+   * @returns
+   */
+  private latestBatchNumber(trx = this.knex): number {
+    return trx
+      .from(getTableName(this.config.tableName, this.config.schemaName))
+      .max('batch as max_batch')
+      .then((obj) => obj[0].max_batch || 0);
+  }
+
+  /**
+   * Runs a batch of `migrations` in a specified `direction`, saving the
+   * appropriate database information as the migrations are run.
+   * @param   {number} batchNo
+   * @param   {MigrateItem[]} migrations
+   * @param   {string} direction
+   * @param   {Knex.Transaction} trx
+   * @returns {Promise<void>}
+   */
+  private waterfallBatch(
+    batchNo: number,
+    migrations: MigrateItem[],
+    direction: string,
+    trx: Knex.Transaction
+  ): Promise<void> {
+    const { tableName } = this.config;
+
+    return Bluebird.each(migrations, (migration) => {
+      const name = this.migrationSource.getMigrationName(migration);
+
+      return this.migrationSource
+        .getMigration(migration)
+        .then((migrationContent) =>
+          this.runMigrationContent(migrationContent.default, direction, trx)
+        )
+        .then(() => {
+          if (direction === 'up') {
+            return trx.into(getTableName(tableName)).insert({
+              name,
+              batch: batchNo,
+              migration_time: new Date(),
+            });
+          }
+          if (direction === 'down') {
+            return trx.from(getTableName(tableName)).where({ name }).del();
+          }
+        });
+    });
+  }
+
+  /**
+   * Runs and builds the given migration class.
+   */
+  private runMigrationContent(Migration, direction, trx) {
+    const instance = new Migration(trx);
+
+    if (this.context.i18n) {
+      instance.setI18n(this.context.i18n);
+    }
+    instance.setTenant(this.context.tenant);
+
+    return instance[direction](trx);
+  }
+
+  /**
+   * Validates some migrations by requiring and checking for an `up` and `down`function.
+   * @param {MigrateItem} migration
+   * @returns {MigrateItem}
+   */
+  async validateMigrationStructure(migration: MigrateItem): MigrateItem {
+    const migrationName = this.migrationSource.getMigrationName(migration);
+
+    // maybe promise
+    const migrationContent = await this.migrationSource.getMigration(migration);
+    if (
+      typeof migrationContent.up !== 'function' ||
+      typeof migrationContent.down !== 'function'
+    ) {
+      throw new Error(
+        `Invalid migration: ${migrationName} must have both an up and down function`
+      );
+    }
+    return migration;
+  }
+
+  /**
+   * Run a batch of current migrations, in sequence.
+   * @param   {MigrateItem[]} migrations
+   * @param   {string} direction
+   * @param   {Knex.Transaction} trx
+   * @returns {Promise<void>}
+   */
+  private async runBatch(
+    migrations: MigrateItem[],
+    direction: string,
+    trx: Knex.Transaction
+  ): Promise<void> {
+    // Adds flag to migration lock.
+    await this.migrationLock(trx);
+
+    // When there is a wrapping transaction, some migrations
+    // could have been done while waiting for the lock:
+    const completed = await listCompleted(
+      this.config.tableName,
+      this.config.schemaName,
+      trx
+    );
+    // Differentiate between all and completed to get new migrations.
+    const newMigrations = getNewMigrations(
+      this.config.migrationSource,
+      migrations,
+      completed
+    );
+    // Retrieve the latest batch number.
+    const batchNo = await this.latestBatchNumber(trx);
+
+    // Increment the next batch number.
+    const newBatchNo = direction === 'up' ? batchNo + 1 : batchNo;
+
+    // Run all migration files in waterfall.
+    await this.waterfallBatch(newBatchNo, newMigrations, direction, trx);
+
+    // Free the migration lock flag.
+    await this.freeLock(trx);
+  }
+}
diff --git a/packages/server/src/lib/Seeder/Seeder.ts b/packages/server/src/lib/Seeder/Seeder.ts
new file mode 100644
index 000000000..8ad674048
--- /dev/null
+++ b/packages/server/src/lib/Seeder/Seeder.ts
@@ -0,0 +1,11 @@
+
+export class Seeder {
+  knex: any;
+
+  constructor(knex) {
+    this.knex = knex;
+  }
+  up(knex) {}
+  down(knex) {}
+}
+
diff --git a/packages/server/src/lib/Seeder/SeederConfig.ts b/packages/server/src/lib/Seeder/SeederConfig.ts
new file mode 100644
index 000000000..77ea2e57d
--- /dev/null
+++ b/packages/server/src/lib/Seeder/SeederConfig.ts
@@ -0,0 +1,44 @@
+import { DEFAULT_LOAD_EXTENSIONS, FsMigrations } from './FsMigrations';
+
+const CONFIG_DEFAULT = Object.freeze({
+  extension: 'js',
+  loadExtensions: DEFAULT_LOAD_EXTENSIONS,
+  tableName: 'knex_migrations',
+  schemaName: null,
+  directory: './migrations',
+  disableTransactions: false,
+  disableMigrationsListValidation: false,
+  sortDirsSeparately: false,
+});
+
+export default function getMergedConfig(config, currentConfig) {
+  // config is the user specified config, mergedConfig has defaults and current config
+  // applied to it.
+  const mergedConfig = {
+    ...CONFIG_DEFAULT,
+    ...(currentConfig || {}),
+    ...config,
+  };
+
+  if (
+    config &&
+    // If user specifies any FS related config,
+    // clear specified migrationSource to avoid ambiguity
+    (config.directory ||
+      config.sortDirsSeparately !== undefined ||
+      config.loadExtensions)
+  ) {
+    mergedConfig.migrationSource = null;
+  }
+
+  // If the user has not specified any configs, we need to
+  // default to fs migrations to maintain compatibility
+  if (!mergedConfig.migrationSource) {
+    mergedConfig.migrationSource = new FsMigrations(
+      mergedConfig.directory,
+      mergedConfig.sortDirsSeparately,
+      mergedConfig.loadExtensions
+    );
+  }
+  return mergedConfig;
+}
diff --git a/packages/server/src/lib/Seeder/TableUtils.ts b/packages/server/src/lib/Seeder/TableUtils.ts
new file mode 100644
index 000000000..587112887
--- /dev/null
+++ b/packages/server/src/lib/Seeder/TableUtils.ts
@@ -0,0 +1,43 @@
+/**
+ * Get schema-aware query builder for a given table and schema name.
+ * @param {Knex} trxOrKnex -
+ * @param {string} tableName -
+ * @param {string} schemaName -
+ * @returns {string}
+ */
+export function getTable(trx, tableName: string, schemaName = null) {
+  return schemaName ? trx(tableName).withSchema(schemaName) : trx(tableName);
+}
+
+/**
+ * Get schema-aware table name.
+ * @param {string} tableName -
+ * @returns {string}
+ */
+export function getTableName(tableName: string, schemaName = null): string {
+  return schemaName ? `${schemaName}.${tableName}` : tableName;
+}
+
+/**
+ * Retrieve the lock table name from given migration table name.
+ * @param {string} tableName
+ * @returns {string}
+ */
+export function getLockTableName(tableName: string): string {
+  return `${tableName}_lock`;
+}
+
+/**
+ * Retireve the lock table name from ginve migration table name with schema.
+ * @param {string} tableName
+ * @param {string} schemaName
+ * @returns {string}
+ */
+export function getLockTableNameWithSchema(
+  tableName: string,
+  schemaName = null
+): string {
+  return schemaName
+    ? `${schemaName} + ${getLockTableName(tableName)}`
+    : getLockTableName(tableName);
+}
diff --git a/packages/server/src/lib/Seeder/TenantSeeder.ts b/packages/server/src/lib/Seeder/TenantSeeder.ts
new file mode 100644
index 000000000..6c54b868e
--- /dev/null
+++ b/packages/server/src/lib/Seeder/TenantSeeder.ts
@@ -0,0 +1,25 @@
+import { Seeder } from "./Seeder";
+
+export class TenantSeeder extends Seeder{
+  public knex: any;
+  public i18n: i18nAPI;
+  public models: any;
+  public tenant: any;
+
+  constructor(knex) {
+    super(knex);
+    this.knex = knex;
+  }
+
+  setI18n(i18n) {
+    this.i18n = i18n;
+  }
+
+  setModels(models) {
+    this.models = models;
+  }
+
+  setTenant(tenant) {
+    this.tenant = tenant;
+  }
+}
diff --git a/packages/server/src/lib/Seeder/Utils.ts b/packages/server/src/lib/Seeder/Utils.ts
new file mode 100644
index 000000000..29a8f0084
--- /dev/null
+++ b/packages/server/src/lib/Seeder/Utils.ts
@@ -0,0 +1,42 @@
+import fs from 'fs';
+
+const { promisify } = require('util');
+const readFile = promisify(fs.readFile);
+
+/**
+ * Detarmines the module type of the given file path.
+ * @param {string} filepath
+ * @returns {boolean}
+ */
+async function isModuleType(filepath: string): boolean {
+  if (process.env.npm_package_json) {
+    // npm >= 7.0.0
+    const packageJson = JSON.parse(
+      await readFile(process.env.npm_package_json, 'utf-8')
+    );
+    if (packageJson.type === 'module') {
+      return true;
+    }
+  }
+  return process.env.npm_package_type === 'module' || filepath.endsWith('.mjs');
+}
+
+/**
+ * Imports content of the given file path.
+ * @param {string} filepath
+ * @returns
+ */
+export async function importFile(filepath: string): any {
+  return (await isModuleType(filepath))
+    ? import(require('url').pathToFileURL(filepath))
+    : require(filepath);
+}
+
+/**
+ *
+ * @param {string} moduleName
+ * @returns
+ */
+export async function importWebpackSeedModule(moduleName: string): any {
+  return import(`@/database/seeds/core/${moduleName}`);
+}
diff --git a/packages/server/src/lib/Seeder/constants.ts b/packages/server/src/lib/Seeder/constants.ts
new file mode 100644
index 000000000..86fa35eec
--- /dev/null
+++ b/packages/server/src/lib/Seeder/constants.ts
@@ -0,0 +1,12 @@
+// Default load extensions.
+export const DEFAULT_LOAD_EXTENSIONS = [
+  '.co',
+  '.coffee',
+  '.eg',
+  '.iced',
+  '.js',
+  '.cjs',
+  '.litcoffee',
+  '.ls',
+  '.ts',
+];
diff --git a/packages/server/src/lib/Seeder/interfaces.ts b/packages/server/src/lib/Seeder/interfaces.ts
new file mode 100644
index 000000000..a2214e678
--- /dev/null
+++ b/packages/server/src/lib/Seeder/interfaces.ts
@@ -0,0 +1,20 @@
+import { ITenant } from "interfaces";
+
+export interface FsMigrations {}
+
+export interface ISeederConfig {
+  tableName: string;
+  migrationSource: FsMigrations;
+  schemaName?: string;
+  loadExtensions: string[];
+}
+
+export interface MigrateItem {
+  file: string;
+  directory: string;
+}
+
+export interface SeedMigrationContext {
+  i18n: i18nAPI;
+  tenant: ITenant;
+}
\ No newline at end of file
diff --git a/packages/server/src/lib/Transformer/Transformer.ts b/packages/server/src/lib/Transformer/Transformer.ts
new file mode 100644
index 000000000..9a3bce78c
--- /dev/null
+++ b/packages/server/src/lib/Transformer/Transformer.ts
@@ -0,0 +1,197 @@
+import moment from 'moment';
+import * as R from 'ramda';
+import { includes, isFunction, isObject, isUndefined, omit } from 'lodash';
+import { formatNumber } from 'utils';
+
+export class Transformer {
+  public context: any;
+  public options: Record<string, any>;
+
+  /**
+   * Includeded attributes.
+   * @returns {string[]}
+   */
+  public includeAttributes = (): string[] => {
+    return [];
+  };
+
+  /**
+   * Exclude attributes.
+   * @returns {string[]}
+   */
+  public excludeAttributes = (): string[] => {
+    return [];
+  };
+
+  /**
+   * Detarmines whether to exclude all attributes except the include attributes.
+   * @returns {boolean}
+   */
+  public isExcludeAllAttributes = () => {
+    return includes(this.excludeAttributes(), '*');
+  };
+
+  /**
+   *
+   * @param object
+   */
+  transform = (object: any) => {
+    return object;
+  };
+
+  /**
+   *
+   */
+  public work = (object: any) => {
+    if (Array.isArray(object)) {
+      return object.map(this.getTransformation);
+    } else if (isObject(object)) {
+      return this.getTransformation(object);
+    }
+    return object;
+  };
+
+  /**
+   * Transformes the given item to desired output.
+   * @param item
+   * @returns
+   */
+  protected getTransformation = (item) => {
+    const normlizedItem = this.normalizeModelItem(item);
+
+    return R.compose(
+      this.transform,
+      R.when(this.hasExcludeAttributes, this.excludeAttributesTransformed),
+      this.includeAttributesTransformed
+    )(normlizedItem);
+  };
+
+  /**
+   *
+   * @param item
+   * @returns
+   */
+  protected normalizeModelItem = (item) => {
+    return !isUndefined(item.toJSON) ? item.toJSON() : item;
+  };
+
+  /**
+   * Exclude attributes from the given item.
+   */
+  protected excludeAttributesTransformed = (item) => {
+    const exclude = this.excludeAttributes();
+
+    return omit(item, exclude);
+  };
+
+  /**
+   * Incldues virtual attributes.
+   */
+  protected getIncludeAttributesTransformed = (item) => {
+    const attributes = this.includeAttributes();
+
+    return attributes
+      .filter(
+        (attribute) =>
+          isFunction(this[attribute]) || !isUndefined(item[attribute])
+      )
+      .reduce((acc, attribute: string) => {
+        acc[attribute] = isFunction(this[attribute])
+          ? this[attribute](item)
+          : item[attribute];
+
+        return acc;
+      }, {});
+  };
+
+  /**
+   *
+   * @param item
+   * @returns
+   */
+  protected includeAttributesTransformed = (item) => {
+    const excludeAll = this.isExcludeAllAttributes();
+    const virtualAttrs = this.getIncludeAttributesTransformed(item);
+
+    return {
+      ...(!excludeAll ? item : {}),
+      ...virtualAttrs,
+    };
+  };
+
+  /**
+   *
+   * @returns
+   */
+  private hasExcludeAttributes = () => {
+    return this.excludeAttributes().length > 0;
+  };
+
+  /**
+   *
+   * @param date
+   * @returns
+   */
+  protected formatDate(date) {
+    return date ? moment(date).format('YYYY/MM/DD') : '';
+  }
+
+  /**
+   *
+   * @param number
+   * @returns
+   */
+  protected formatNumber(number) {
+    return formatNumber(number, { money: false });
+  }
+
+  /**
+   *
+   * @param money
+   * @param options
+   * @returns
+   */
+  protected formatMoney(money, options?) {
+    return formatNumber(money, {
+      currencyCode: this.context.organization.baseCurrency,
+      ...options,
+    });
+  }
+
+  /**
+   *
+   * @param obj
+   * @param transformer
+   * @param options
+   */
+  public item(
+    obj: Record<string, any>,
+    transformer: Transformer,
+    options?: any
+  ) {
+    transformer.setOptions(options);
+    transformer.setContext(this.context);
+
+    return transformer.work(obj);
+  }
+
+  /**
+   * Sets custom options to the application.
+   * @param   {} options
+   * @returns {Transformer}
+   */
+  public setOptions(options) {
+    this.options = options;
+    return this;
+  }
+
+  /**
+   * Sets the application context to the application.
+   * @param   {} context
+   * @returns {Transformer}
+   */
+  public setContext(context) {
+    this.context = context;
+    return this;
+  }
+}
diff --git a/packages/server/src/lib/Transformer/TransformerInjectable.ts b/packages/server/src/lib/Transformer/TransformerInjectable.ts
new file mode 100644
index 000000000..7343198de
--- /dev/null
+++ b/packages/server/src/lib/Transformer/TransformerInjectable.ts
@@ -0,0 +1,49 @@
+import { Service, Inject } from 'typedi';
+import { isNull } from 'lodash';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { TenantMetadata } from '@/system/models';
+import { Transformer } from './Transformer';
+
+@Service()
+export class TransformerInjectable {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Retrieves the application context of all tenant transformers.
+   * @param   {number} tenantId
+   * @returns {}
+   */
+  async getApplicationContext(tenantId: number) {
+    const i18n = this.tenancy.i18n(tenantId);
+    const organization = await TenantMetadata.query().findOne({ tenantId });
+
+    return {
+      organization,
+      i18n,
+    };
+  }
+
+  /**
+   * Transformes the given transformer after inject the tenant context.
+   * @param   {number} tenantId
+   * @param   {Record<string, any> | Record<string, any>[]} object
+   * @param   {Transformer} transformer
+   * @param   {Record<string, any>} options
+   * @returns {Record<string, any>}
+   */
+  async transform(
+    tenantId: number,
+    object: Record<string, any> | Record<string, any>[],
+    transformer: Transformer,
+    options?: Record<string, any>
+  ) {
+    if (!isNull(tenantId)) {
+      const context = await this.getApplicationContext(tenantId);
+      transformer.setContext(context);
+    }
+    transformer.setOptions(options);
+
+    return transformer.work(object);
+  }
+}
diff --git a/packages/server/src/lib/ViewRolesBuilder/FilterRolesDynamicFilter.js b/packages/server/src/lib/ViewRolesBuilder/FilterRolesDynamicFilter.js
new file mode 100644
index 000000000..978abb53d
--- /dev/null
+++ b/packages/server/src/lib/ViewRolesBuilder/FilterRolesDynamicFilter.js
@@ -0,0 +1,44 @@
+import DynamicFilterRoleAbstructor from '@/lib/DynamicFilter/DynamicFilterRoleAbstructor';
+import {
+  validateViewRoles,
+  buildFilterQuery,
+} from '@/lib/ViewRolesBuilder';
+
+export default class ViewRolesDynamicFilter extends DynamicFilterRoleAbstructor {
+  /**
+   * Constructor method.
+   * @param {*} filterRoles -
+   * @param {*} logicExpression -
+   */
+  constructor(filterRoles, logicExpression) {
+    super();
+
+    this.filterRoles = filterRoles;
+    this.logicExpression = logicExpression;
+
+    this.tableName = '';
+  }
+
+  /**
+   * Retrieve logic expression.
+   */
+  buildLogicExpression() {
+    return this.logicExpression;
+  }
+
+  /**
+   * Validates filter roles.
+   */
+  validateFilterRoles() {
+    return validateViewRoles(this.filterRoles, this.logicExpression);
+  }
+
+  /**
+   * Builds database query of view roles.
+   */
+  buildQuery() {
+    return (builder) => {
+      buildFilterQuery(this.tableName, this.filterRoles, this.logicExpression)(builder);
+    };
+  }
+}
diff --git a/packages/server/src/lib/ViewRolesBuilder/index.ts b/packages/server/src/lib/ViewRolesBuilder/index.ts
new file mode 100644
index 000000000..681bd60d7
--- /dev/null
+++ b/packages/server/src/lib/ViewRolesBuilder/index.ts
@@ -0,0 +1,129 @@
+import { difference } from 'lodash';
+
+import { IFilterRole, IModel } from '@/interfaces';
+
+/**
+ * Get field column metadata and its relation with other tables.
+ * @param {String} tableName - Table name of target column.
+ * @param {String} fieldKey - Target column key that stored in resource field.
+ */
+export function getRoleFieldColumn(model: IModel, fieldKey: string) {
+  const tableFields = model.fields;
+  return tableFields[fieldKey] ? tableFields[fieldKey] : null;
+}
+
+export function buildSortColumnJoin(model: IModel, sortColumnKey: string) {
+  return (builder) => {
+    const fieldColumn = getRoleFieldColumn(model, sortColumnKey);
+
+    if (fieldColumn.relation) {
+      const joinTable = getTableFromRelationColumn(fieldColumn.relation);
+      builder.join(
+        joinTable,
+        `${model.tableName}.${fieldColumn.column}`,
+        '=',
+        fieldColumn.relation
+      );
+    }
+  };
+}
+
+/**
+ * Mapes the view roles to view conditionals.
+ * @param {Array} viewRoles -
+ * @return {Array}
+ */
+export function mapViewRolesToConditionals(viewRoles) {
+  return viewRoles.map((viewRole) => ({
+    comparator: viewRole.comparator,
+    value: viewRole.value,
+    index: viewRole.index,
+
+    columnKey: viewRole.field.key,
+    slug: viewRole.field.slug,
+  }));
+}
+
+export function mapFilterRolesToDynamicFilter(roles) {
+  return roles.map((role) => ({
+    ...role,
+    columnKey: role.fieldKey,
+  }));
+}
+
+/**
+ * Builds sort column query.
+ * @param {String} tableName -
+ * @param {String} columnKey -
+ * @param {String} sortDirection -
+ */
+export function buildSortColumnQuery(
+  model: IModel,
+  columnKey: string,
+  sortDirection: string
+) {
+  const fieldRelation = getRoleFieldColumn(model, columnKey);
+  const sortColumn =
+    fieldRelation.relation || `${model.tableName}.${fieldRelation.column}`;
+
+  return (builder) => {
+    builder.orderBy(sortColumn, sortDirection);
+    buildSortColumnJoin(model, columnKey)(builder);
+  };
+}
+
+export function validateFilterLogicExpression(
+  logicExpression: string,
+  indexes
+) {
+  const logicExpIndexes = logicExpression.match(/\d+/g) || [];
+  const diff = difference(logicExpIndexes.map(Number), indexes);
+
+  return diff.length > 0 ? false : true;
+}
+
+export function validateRolesLogicExpression(
+  logicExpression: string,
+  roles: IFilterRole[]
+) {
+  return validateFilterLogicExpression(
+    logicExpression,
+    roles.map((r) => r.index)
+  );
+}
+
+export function validateFieldKeyExistance(model: any, fieldKey: string) {
+  return model?.fields?.[fieldKey] || false;
+}
+
+
+/**
+ * Retrieve model fields keys.
+ * @param {IModel} Model
+ * @return {string[]}
+ */
+export function getModelFieldsKeys(Model: IModel) {
+  const fields = Object.keys(Model.fields);
+
+  return fields.sort((a, b) => {
+    if (a < b) {
+      return -1;
+    }
+    if (a > b) {
+      return 1;
+    }
+    return 0;
+  });
+}
+
+export function getModelFields(Model: IModel) {
+  const fieldsKey = this.getModelFieldsKeys(Model);
+
+  return fieldsKey.map((fieldKey) => {
+    const field = Model.fields[fieldKey];
+    return {
+      ...field,
+      key: fieldKey,
+    };
+  });
+}
diff --git a/packages/server/src/loaders/agenda.ts b/packages/server/src/loaders/agenda.ts
new file mode 100644
index 000000000..e370a1436
--- /dev/null
+++ b/packages/server/src/loaders/agenda.ts
@@ -0,0 +1,11 @@
+import Agenda from 'agenda';
+import config from '@/config';
+
+export default ({ mongoConnection }) => {
+  return new Agenda({
+    mongo: mongoConnection,
+    db: { collection: config.agenda.dbCollection },
+    processEvery: config.agenda.pooltime,
+    maxConcurrency: config.agenda.concurrency,
+  });
+};
diff --git a/packages/server/src/loaders/database.ts b/packages/server/src/loaders/database.ts
new file mode 100644
index 000000000..8299573f8
--- /dev/null
+++ b/packages/server/src/loaders/database.ts
@@ -0,0 +1,10 @@
+import Knex from 'knex';
+import { knexSnakeCaseMappers } from 'objection';
+import { systemKnexConfig } from '@/config/knexConfig';
+
+export default () => {
+  return Knex({
+    ...systemKnexConfig,
+    ...knexSnakeCaseMappers({ upperCase: true }),
+  });
+};
\ No newline at end of file
diff --git a/packages/server/src/loaders/dbManager.ts b/packages/server/src/loaders/dbManager.ts
new file mode 100644
index 000000000..6aaf31ed2
--- /dev/null
+++ b/packages/server/src/loaders/dbManager.ts
@@ -0,0 +1,7 @@
+import knexManager from 'knex-db-manager';
+import { systemKnexConfig, systemDbManager } from 'config/knexConfig';
+
+export default () => knexManager.databaseManagerFactory({
+  knex: systemKnexConfig,
+  dbManager: systemDbManager,
+});
\ No newline at end of file
diff --git a/packages/server/src/loaders/dependencyInjector.ts b/packages/server/src/loaders/dependencyInjector.ts
new file mode 100644
index 000000000..2c42690dc
--- /dev/null
+++ b/packages/server/src/loaders/dependencyInjector.ts
@@ -0,0 +1,59 @@
+import { Container } from 'typedi';
+import LoggerInstance from '@/loaders/logger';
+import agendaFactory from '@/loaders/agenda';
+import SmsClientLoader from '@/loaders/smsClient';
+import mailInstance from '@/loaders/mail';
+import dbManagerFactory from '@/loaders/dbManager';
+import i18n from '@/loaders/i18n';
+import repositoriesLoader from '@/loaders/systemRepositories';
+import Cache from '@/services/Cache';
+import config from '@/config'
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import rateLimiterLoaders from './rateLimiterLoader';
+import eventEmitter, { susbcribers } from './eventEmitter';
+
+export default ({ mongoConnection, knex }) => {
+  try {
+    const agendaInstance = agendaFactory({ mongoConnection });
+    const smsClientInstance = SmsClientLoader(config.easySMSGateway.api_key);
+    const dbManager = dbManagerFactory(knex);
+    const cacheInstance = new Cache();
+
+    Container.set('logger', LoggerInstance);
+    Container.set('knex', knex);
+    Container.set('SMSClient', smsClientInstance);
+    Container.set('mail', mailInstance);
+  
+    Container.set('dbManager', dbManager);
+    LoggerInstance.info(
+      '[DI] Database manager has been injected into container.'
+    );
+
+    Container.set('agenda', agendaInstance);
+    LoggerInstance.info('[DI] Agenda has been injected into container');
+
+    Container.set('i18n', i18n());
+    LoggerInstance.info('[DI] i18n has been injected into container');
+
+    Container.set('cache', cacheInstance);
+    LoggerInstance.info('[DI] cache has been injected into container');
+
+    Container.set('repositories', repositoriesLoader());
+    LoggerInstance.info('[DI] repositories has been injected into container');
+
+    rateLimiterLoaders();
+    LoggerInstance.info('[DI] rate limiter has been injected into container.');
+
+    Container.set(EventPublisher, eventEmitter());
+
+    const emitter = Container.get(EventPublisher);
+
+    emitter.loadSubscribers(susbcribers());
+
+
+    return { agenda: agendaInstance };
+  } catch (e) {
+    LoggerInstance.error('Error on dependency injector loader: %o', e);
+    throw e;
+  }
+};
diff --git a/packages/server/src/loaders/eventEmitter.ts b/packages/server/src/loaders/eventEmitter.ts
new file mode 100644
index 000000000..8cdb723c4
--- /dev/null
+++ b/packages/server/src/loaders/eventEmitter.ts
@@ -0,0 +1,192 @@
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+import ItemSubscriber from '@/subscribers/Items/ItemSubscriber';
+import InventoryAdjustmentsSubscriber from '@/subscribers/Inventory/InventoryAdjustment';
+import BillWriteInventoryTransactionsSubscriber from '@/subscribers/Bills/WriteInventoryTransactions';
+import PaymentSyncBillBalance from '@/subscribers/PaymentMades/PaymentSyncBillBalance';
+import SaleReceiptInventoryTransactionsSubscriber from '@/subscribers/SaleReceipt/WriteInventoryTransactions';
+import SaleInvoiceWriteInventoryTransactions from '@/subscribers/SaleInvoices/WriteInventoryTransactions';
+import SaleInvoiceWriteGLEntriesSubscriber from '@/subscribers/SaleInvoices/WriteJournalEntries';
+import PaymentReceiveSyncInvoices from '@/subscribers/PaymentReceive/PaymentReceiveSyncInvoices';
+import CashflowTransactionSubscriber from '@/services/Cashflow/CashflowTransactionSubscriber';
+import PaymentReceivesWriteGLEntriesSubscriber from '@/subscribers/PaymentReceive/WriteGLEntries';
+import InventorySubscriber from '@/subscribers/Inventory/Inventory';
+import SaleReceiptWriteGLEntriesSubscriber from '@/subscribers/SaleReceipt/WriteJournalEntries';
+import { CustomerWriteGLOpeningBalanceSubscriber } from '@/services/Contacts/Customers/Subscribers/CustomerGLEntriesSubscriber';
+import { VendorsWriteGLOpeningSubscriber } from '@/services/Contacts/Vendors/Subscribers/VendorGLEntriesSubscriber';
+import SaleEstimateAutoSerialSubscriber from '@/subscribers/SaleEstimate/AutoIncrementSerial';
+import SaleEstimateSmsNotificationSubscriber from '@/subscribers/SaleEstimate/SmsNotifications';
+import { ExpensesWriteGLSubscriber } from '@/services/Expenses/ExpenseGLEntriesSubscriber';
+import SaleReceiptAutoSerialSubscriber from '@/subscribers/SaleReceipt/AutoIncrementSerial';
+import SaleInvoiceAutoIncrementSubscriber from '@/subscribers/SaleInvoices/AutoIncrementSerial';
+import SaleInvoiceConvertFromEstimateSubscriber from '@/subscribers/SaleInvoices/ConvertFromEstimate';
+import PaymentReceiveAutoSerialSubscriber from '@/subscribers/PaymentReceive/AutoSerialIncrement';
+import SyncSystemSendInvite from '@/services/InviteUsers/SyncSystemSendInvite';
+import InviteSendMainNotification from '@/services/InviteUsers/InviteSendMailNotification';
+import SyncTenantAcceptInvite from '@/services/InviteUsers/SyncTenantAcceptInvite';
+import SyncTenantUserMutate from '@/services/Users/SyncTenantUserSaved';
+import OrgSyncTenantAdminUserSubscriber from '@/subscribers/Organization/SyncTenantAdminUser';
+import OrgBuildSmsNotificationSubscriber from '@/subscribers/Organization/BuildSmsNotification';
+import PurgeUserAbilityCache from '@/services/Users/PurgeUserAbilityCache';
+import ResetLoginThrottleSubscriber from '@/subscribers/Authentication/ResetLoginThrottle';
+import AuthenticationSubscriber from '@/subscribers/Authentication/SendResetPasswordMail';
+import AuthSendWelcomeMailSubscriber from '@/subscribers/Authentication/SendWelcomeMail';
+import PurgeAuthorizedUserOnceRoleMutate from '@/services/Roles/PurgeAuthorizedUser';
+import SendSmsNotificationToCustomer from '@/subscribers/SaleInvoices/SendSmsNotificationToCustomer';
+import SendSmsNotificationSaleReceipt from '@/subscribers/SaleReceipt/SendSmsNotificationToCustomer';
+import SendSmsNotificationPaymentReceive from '@/subscribers/PaymentReceive/SendSmsNotificationToCustomer';
+import SaleInvoiceWriteoffSubscriber from '@/services/Sales/SaleInvoiceWriteoffSubscriber';
+import LandedCostSyncCostTransactionsSubscriber from '@/services/Purchases/LandedCost/LandedCostSyncCostTransactionsSubscriber';
+import LandedCostInventoryTransactionsSubscriber from '@/services/Purchases/LandedCost/LandedCostInventoryTransactionsSubscriber';
+import CreditNoteGLEntriesSubscriber from '@/services/CreditNotes/CreditNoteGLEntriesSubscriber';
+import VendorCreditGlEntriesSubscriber from '@/services/Purchases/VendorCredits/VendorCreditGLEntriesSubscriber';
+import CreditNoteInventoryTransactionsSubscriber from '@/services/CreditNotes/CreditNoteInventoryTransactionsSubscriber';
+import VendorCreditInventoryTransactionsSubscriber from '@/services/Purchases/VendorCredits/VendorCreditInventoryTransactionsSusbcriber';
+import CreditNoteAutoSerialSubscriber from '@/services/CreditNotes/CreditNoteAutoSerialSubscriber';
+import VendorCreditAutoSerialSubscriber from '@/services/Purchases/VendorCredits/VendorCreditAutoSerialSubscriber';
+import LandedCostGLEntriesSubscriber from '@/services/Purchases/LandedCost/LandedCostGLEntriesSubscriber';
+import RefundCreditNoteGLEntriesSubscriber from '@/services/CreditNotes/RefundCreditNoteGLEntriesSubscriber';
+import RefundVendorCreditGLEntriesSubscriber from '@/services/Purchases/VendorCredits/RefundVendorCredits/RefundVendorCreditGLEntriesSubscriber';
+import RefundSyncCreditNoteBalanceSubscriber from '@/services/CreditNotes/RefundSyncCreditNoteBalanceSubscriber';
+import RefundSyncVendorCreditBalanceSubscriber from '@/services/Purchases/VendorCredits/RefundVendorCredits/RefundSyncVendorCreditBalanceSubscriber';
+import CreditNoteApplySyncCreditSubscriber from '@/services/CreditNotes/CreditNoteApplySyncCreditSubscriber';
+import CreditNoteApplySyncInvoicesCreditedAmountSubscriber from '@/services/CreditNotes/CreditNoteApplySyncInvoicesSubscriber';
+import ApplyVendorCreditSyncInvoicedSubscriber from '@/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditSyncInvoicedSubscriber';
+import ApplyVendorCreditSyncBillsSubscriber from '@/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditSyncBillsSubscriber';
+import DeleteCustomerLinkedCreditSubscriber from '@/services/CreditNotes/DeleteCustomerLinkedCreditSubscriber';
+import DeleteVendorAssociatedVendorCredit from '@/services/Purchases/VendorCredits/DeleteVendorAssociatedVendorCredit';
+import SalesTransactionLockingGuardSubscriber from '@/services/TransactionsLocking/SalesTransactionLockingGuardSubscriber';
+import PurchasesTransactionLockingGuardSubscriber from '@/services/TransactionsLocking/PurchasesTransactionLockingGuardSubscriber';
+import FinancialTransactionLockingGuardSubscriber from '@/services/TransactionsLocking/FinancialsTransactionLockingGuardSubscriber';
+import CashflowWithAccountSubscriber from '@/services/Cashflow/CashflowWithAccountSubscriber';
+import { WarehousesItemsQuantitySyncSubscriber } from '@/services/Warehouses/Integrations/WarehousesItemsQuantitySynSubscriber';
+import { WarehouseTransferInventoryTransactionsSubscriber } from '@/services/Warehouses/WarehousesTransfers/WarehouseTransferInventoryTransactionsSubscriber';
+import { AccountsTransactionsWarehousesSubscribe } from '@/services/Accounting/AccountsTransactionsWarehousesSubscribe';
+import { ActivateWarehousesSubscriber } from '@/services/Warehouses/ActivateWarehousesSubscriber';
+import { ManualJournalWriteGLSubscriber } from '@/services/ManualJournals/ManualJournalGLEntriesSubscriber';
+import { BillGLEntriesSubscriber } from '@/services/Purchases/Bills/BillGLEntriesSubscriber';
+import { PaymentWriteGLEntriesSubscriber } from '@/services/Purchases/BillPayments/BillPaymentGLEntriesSubscriber';
+
+import BranchesIntegrationsSubscribers from '@/services/Branches/EventsProvider';
+import WarehousesIntegrationsSubscribers from '@/services/Warehouses/EventsProvider';
+import { WarehouseTransferAutoIncrementSubscriber } from '@/services/Warehouses/WarehousesTransfers/WarehouseTransferAutoIncrementSubscriber';
+import { InvoicePaymentGLRewriteSubscriber } from '@/services/Sales/Invoices/subscribers/InvoicePaymentGLRewriteSubscriber';
+import { BillPaymentsGLEntriesRewriteSubscriber } from '@/services/Purchases/Bills/BillPaymentsGLEntriesRewriteSubscriber';
+import { InvoiceCostGLEntriesSubscriber } from '@/services/Sales/Invoices/subscribers/InvoiceCostGLEntriesSubscriber';
+import { InventoryCostGLBeforeWriteSubscriber } from '@/services/Inventory/subscribers/InventoryCostGLBeforeWriteSubscriber';
+import { SaleReceiptCostGLEntriesSubscriber } from '@/services/Sales/Receipts/subscribers/SaleReceiptCostGLEntriesSubscriber';
+import { SeedInitialCurrenciesOnSetupSubsriber } from '@/services/Currencies/subscribers/SeedInitialCurrenciesOnSetupSubscriber';
+import { MutateBaseCurrencyAccountsSubscriber } from '@/services/Accounts/susbcribers/MutateBaseCurrencyAccounts';
+import { ProjectBillableTasksSubscriber } from '@/services/Projects/Projects/ProjectBillableTasksSubscriber';
+import { ProjectBillableExpensesSubscriber } from '@/services/Projects/Projects/ProjectBillableExpenseSubscriber';
+import { ProjectBillableBillSubscriber } from '@/services/Projects/Projects/ProjectBillableBillSubscriber';
+import { SyncActualTimeTaskSubscriber } from '@/services/Projects/Times/SyncActualTimeTaskSubscriber';
+
+export default () => {
+  return new EventPublisher();
+};
+
+export const susbcribers = () => {
+  return [
+    ItemSubscriber,
+    InventoryAdjustmentsSubscriber,
+    BillWriteInventoryTransactionsSubscriber,
+    PaymentSyncBillBalance,
+    SaleReceiptInventoryTransactionsSubscriber,
+    SaleReceiptWriteGLEntriesSubscriber,
+    SaleInvoiceWriteInventoryTransactions,
+    SaleInvoiceWriteGLEntriesSubscriber,
+    PaymentReceiveSyncInvoices,
+    PaymentReceivesWriteGLEntriesSubscriber,
+    CashflowTransactionSubscriber,
+    InventorySubscriber,
+    CustomerWriteGLOpeningBalanceSubscriber,
+    VendorsWriteGLOpeningSubscriber,
+    SaleEstimateAutoSerialSubscriber,
+    SaleEstimateSmsNotificationSubscriber,
+    ExpensesWriteGLSubscriber,
+    SaleReceiptAutoSerialSubscriber,
+    SaleInvoiceAutoIncrementSubscriber,
+    SaleInvoiceConvertFromEstimateSubscriber,
+    PaymentReceiveAutoSerialSubscriber,
+    SyncSystemSendInvite,
+    SyncTenantAcceptInvite,
+    InviteSendMainNotification,
+    SyncTenantUserMutate,
+    OrgSyncTenantAdminUserSubscriber,
+    OrgBuildSmsNotificationSubscriber,
+    PurgeUserAbilityCache,
+    ResetLoginThrottleSubscriber,
+    AuthenticationSubscriber,
+    AuthSendWelcomeMailSubscriber,
+    PurgeAuthorizedUserOnceRoleMutate,
+    SendSmsNotificationToCustomer,
+    SendSmsNotificationSaleReceipt,
+    SendSmsNotificationPaymentReceive,
+    SaleInvoiceWriteoffSubscriber,
+    LandedCostSyncCostTransactionsSubscriber,
+    LandedCostInventoryTransactionsSubscriber,
+    CreditNoteGLEntriesSubscriber,
+    VendorCreditGlEntriesSubscriber,
+    CreditNoteInventoryTransactionsSubscriber,
+    VendorCreditInventoryTransactionsSubscriber,
+    CreditNoteAutoSerialSubscriber,
+    VendorCreditAutoSerialSubscriber,
+    LandedCostGLEntriesSubscriber,
+    RefundCreditNoteGLEntriesSubscriber,
+    RefundVendorCreditGLEntriesSubscriber,
+    RefundSyncCreditNoteBalanceSubscriber,
+    RefundSyncVendorCreditBalanceSubscriber,
+    CreditNoteApplySyncCreditSubscriber,
+    CreditNoteApplySyncInvoicesCreditedAmountSubscriber,
+    ApplyVendorCreditSyncInvoicedSubscriber,
+    ApplyVendorCreditSyncBillsSubscriber,
+    DeleteCustomerLinkedCreditSubscriber,
+    DeleteVendorAssociatedVendorCredit,
+
+    // # Inventory
+    InventoryCostGLBeforeWriteSubscriber,
+
+    // #Invoices
+    InvoicePaymentGLRewriteSubscriber,
+    InvoiceCostGLEntriesSubscriber,
+
+    BillPaymentsGLEntriesRewriteSubscriber,
+
+    // # Receipts
+    SaleReceiptCostGLEntriesSubscriber,
+
+    // Transaction locking.
+    SalesTransactionLockingGuardSubscriber,
+    PurchasesTransactionLockingGuardSubscriber,
+    FinancialTransactionLockingGuardSubscriber,
+    CashflowWithAccountSubscriber,
+
+    // Warehouses
+    WarehousesItemsQuantitySyncSubscriber,
+    WarehouseTransferInventoryTransactionsSubscriber,
+    WarehouseTransferAutoIncrementSubscriber,
+    ActivateWarehousesSubscriber,
+
+    // Branches.
+    AccountsTransactionsWarehousesSubscribe,
+    ...BranchesIntegrationsSubscribers(),
+    ...WarehousesIntegrationsSubscribers(),
+
+    // Manual Journals
+    ManualJournalWriteGLSubscriber,
+
+    // Bills
+    BillGLEntriesSubscriber,
+    PaymentWriteGLEntriesSubscriber,
+
+    SeedInitialCurrenciesOnSetupSubsriber,
+    MutateBaseCurrencyAccountsSubscriber,
+
+    // # Projects
+    SyncActualTimeTaskSubscriber,
+    ProjectBillableTasksSubscriber,
+    ProjectBillableExpensesSubscriber,
+    ProjectBillableBillSubscriber,
+  ];
+};
diff --git a/packages/server/src/loaders/events.ts b/packages/server/src/loaders/events.ts
new file mode 100644
index 000000000..f402a6087
--- /dev/null
+++ b/packages/server/src/loaders/events.ts
@@ -0,0 +1,37 @@
+// Here we import all events.
+// import 'subscribers/authentication';
+// import 'subscribers/organization';
+// import 'subscribers/inviteUser';
+// import 'subscribers/manualJournals';
+// import 'subscribers/expenses';
+
+// import 'subscribers/Bills';
+// import 'subscribers/Bills/WriteJournalEntries';
+// import 'subscribers/Bills/WriteInventoryTransactions';
+
+// // import 'subscribers/SaleInvoices';
+// // import 'subscribers/SaleInvoices/WriteInventoryTransactions';
+// // import 'subscribers/SaleInvoices/WriteJournalEntries';
+
+// import 'subscribers/SaleReceipt';
+// import 'subscribers/SaleReceipt/WriteInventoryTransactions';
+// import 'subscribers/SaleReceipt/WriteJournalEntries';
+
+// import 'subscribers/Inventory/Inventory';
+// import 'subscribers/Inventory/InventoryAdjustment';
+
+// import 'subscribers/customers';
+// import 'subscribers/vendors';
+// import 'subscribers/paymentMades';
+// import 'subscribers/paymentReceives';
+// import 'subscribers/saleEstimates';
+// import 'subscribers/items';
+
+// import 'subscribers/LandedCost';
+
+// import 'services/Cashflow/CashflowTransactionSubscriber';
+
+// import 'services/Sales/SaleInvoiceWriteoffSubscriber';
+// import 'subscribers/SaleInvoices/SendSmsNotificationToCustomer';
+// import 'subscribers/SaleReceipt/SendNotificationToCustomer';
+// import 'services/Sales/PaymentReceives/PaymentReceiveSmsSubscriber';
\ No newline at end of file
diff --git a/packages/server/src/loaders/express.ts b/packages/server/src/loaders/express.ts
new file mode 100644
index 000000000..696ef895b
--- /dev/null
+++ b/packages/server/src/loaders/express.ts
@@ -0,0 +1,72 @@
+import { json, Request, Response, NextFunction } from 'express';
+import helmet from 'helmet';
+import boom from 'express-boom';
+import errorHandler from 'errorhandler';
+import bodyParser from 'body-parser';
+import fileUpload from 'express-fileupload';
+import routes from 'api';
+import LoggerMiddleware from '@/api/middleware/LoggerMiddleware';
+import AgendashController from '@/api/controllers/Agendash';
+import ConvertEmptyStringsToNull from '@/api/middleware/ConvertEmptyStringsToNull';
+import RateLimiterMiddleware from '@/api/middleware/RateLimiterMiddleware';
+import {
+  JSONResponseTransformer,
+  snakecaseResponseTransformer,
+} from '@/api/middleware/JSONResponseTransformer';
+import config from '@/config';
+import path from 'path';
+import ObjectionErrorHandlerMiddleware from '@/api/middleware/ObjectionErrorHandlerMiddleware';
+
+export default ({ app }) => {
+  // Express configuration.
+  app.set('port', 3000);
+
+  // Template engine configuration.
+  app.set('views', path.join(__dirname, '../resources/views'));
+  app.set('view engine', 'pug');
+
+  // Helmet helps you secure your Express apps by setting various HTTP headers.
+  app.use(helmet());
+
+  // Allow to full error stack traces and internal details
+  app.use(errorHandler());
+
+  // Boom response objects.
+  app.use(boom());
+
+  app.use(bodyParser.json());
+
+  // Parses both json and urlencoded.
+  app.use(json());
+
+  // Middleware for intercepting and transforming json responses.
+  app.use(JSONResponseTransformer(snakecaseResponseTransformer));
+
+  // Handle multi-media requests.
+  app.use(
+    fileUpload({
+      createParentPath: true,
+    })
+  );
+
+  // Logger middleware.
+  app.use(LoggerMiddleware);
+
+  // Converts empty strings to null of request body.
+  app.use(ConvertEmptyStringsToNull);
+
+  // Prefix all application routes.
+  app.use(config.api.prefix, RateLimiterMiddleware);
+  app.use(config.api.prefix, routes());
+
+  // Agendash application load.
+  app.use('/agendash', AgendashController.router());
+
+  // Handles objectionjs errors.
+  app.use(ObjectionErrorHandlerMiddleware);
+
+  // catch 404 and forward to error handler
+  app.use((req: Request, res: Response, next: NextFunction) => {
+    return res.boom.notFound();
+  });
+};
diff --git a/packages/server/src/loaders/i18n.ts b/packages/server/src/loaders/i18n.ts
new file mode 100644
index 000000000..42706fb5b
--- /dev/null
+++ b/packages/server/src/loaders/i18n.ts
@@ -0,0 +1,8 @@
+import { I18n } from 'i18n';
+
+export default () => new I18n({
+  locales: ['en', 'ar'],
+  register: global,
+  directory: global.__locales_dir,
+  updateFiles: false,
+});
\ No newline at end of file
diff --git a/packages/server/src/loaders/index.ts b/packages/server/src/loaders/index.ts
new file mode 100644
index 000000000..08e9e1afd
--- /dev/null
+++ b/packages/server/src/loaders/index.ts
@@ -0,0 +1,34 @@
+import Logger from '@/loaders/logger';
+import mongooseLoader from '@/loaders/mongoose';
+import jobsLoader from '@/loaders/jobs';
+import expressLoader from '@/loaders/express';
+import databaseLoader from '@/loaders/database';
+import dependencyInjectorLoader from '@/loaders/dependencyInjector';
+import objectionLoader from '@/database/objection';
+import i18nConfig from '@/loaders/i18n';
+
+// We have to import at least all the events once so they can be triggered
+// import '@/loaders/events';
+
+export default async ({ expressApp }) => {
+  const mongoConnection = await mongooseLoader();
+  Logger.info('[init] MongoDB loaded and connected!');
+
+  // Initialize the system database once app started.
+  const knex = databaseLoader();
+
+  // Initialize the objection.js from knex instance.
+  objectionLoader({ knex });
+
+  // It returns the agenda instance because it's needed in the subsequent loaders
+  const { agenda } = await dependencyInjectorLoader({ mongoConnection, knex });
+
+  await jobsLoader({ agenda });
+  Logger.info('[init] Jobs loaded');
+
+  expressLoader({ app: expressApp });
+  Logger.info('[init] Express loaded');
+
+  i18nConfig();
+  Logger.info('[init] I18n node configured.');
+};
diff --git a/packages/server/src/loaders/jobs.ts b/packages/server/src/loaders/jobs.ts
new file mode 100644
index 000000000..448df7ec4
--- /dev/null
+++ b/packages/server/src/loaders/jobs.ts
@@ -0,0 +1,52 @@
+import Agenda from 'agenda';
+import WelcomeEmailJob from 'jobs/welcomeEmail';
+import WelcomeSMSJob from 'jobs/WelcomeSMS';
+import ResetPasswordMailJob from 'jobs/ResetPasswordMail';
+import ComputeItemCost from 'jobs/ComputeItemCost';
+import RewriteInvoicesJournalEntries from 'jobs/writeInvoicesJEntries';
+import SendLicenseViaPhoneJob from 'jobs/SendLicensePhone';
+import SendLicenseViaEmailJob from 'jobs/SendLicenseEmail';
+import SendSMSNotificationSubscribeEnd from 'jobs/SMSNotificationSubscribeEnd';
+import SendSMSNotificationTrialEnd from 'jobs/SMSNotificationTrialEnd';
+import SendMailNotificationSubscribeEnd from 'jobs/MailNotificationSubscribeEnd';
+import SendMailNotificationTrialEnd from 'jobs/MailNotificationTrialEnd';
+import UserInviteMailJob from 'jobs/UserInviteMail';
+import OrganizationSetupJob from 'jobs/OrganizationSetup';
+import OrganizationUpgrade from 'jobs/OrganizationUpgrade';
+import SmsNotification from 'jobs/SmsNotification';
+
+export default ({ agenda }: { agenda: Agenda }) => {
+  new WelcomeEmailJob(agenda);
+  new ResetPasswordMailJob(agenda);
+  new WelcomeSMSJob(agenda);
+  new UserInviteMailJob(agenda);
+  new SendLicenseViaEmailJob(agenda);
+  new SendLicenseViaPhoneJob(agenda);
+  new ComputeItemCost(agenda);
+  new RewriteInvoicesJournalEntries(agenda);
+  new OrganizationSetupJob(agenda);
+  new OrganizationUpgrade(agenda);
+  new SmsNotification(agenda);
+
+  agenda.define(
+    'send-sms-notification-subscribe-end',
+    { priority: 'nromal', concurrency: 1, },
+    new SendSMSNotificationSubscribeEnd().handler,
+  );
+  agenda.define(
+    'send-sms-notification-trial-end',
+    { priority: 'normal', concurrency: 1, },
+    new SendSMSNotificationTrialEnd().handler,
+  );
+  agenda.define(
+    'send-mail-notification-subscribe-end',
+    { priority: 'high', concurrency: 1, },
+    new SendMailNotificationSubscribeEnd().handler
+  );
+  agenda.define(
+    'send-mail-notification-trial-end',
+    { priority: 'high', concurrency: 1, },
+    new SendMailNotificationTrialEnd().handler
+  );
+  agenda.start();
+};
diff --git a/packages/server/src/loaders/logger.ts b/packages/server/src/loaders/logger.ts
new file mode 100644
index 000000000..cbdf1a3fa
--- /dev/null
+++ b/packages/server/src/loaders/logger.ts
@@ -0,0 +1,13 @@
+import winston from 'winston';
+
+const transports = {
+  console: new winston.transports.Console({ level: 'warn' }),
+  file: new winston.transports.File({ filename: 'stdout.log' }),
+};
+
+export default winston.createLogger({
+  transports: [
+    transports.console,
+    transports.file,
+  ],
+});
diff --git a/packages/server/src/loaders/mail.ts b/packages/server/src/loaders/mail.ts
new file mode 100644
index 000000000..496a7f78a
--- /dev/null
+++ b/packages/server/src/loaders/mail.ts
@@ -0,0 +1,15 @@
+import nodemailer from 'nodemailer';
+import config from '@/config';
+
+// create reusable transporter object using the default SMTP transport
+const transporter = nodemailer.createTransport({
+  host: config.mail.host,
+  port: config.mail.port,
+  secure: config.mail.secure, // true for 465, false for other ports
+  auth: {
+    user: config.mail.username,
+    pass: config.mail.password,
+  },
+});
+
+export default transporter;
\ No newline at end of file
diff --git a/packages/server/src/loaders/mongoose.ts b/packages/server/src/loaders/mongoose.ts
new file mode 100644
index 000000000..e241afd33
--- /dev/null
+++ b/packages/server/src/loaders/mongoose.ts
@@ -0,0 +1,11 @@
+import mongoose from 'mongoose';
+import { Db } from 'mongodb';
+import config from '@/config';
+
+export default async (): Promise<Db> => {
+  const connection = await mongoose.connect(
+    config.mongoDb.databaseURL,
+    { useNewUrlParser: true, useCreateIndex: true },
+  );
+  return connection.connection.db;
+};
diff --git a/packages/server/src/loaders/rateLimiterLoader.ts b/packages/server/src/loaders/rateLimiterLoader.ts
new file mode 100644
index 000000000..b272f0d53
--- /dev/null
+++ b/packages/server/src/loaders/rateLimiterLoader.ts
@@ -0,0 +1,24 @@
+import RateLimiter from '@/services/Authentication/RateLimiter';
+import { Container } from 'typedi';
+import { RateLimiterMemory } from 'rate-limiter-flexible';
+import config from '@/config';
+
+export default () => {
+  const rateLimiterRequestsMemory = new RateLimiterMemory({
+    points: config.throttler.requests.points,
+    duration: config.throttler.requests.duration,
+    blockDuration: config.throttler.requests.blockDuration,
+  });
+  const rateLimiterMemoryLogin = new RateLimiterMemory({
+    points: config.throttler.login.points,
+    duration: config.throttler.login.duration,
+    blockDuration: config.throttler.login.blockDuration,
+  });
+
+  const rateLimiterRequest = new RateLimiter(rateLimiterRequestsMemory);
+  const rateLimiterLogin = new RateLimiter(rateLimiterMemoryLogin)
+
+  // Inject the rate limiter of the global requests and login into the container.
+  Container.set('rateLimiter.request', rateLimiterRequest);
+  Container.set('rateLimiter.login', rateLimiterLogin);
+};
\ No newline at end of file
diff --git a/packages/server/src/loaders/smsClient.ts b/packages/server/src/loaders/smsClient.ts
new file mode 100644
index 000000000..b61d01bbf
--- /dev/null
+++ b/packages/server/src/loaders/smsClient.ts
@@ -0,0 +1,9 @@
+import SMSClient from '@/services/SMSClient';
+import EasySMSGateway from '@/services/SMSClient/EasySmsClient';
+
+export default (token: string) => {
+  const easySmsGateway = new EasySMSGateway(token);
+  const smsClient = new SMSClient(easySmsGateway);
+  
+  return smsClient;
+};
diff --git a/packages/server/src/loaders/systemRepositories.ts b/packages/server/src/loaders/systemRepositories.ts
new file mode 100644
index 000000000..4d84583ca
--- /dev/null
+++ b/packages/server/src/loaders/systemRepositories.ts
@@ -0,0 +1,17 @@
+import Container from 'typedi';
+import {
+  SystemUserRepository,
+  SubscriptionRepository,
+  TenantRepository,
+} from '@/system/repositories';
+
+export default () => {
+  const knex = Container.get('knex');
+  const cache = Container.get('cache');
+
+  return {
+    systemUserRepository: new SystemUserRepository(knex, cache),
+    subscriptionRepository: new SubscriptionRepository(knex, cache),
+    tenantRepository: new TenantRepository(knex, cache),
+  };
+}
\ No newline at end of file
diff --git a/packages/server/src/loaders/tenantCache.ts b/packages/server/src/loaders/tenantCache.ts
new file mode 100644
index 000000000..79cae5915
--- /dev/null
+++ b/packages/server/src/loaders/tenantCache.ts
@@ -0,0 +1,8 @@
+import { Container } from 'typedi';
+import Cache from '@/services/Cache';
+
+export default (tenantId: number) => {
+  const cacheInstance = new Cache();
+
+  return cacheInstance;
+};
\ No newline at end of file
diff --git a/packages/server/src/loaders/tenantModels.ts b/packages/server/src/loaders/tenantModels.ts
new file mode 100644
index 000000000..5e07ff3dd
--- /dev/null
+++ b/packages/server/src/loaders/tenantModels.ts
@@ -0,0 +1,124 @@
+import { mapValues } from 'lodash';
+
+import Account from 'models/Account';
+import AccountTransaction from 'models/AccountTransaction';
+import Item from 'models/Item';
+import ItemEntry from 'models/ItemEntry';
+import ItemCategory from 'models/ItemCategory';
+import Bill from 'models/Bill';
+import BillPayment from 'models/BillPayment';
+import BillPaymentEntry from 'models/BillPaymentEntry';
+import Currency from 'models/Currency';
+import Contact from 'models/Contact';
+import Vendor from 'models/Vendor';
+import Customer from 'models/Customer';
+import ExchangeRate from 'models/ExchangeRate';
+import Expense from 'models/Expense';
+import ExpenseCategory from 'models/ExpenseCategory';
+import View from 'models/View';
+import ViewRole from 'models/ViewRole';
+import ViewColumn from 'models/ViewColumn';
+import Setting from 'models/Setting';
+import SaleInvoice from 'models/SaleInvoice';
+import SaleInvoiceEntry from 'models/SaleInvoiceEntry';
+import SaleReceipt from 'models/SaleReceipt';
+import SaleReceiptEntry from 'models/SaleReceiptEntry';
+import SaleEstimate from 'models/SaleEstimate';
+import SaleEstimateEntry from 'models/SaleEstimateEntry';
+import PaymentReceive from 'models/PaymentReceive';
+import PaymentReceiveEntry from 'models/PaymentReceiveEntry';
+import Option from 'models/Option';
+import InventoryCostLotTracker from 'models/InventoryCostLotTracker';
+import InventoryTransaction from 'models/InventoryTransaction';
+import ManualJournal from 'models/ManualJournal';
+import ManualJournalEntry from 'models/ManualJournalEntry';
+import Media from 'models/Media';
+import MediaLink from 'models/MediaLink';
+import InventoryAdjustment from 'models/InventoryAdjustment';
+import InventoryAdjustmentEntry from 'models/InventoryAdjustmentEntry';
+import BillLandedCost from 'models/BillLandedCost';
+import BillLandedCostEntry from 'models/BillLandedCostEntry';
+import CashflowAccount from 'models/CashflowAccount';
+import CashflowTransaction from 'models/CashflowTransaction';
+import CashflowTransactionLine from 'models/CashflowTransactionLine';
+import Role from 'models/Role';
+import RolePermission from 'models/RolePermission';
+import User from 'models/User';
+import CreditNote from 'models/CreditNote';
+import VendorCredit from 'models/VendorCredit';
+import RefundCreditNote from 'models/RefundCreditNote';
+import RefundVendorCredit from 'models/RefundVendorCredit';
+import CreditNoteAppliedInvoice from 'models/CreditNoteAppliedInvoice';
+import VendorCreditAppliedBill from 'models/VendorCreditAppliedBill';
+import Branch from 'models/Branch';
+import Warehouse from 'models/Warehouse';
+import WarehouseTransfer from 'models/WarehouseTransfer';
+import WarehouseTransferEntry from 'models/WarehouseTransferEntry';
+import ItemWarehouseQuantity from 'models/ItemWarehouseQuantity';
+import Project from 'models/Project';
+import Time from 'models/Time';
+import Task from 'models/Task';
+
+export default (knex) => {
+  const models = {
+    Option,
+    Account,
+    AccountTransaction,
+    Item,
+    ItemCategory,
+    ItemEntry,
+    ManualJournal,
+    ManualJournalEntry,
+    Bill,
+    BillPayment,
+    BillPaymentEntry,
+    Currency,
+    ExchangeRate,
+    Expense,
+    ExpenseCategory,
+    View,
+    ViewRole,
+    ViewColumn,
+    Setting,
+    SaleInvoice,
+    SaleInvoiceEntry,
+    SaleReceipt,
+    SaleReceiptEntry,
+    SaleEstimate,
+    SaleEstimateEntry,
+    PaymentReceive,
+    PaymentReceiveEntry,
+    InventoryTransaction,
+    InventoryCostLotTracker,
+    Media,
+    MediaLink,
+    Vendor,
+    Customer,
+    Contact,
+    InventoryAdjustment,
+    InventoryAdjustmentEntry,
+    BillLandedCost,
+    BillLandedCostEntry,
+    CashflowTransaction,
+    CashflowTransactionLine,
+    CashflowAccount,
+    Role,
+    RolePermission,
+    User,
+    VendorCredit,
+    CreditNote,
+    RefundCreditNote,
+    RefundVendorCredit,
+    CreditNoteAppliedInvoice,
+    VendorCreditAppliedBill,
+    Branch,
+    Warehouse,
+    WarehouseTransfer,
+    WarehouseTransferEntry,
+    ItemWarehouseQuantity,
+    Project,
+    Time,
+    Task,
+  };
+  return mapValues(models, (model) => model.bindKnex(knex));
+};
diff --git a/packages/server/src/loaders/tenantRepositories.ts b/packages/server/src/loaders/tenantRepositories.ts
new file mode 100644
index 000000000..c5f3dbec1
--- /dev/null
+++ b/packages/server/src/loaders/tenantRepositories.ts
@@ -0,0 +1,41 @@
+import AccountRepository from '@/repositories/AccountRepository';
+import VendorRepository from '@/repositories/VendorRepository';
+import CustomerRepository from '@/repositories/CustomerRepository';
+import ExpenseRepository from '@/repositories/ExpenseRepository';
+import ViewRepository from '@/repositories/ViewRepository';
+import ViewRoleRepository from '@/repositories/ViewRoleRepository';
+import ContactRepository from '@/repositories/ContactRepository';
+import AccountTransactionsRepository from '@/repositories/AccountTransactionRepository';
+import SettingRepository from '@/repositories/SettingRepository';
+import ExpenseEntryRepository from '@/repositories/ExpenseEntryRepository';
+import BillRepository from '@/repositories/BillRepository';
+import SaleInvoiceRepository from '@/repositories/SaleInvoiceRepository';
+import ItemRepository from '@/repositories/ItemRepository';
+import InventoryTransactionRepository from '@/repositories/InventoryTransactionRepository';
+
+export default (knex, cache, i18n) => {
+  return {
+    accountRepository: new AccountRepository(knex, cache, i18n),
+    transactionsRepository: new AccountTransactionsRepository(
+      knex,
+      cache,
+      i18n
+    ),
+    customerRepository: new CustomerRepository(knex, cache, i18n),
+    vendorRepository: new VendorRepository(knex, cache, i18n),
+    contactRepository: new ContactRepository(knex, cache, i18n),
+    expenseRepository: new ExpenseRepository(knex, cache, i18n),
+    expenseEntryRepository: new ExpenseEntryRepository(knex, cache, i18n),
+    viewRepository: new ViewRepository(knex, cache, i18n),
+    viewRoleRepository: new ViewRoleRepository(knex, cache, i18n),
+    settingRepository: new SettingRepository(knex, cache, i18n),
+    billRepository: new BillRepository(knex, cache, i18n),
+    saleInvoiceRepository: new SaleInvoiceRepository(knex, cache, i18n),
+    itemRepository: new ItemRepository(knex, cache, i18n),
+    inventoryTransactionRepository: new InventoryTransactionRepository(
+      knex,
+      cache,
+      i18n
+    ),
+  };
+};
diff --git a/packages/server/src/locales/ar.json b/packages/server/src/locales/ar.json
new file mode 100644
index 000000000..f7bed4726
--- /dev/null
+++ b/packages/server/src/locales/ar.json
@@ -0,0 +1,640 @@
+{
+  "Petty Cash": "العهدة",
+  "Cash": "النقدية",
+  "Bank": "المصرف",
+  "Other Income": "إيرادات اخري",
+  "Interest Income": "إيرادات الفوائد",
+  "Depreciation Expense": "مصاريف الاهلاك",
+  "Interest Expense": "مصروفات الفوائد",
+  "Sales of Product Income": "مبيعات دخل المنتجات",
+  "Inventory Asset": "المخزون",
+  "Cost of Goods Sold (COGS)": "تكلفة البضائع المباعة (COGS)",
+  "Cost of Goods Sold": "تكلفة البضاعة المباعة",
+  "Accounts Payable": "الذمم الدائنة",
+  "Other Expense": "مصاريف أخرى",
+  "Payroll Expenses": "مصاريف المرتبات",
+  "Fixed Asset": "أصول ثابتة",
+  "Credit Card": "بطاقة إئتمان",
+  "Non-Current Asset": "أصول غير متداولة",
+  "Current Asset": "أصول متداولة",
+  "Other Asset": "أصول اخري",
+  "Long Term Liability": "التزامات طويلة الاجل",
+  "Current Liability": "التزامات قصيرة الاجل",
+  "Other Liability": "التزمات اخري",
+  "Equity": "حقوق الملكية",
+  "Expense": "مصروف",
+  "Income": "إيراد",
+  "Accounts Receivable (A/R)": "الذمم المدينة",
+  "Accounts Receivable": "الذمم المدينة",
+  "Accounts Payable (A/P)": "الذمم الدائنة",
+  "Inactive": "غير نشط",
+  "Other Current Asset": "أصول متداولة اخرى",
+  "Tax Payable": "الضريبة المستحقة",
+  "Other Current Liability": "التزامات قصيرة الأجر اخرى",
+  "Non-Current Liability": "التزامات طويلة الأجر",
+  "Assets": "أصول",
+  "Liabilities": "الالتزمات",
+  "Account name": "أسم الحساب",
+  "Account type": "نوع الحساب",
+  "Account normal": "حساب عادي",
+  "Description": "وصف",
+  "Account code": "رمز الحساب",
+  "Currency": "عملة",
+  "Balance": "توازن",
+  "Active": "نشيط",
+  "Created at": "أنشئت في",
+  "fixed_asset": "أصل ثابت",
+  "Journal": "قيد",
+  "Reconciliation": "تسوية",
+  "Credit": "دائن",
+  "Debit": "مدين",
+  "Interest": "فائدة",
+  "Depreciation": "اهلاك",
+  "Payroll": "كشف رواتب",
+  "Type": "نوع",
+  "Name": "الأسم",
+  "Sellable": "قابل للبيع",
+  "Purchasable": "قابل للشراء",
+  "Sell price": "سعر البيع",
+  "Cost price": "سعر الكلفة",
+  "User": "المستخدم",
+  "Category": "تصنيف",
+  "Note": "ملحوظة",
+  "Quantity on hand": "كمية في اليد",
+  "Purchase description": "وصف الشراء",
+  "Sell description": "وصف البيع",
+  "Sell account": "حساب البيع",
+  "Cost account": "حساب التكلفة",
+  "Inventory account": "حساب المخزون",
+  "Payment date": "تاريخ الدفع",
+  "Payment account": "حساب الدفع",
+  "Amount": "كمية",
+  "Reference No.": "رقم المرجع.",
+  "Published": "نشرت",
+  "Journal number": "رقم القيد",
+  "Status": "حالة",
+  "Journal type": "نوع القيد",
+  "Date": "تاريخ",
+  "Asset": "أصل",
+  "Liability": "التزام",
+  "First-in first-out (FIFO)": "الوارد أولاً يصرف أولاً (FIFO)",
+  "Last-in first-out (LIFO)": "الوارد أخيرًا يصرف أولاً (LIFO)",
+  "Average rate": "المعدل المتوسط",
+  "Total": "الإجمالي",
+  "Transaction type": "نوع المعاملة",
+  "Transaction #": "عملية #",
+  "Running Value": "القيمة الجارية",
+  "Running quantity": "الكمية الجارية",
+  "Profit Margin": "هامش الربح",
+  "Value": "القيمة",
+  "Rate": "السعر",
+  "OPERATING ACTIVITIES": "الأنشطة التشغيلية",
+  "FINANCIAL ACTIVITIES": "الأنشطة التمويلية",
+  "INVESTMENT ACTIVITIES": "الانشطة الاستثمارية",
+  "Net income": "صافي الدخل",
+  "Adjustments net income by operating activities.": "تسويات صافي الدخل من الأنشطة التشغيلية.",
+  "Net cash provided by operating activities": "صافي التدفقات النقدية من أنشطة التشغيل",
+  "Net cash provided by investing activities": "صافي التدفقات النقدية من أنشطة الاستثمار",
+  "Net cash provided by financing activities": "صافي التدفقات النقدية من أنشطة التمويلية",
+  "Cash at beginning of period": "التدفقات النقدية في بداية الفترة",
+  "NET CASH INCREASE FOR PERIOD": "زيادة التدفقات النقدية للفترة",
+  "CASH AT END OF PERIOD": "صافي التدفقات النقدية في نهاية الفترة",
+  "Expenses": "مصاريف",
+  "Services": "خدمات",
+  "Inventory": "المخزون",
+  "Non Inventory": "غير المخزون",
+  "Draft": "مسودة",
+  "Delivered": "تم التوصيل",
+  "Overdue": "متأخر",
+  "Partially paid": "المدفوعة جزئيا",
+  "Paid": "مدفوع",
+  "Opened": "افتتح",
+  "Unpaid": "غير مدفوعة",
+  "Approved": "وافق",
+  "Rejected": "مرفوض",
+  "Invoiced": "مفوترة",
+  "Expired": "منتهي الصلاحية",
+  "Closed": "مغلق",
+  "Manual journal": "قيد اليدوي",
+  "Owner contribution": "زيادة رأس المال",
+  "Transfer to account": "تحويل إلى الحساب",
+  "Transfer from account": "تحويل من الحساب",
+  "Other income": "إيراد اخر",
+  "Other expense": "مصاريف أخرى",
+  "Owner drawing": "سحب رأس المال",
+  "Inventory adjustment": "تسوية المخزون",
+  "Customer opening balance": "الرصيد الافتتاحي للزبون",
+  "Vendor opening balance": "رصيد افتتاحي للمورد",
+  "Payment made": "سند الزبون",
+  "Bill": "فاتورة الشراء",
+  "Payment receive": "استلام الدفع",
+  "Sale receipt": "إيصال البيع",
+  "Sale invoice": "فاتورة البيع",
+  "Quantity": "الكمية",
+  "Bank Account": "حساب البنك",
+  "Saving Bank Account": "حساب التوفير البنكي",
+  "Undeposited Funds": "الأموال غير المودعة",
+  "Computer Equipment": "معدات كمبيوتر",
+  "Office Equipment": "معدات مكتبية",
+  "Uncategorized Income": "الدخل غير مصنف",
+  "Sales of Service Income": "دخل مبيعات الخدمات",
+  "Bank Fees and Charges": "رسوم المصرفية",
+  "Exchange Gain or Loss": "ربح أو خسارة فروقات الصرف",
+  "Rent": "إيجار",
+  "Office expenses": "مصاريف المكتب",
+  "Other Expenses": "مصاريف اخري",
+  "Drawings": "السحوبات",
+  "Owner's Equity": "حقوق الملكية",
+  "Opening Balance Equity": "الارصدة الافتتاحية ",
+  "Retained Earnings": "الأرباح المحتجزة",
+  "Sales Tax Payable": "ضريبة المبيعات المستحقة",
+  "Revenue Received in Advance": "الإيرادات المقبوضة مقدما",
+  "Opening Balance Liabilities": "رصيد الالتزامات الافتتاحي",
+  "Loan": "اقراض",
+  "Owner A Drawings": "مسحوبات المالك",
+  "An account that holds valuation of products or goods that availiable for sale.": "حساب يحمل قيم مخزون البضاعة أو السلع المتاحة للبيع.",
+  "Tracks the gain and losses of the exchange differences.": "يسجل مكاسب وخسائر فروق الصرف.",
+  "Any bank fees levied is recorded into the bank fees and charges account. A bank account maintenance fee, transaction charges, a late payment fee are some examples.": "يتم تسجيل أي رسوم مصرفية يتم فرضها في حساب الرسوم والمصروفات البنكية. ومن الأمثلة على ذلك رسوم صيانة الحساب المصرفي ورسوم المعاملات ورسوم الدفع المتأخر.",
+  "The income activities are not associated to the core business.": "لا ترتبط انشطة الدخل إلى الأعمال الأساسية.",
+  "Cash and cash equivalents": "النقد والنقد المكافئ",
+  "Inventories": "مخزون البضاعة",
+  "Other current assets": "الأصول متداولة الأخرى",
+  "Non-Current Assets": "أصول غير المتداولة",
+  "Current Liabilties": "التزامات متداولة",
+  "Long-Term Liabilities": "التزامات طويلة الاجل",
+  "Non-Current Liabilities": "التزامات غير متداولة",
+  "Liabilities and Equity": "التزامات وحقوق الملكية",
+  "Closing balance": "الرصيد الختامي",
+  "Opening balance": "الرصيد الفتاحي",
+  "Total {{accountName}}": "إجمالي {{accountName}}",
+
+  "invoice.paper.invoice": "فاتورة",
+  "invoice.paper.due_amount": "القيمة المستحقة",
+  "invoice.paper.billed_to": "فاتورة إلي",
+  "invoice.paper.invoice_date": "تاريخ الفاتورة",
+  "invoice.paper.invoice_number": "رقم الفاتورة",
+  "invoice.paper.due_date": "تاريخ الاستحقاق",
+  "invoice.paper.conditions_title": "الشروط والأحكام",
+  "invoice.paper.notes_title": "ملاحظات",
+  "invoice.paper.total": "المجموع",
+  "invoice.paper.balance_due": "مبلغ المستحق",
+  "invoice.paper.payment_amount": "مبلغ المدفوع",
+  "invoice.paper.invoice_amount": "قيمة الفاتورة",
+
+  "item_entry.paper.item_name": "اسم الصنف",
+  "item_entry.paper.rate": "السعر",
+  "item_entry.paper.quantity": "الكمية",
+  "item_entry.paper.total": "إجمالي",
+
+  "estimate.paper.estimate": "عرض أسعار",
+  "estimate.paper.billed_to": "عرض أسعار إلي",
+  "estimate.paper.estimate_date": "تاريخ العرض",
+  "estimate.paper.estimate_number": "رقم العرض",
+  "estimate.paper.expiration_date": "تاريخ انتهاء الصلاحية",
+  "estimate.paper.conditions_title": "الشروط والأحكام",
+  "estimate.paper.notes_title": "ملاحظات",
+  "estimate.paper.amount": "قيمة العرض",
+  "estimate.paper.subtotal": "المجموع",
+  "estimate.paper.total": "إجمالي",
+  "estimate.paper.estimate_amount": "قيمة العرض",
+
+  "receipt.paper.receipt": "إيصال",
+  "receipt.paper.billed_to": "الإيصال إلي",
+  "receipt.paper.receipt_date": "تاريخ الإيصال",
+  "receipt.paper.receipt_number": "رقم الإيصال",
+  "receipt.paper.conditions_title": "الشروط والأحكام",
+  "receipt.paper.notes_title": "ملاحظات",
+  "receipt.paper.receipt_amount": "قيمة الإيصال",
+  "receipt.paper.total": "إجمالي",
+  "receipt.paper.payment_amount": "مبلغ المدفوع",
+  "receipt.paper.balance_due": "مبلغ المستحق",
+  "receipt.paper.statement": "البيان",
+  "receipt.paper.notes": "ملاحظات",
+
+  "payment.paper.payment_receipt": "إيصال قبض",
+  "payment.paper.amount_received": "القيمة المستلمه",
+  "payment.paper.billed_to": "إيصال إلي",
+  "payment.paper.payment_date": "تاريخ الدفع",
+  "payment.paper.invoice_number": "رقم الفاتورة",
+  "payment.paper.invoice_date": "تاريخ الفاتورة",
+  "payment.paper.invoice_amount": "قيمة الفاتورة",
+  "payment.paper.payment_amount": "قيمة الدفع",
+  "payment.paper.balance_due": "المبلغ المستحق",
+  "payment.paper.statement": "البيان",
+
+  "credit.paper.credit_note": "اشعار دائن",
+  "credit.paper.amount": "قيمة الاشعار",
+  "credit.paper.remaining": "رصيد المتبقي",
+  "credit.paper.billed_to": "إيصال إلي",
+  "credit.paper.credit_date": "تاريخ الاشعار",
+  "credit.paper.terms_conditions": "الشروط والاحكام",
+  "credit.paper.notes": "ملاحظات",
+  "credit.paper.total": "إجمالي",
+  "credit.paper.credits_used": "قيمة المستخدمه",
+  "credit.paper.credits_remaining": "قيمة المتبقية",
+
+  "account.field.name": "إسم الحساب",
+  "account.field.description": "الوصف",
+  "account.field.slug": "Account slug",
+  "account.field.code": "رقم الحساب",
+  "account.field.root_type": "جذر الحساب",
+  "account.field.normal": "طبيعة الحساب",
+  "account.field.normal.credit": "دائن",
+  "account.field.normal.debit": "مدين",
+  "account.field.type": "نوع الحساب",
+  "account.field.active": "Activity",
+  "account.field.balance": "الرصيد",
+  "account.field.created_at": "أنشئت في",
+  "item.field.type": "نوع الصنف",
+  "item.field.type.inventory": "مخزون",
+  "item.field.type.service": "خدمة",
+  "item.field.type.non-inventory": "غير مخزون",
+  "item.field.name": "اسم الصنف",
+  "item.field.code": "رمز الصنف",
+  "item.field.sellable": "قابل للبيع",
+  "item.field.purchasable": "قابل للشراء",
+  "item.field.cost_price": "سعر التكلفة",
+  "item.field.cost_account": "حساب التكلفة",
+  "item.field.sell_account": "حساب البيع",
+  "item.field.sell_description": "وصف البيع",
+  "item.field.inventory_account": "حساب المخزون",
+  "item.field.purchase_description": "وصف الشراء",
+  "item.field.quantity_on_hand": "الكمية",
+  "item.field.note": "ملاحظة",
+  "item.field.category": "التصنيف",
+  "item.field.active": "Active",
+  "item.field.created_at": "أنشئت في",
+  "item_category.field.name": "الاسم",
+  "item_category.field.description": "الوصف",
+  "item_category.field.count": "العدد",
+  "item_category.field.created_at": "أنشئت في",
+  "invoice.field.customer": "الزبون",
+  "invoice.field.invoice_date": "تاريخ الفاتورة",
+  "invoice.field.due_date": "تاريخ الاستحقاق",
+  "invoice.field.invoice_no": "رقم الفاتورة",
+  "invoice.field.reference_no": "رقم الإشاري",
+  "invoice.field.invoice_message": "رسالة الفاتورة",
+  "invoice.field.terms_conditions": "الشروط والأحكام",
+  "invoice.field.amount": "القيمة",
+  "invoice.field.payment_amount": "القيمة المدفوعة",
+  "invoice.field.due_amount": "القيمة المستحقة",
+  "invoice.field.status": "الحالة",
+  "invoice.field.status.paid": "مدفوعة",
+  "invoice.field.status.partially-paid": "المدفوعة جزئيا",
+  "invoice.field.status.overdue": "متأخرة",
+  "invoice.field.status.unpaid": "غير مدفوعة",
+  "invoice.field.status.delivered": "تم تسليمها",
+  "invoice.field.status.draft": "مسودة",
+  "invoice.field.created_at": "أنشئت في",
+  "estimate.field.amount": "القيمة",
+  "estimate.field.estimate_number": "رقم العرض",
+  "estimate.field.customer": "الزبون",
+  "estimate.field.estimate_date": "تاريخ العرض",
+  "estimate.field.expiration_date": "تاريخ انتهاء الصلاحية",
+  "estimate.field.reference_no": "رقم الإشاري",
+  "estimate.field.note": "ملاحظة",
+  "estimate.field.terms_conditions": "الشروط والأحكام",
+  "estimate.field.status": "الحالة",
+  "estimate.field.status.delivered": "تم تسليمها",
+  "estimate.field.status.rejected": "مرفوضة",
+  "estimate.field.status.approved": "تم الموافقة",
+  "estimate.field.status.draft": "مسودة",
+  "estimate.field.created_at": "أنشئت في",
+  "payment_receive.field.customer": "الزبون",
+  "payment_receive.field.payment_date": "تاريخ الدفع",
+  "payment_receive.field.amount": "القيمة",
+  "payment_receive.field.reference_no": "رقم الإشاري",
+  "payment_receive.field.deposit_account": "حساب الإيداع",
+  "payment_receive.field.payment_receive_no": "رقم عملية الدفع",
+  "payment_receive.field.statement": "البيان",
+  "payment_receive.field.created_at": "أنشئت في",
+  "bill_payment.field.vendor": "المورد",
+  "bill_payment.field.amount": "القيمة",
+  "bill_payment.field.due_amount": "قيمة المستحقة",
+  "bill_payment.field.payment_account": "حساب الدفع",
+  "bill_payment.field.payment_number": "قيمة الدفع",
+  "bill_payment.field.payment_date": "تاريخ الدفع",
+  "bill_payment.field.reference_no": "رقم الإشاري",
+  "bill_payment.field.description": "الوصف",
+  "bill_payment.field.created_at": "أنشئت في",
+  "bill.field.vendor": "المورد",
+  "bill.field.bill_number": "رقم الفاتورة",
+  "bill.field.bill_date": "تاريخ الفاتورة",
+  "bill.field.due_date": "تاريخ الاستحقاق",
+  "bill.field.reference_no": "رقم الإشاري",
+  "bill.field.status": "الحالة",
+  "bill.field.status.paid": "مدفوعة",
+  "bill.field.status.partially-paid": "مدفوعة جزئيا",
+  "bill.field.status.unpaid": "غير مدفوعة",
+  "bill.field.status.opened": "مفتوحة",
+  "bill.field.status.draft": "مسودة",
+  "bill.field.status.overdue": "متأخرة",
+  "bill.field.amount": "القيمة",
+  "bill.field.payment_amount": "قيم الدفع",
+  "bill.field.note": "ملاحظة",
+  "bill.field.created_at": "أنشئت في",
+  "inventory_adjustment.field.date": "التاريخ",
+  "inventory_adjustment.field.type": "النوع",
+  "inventory_adjustment.field.type.increment": "زيادة",
+  "inventory_adjustment.field.type.decrement": "نقصان",
+  "inventory_adjustment.field.adjustment_account": "حساب التسوية",
+  "inventory_adjustment.field.reason": "السبب",
+  "inventory_adjustment.field.reference_no": "رقم الإشاري",
+  "inventory_adjustment.field.description": "الوصف",
+  "inventory_adjustment.field.published_at": "نشرت في",
+  "inventory_adjustment.field.created_at": "أنشئت في",
+  "expense.field.payment_date": "تاريخ الدفع",
+  "expense.field.payment_account": "حساب الدفع",
+  "expense.field.amount": "القيمة",
+  "expense.field.reference_no": "رقم الإشاري",
+  "expense.field.description": "الوصف",
+  "expense.field.published": "Published",
+  "expense.field.status": "الحالة",
+  "expense.field.status.draft": "مسودة",
+  "expense.field.status.published": "نشرت",
+  "expense.field.created_at": "أنشئت في",
+  "manual_journal.field.date": "التاريخ",
+  "manual_journal.field.journal_number": "رقم القيد",
+  "manual_journal.field.reference": "رقم الإشاري",
+  "manual_journal.field.journal_type": "نوع القيد",
+  "manual_journal.field.amount": "القيمة",
+  "manual_journal.field.description": "الوصف",
+  "manual_journal.field.status": "الحالة",
+  "manual_journal.field.created_at": "أنشئت في",
+  "receipt.field.amount": "القيمة",
+  "receipt.field.deposit_account": "حساب الإيداع",
+  "receipt.field.customer": "الزبون",
+  "receipt.field.receipt_date": "تاريخ الإيصال",
+  "receipt.field.receipt_number": "رقم الإيصال",
+  "receipt.field.reference_no": "رقم الإشاري",
+  "receipt.field.receipt_message": "رسالة الإيصال",
+  "receipt.field.statement": "البيان",
+  "receipt.field.created_at": "أنشئت في",
+  "receipt.field.status": "الحالة",
+  "receipt.field.status.draft": "مسودة",
+  "receipt.field.status.closed": "مغلقة",
+  "customer.field.first_name": "الاسم الأول",
+  "customer.field.last_name": "الاسم الاخير",
+  "customer.field.display_name": "اسم العرض",
+  "customer.field.email": "بريد الالكتروني",
+  "customer.field.work_phone": "هاتف عمل",
+  "customer.field.personal_phone": "هاتف شخصي",
+  "customer.field.company_name": "اسم الشركة",
+  "customer.field.website": "موقع الكتروني",
+  "customer.field.opening_balance_at": "الرصيد الافتتاحي في",
+  "customer.field.opening_balance": "الرصيد الافتتاحي",
+  "customer.field.created_at": "أنشئت في",
+  "customer.field.balance": "الرصيد",
+  "customer.field.status": "الحالة",
+  "customer.field.currency": "العملة",
+  "customer.field.status.active": "مفعل",
+  "customer.field.status.inactive": "غير مفعل",
+  "customer.field.status.overdue": "متأخر",
+  "customer.field.status.unpaid": "غير دافع",
+  "vendor.field.first_name": "الاسم الأول",
+  "vendor.field.last_name": "الاسم الاخير",
+  "vendor.field.display_name": "اسم العرض",
+  "vendor.field.email": "بريد الالكتروني",
+  "vendor.field.work_phone": "هاتف عمل",
+  "vendor.field.personal_phone": "هاتف شخصي",
+  "vendor.field.company_name": "اسم الشركة",
+  "vendor.field.website": "موقع الكتروني",
+  "vendor.field.opening_balance_at": "الرصيد الافتتاحي في",
+  "vendor.field.opening_balance": "الرصيد الافتتاحي",
+  "vendor.field.created_at": "أنشئت في",
+  "vendor.field.balance": "الرصيد",
+  "vendor.field.status": "الحالة",
+  "vendor.field.currency": "العملة",
+  "vendor.field.status.active": "مفعل",
+  "vendor.field.status.inactive": "غير مفعل",
+  "vendor.field.status.overdue": "متأخر",
+  "vendor.field.status.unpaid": "غير دافع",
+  "Invoice write-off": "شطب فاتورة",
+  "transaction_type.credit_note": "اشعار دائن",
+  "transaction_type.refund_credit_note": "استرجاع اموال اشعار دائن",
+  "transaction_type.vendor_credit": "اشعار مدين",
+  "transaction_type.refund_vendor_credit": "استرجاع اموال اشعار مدين",
+  "transaction_type.landed_cost": "تحميل تكلفة",
+
+  "sms_notification.invoice_details.label": "تفاصيل فاتورة البيع ",
+  "sms_notification.invoice_reminder.label": "تذكير بفاتورة البيع ",
+  "sms_notification.receipt_details.label": "تفاصيل إيصال البيع ",
+  "sms_notification.sale_estimate_details.label": "تفاصيل فاتورة عرض اسعار ",
+  "sms_notification.payment_receive_details.label": "تفاصيل سند الزبون",
+  "sms_notification.customer_balance.label": "رصيد الزبون",
+
+  "sms_notification.invoice_details.description": "سيتم إرسال إشعار عبر الرسائل القصيرة إلى العميل بمجرد إنشاء الفاتورة ونشرها أو عند إشعار العميل عبر رسالة نصية قصيرة بالفاتورة. ",
+  "sms_notification.payment_receive.description": "سيتم إرسال إشعار رسالة شكر للدفع إلى العميل بمجرد إنشاء الدفعة ونشرها أو إشعار العميل بالدفع يدويًا. ",
+  "sms_notification.receipt_details.description": "سيتم إرسال إشعار عبر الرسائل القصيرة إلى العميل بمجرد إنشاء ونشر الإيصال أو عند إشعار العميل بالإيصال يدويًا.",
+  "sms_notification.customer_balance.description": "إرسال رسالة نصية قصيرة إشعار العملاء برصيدهم الحالي المستحق. ",
+  "sms_notification.estimate_details.description": "سيتم إرسال إشعار عبر الرسائل القصيرة إلى عميلك بمجرد نشر العرض أو إشعار العميل بالعرض يدويًا.",
+  "sms_notification.invoice_reminder.description": "سيتم ارسال إشعار SMS لتذكير الزبون بالدفع باكراً ، سواء ارسال بشكل تلقائي او يدوي.",
+
+  "sms_notification.customer_balance.default_message": "عزيزي {CustomerName} ، هذا تذكير بشأن رصيد الحالي المستحق {Balance} ، يُرجى الدفع في أقرب وقت ممكن. - {CompanyName}",
+  "sms_notification.payment_receive.default_message": "مرحبًا {CustomerName} ، تم القبض بقيمة {Amount} للفاتورة - {InvoiceNumber}. نحن نتطلع إلى خدمتك مرة أخرى. شكرا لك. - {CompanyName}",
+  "sms_notification.estimate.default_message": "مرحبًا , {CustomerName} ، تم أنشاء فاتورة عرض اسعار - {EstimateNumber} لك. يرجى إلقاء نظرة وقبوله للمضي قدما. بانتظار ردك. - {CompanyName}",
+
+  "sms_notification.invoice_details.default_message": "مرحبًا {CustomerName},  لديك مبلغ مستحق قدره {DueAmount}  للفاتورة {InvoiceNumber}. - {CompanyName}",
+  "sms_notification.receipt_details.default_message": "مرحبًا {CustomerName} ، لقد تم إنشاء إيصال - {ReceiptNumber} من أجلك. نتطلع إلى خدمتك مرة أخرى. شكرًا لك - {CompanyName}",
+  "sms_notification.invoice_reminder.default_message": "عزيزي {CustomerName} ، يرجي سداد فاتورة - {InvoiceNumber} المستحقة. يرجى الدفع قبل تاريخ {DueDate}. شكرا لك. - {CompanyName}",
+
+  "module.sale_invoices.label": "فواتير البيع",
+  "module.sale_receipts.label": "إيصالات البيع",
+  "module.sale_estimates.label": "فاتورة عرض اسعار ",
+  "module.payment_receives.label": "سندات الزبائن ",
+  "module.customers.label": "العملاء",
+
+  "sms_notification.invoice.var.invoice_number": "يشير  إلى رقم الفاتورة.",
+  "sms_notification.invoice.var.reference_number": "يشير  إلى رقم إشاري للفاتورة.",
+  "sms_notification.invoice.var.customer_name": "يشير  إلى اسم العميل الفاتورة",
+  "sms_notification.invoice.var.due_amount": "يشير  إلى مبلغ الفاتورة المستحق",
+  "sms_notification.invoice.var.amount": "يشير  إلى مبلغ الفاتورة.",
+  "sms_notification.invoice.var.company_name": "يشير إلي اسم الشركة.",
+  "sms_notification.invoice.var.due_date": "يشير إلي تاريخ استحقاق الفاتورة.",
+
+  "sms_notification.receipt.var.receipt_number": "يشير  إلى رقم الإيصال.",
+  "sms_notification.receipt.var.reference_number": "يشير  إلى رقم الإشاري للإيصال.",
+  "sms_notification.receipt.var.customer_name": "يشير  إلى اسم العميل الإيصال.",
+  "sms_notification.receipt.var.amount": "يشير  إلى مبلغ الإيصال. ",
+  "sms_notification.receipt.var.company_name": "يشير إلي اسم الشركة.",
+
+  "sms_notification.payment.var.payment_number": "يشير  إلى رقم معاملة الدفع.",
+  "sms_notification.payment.var.reference_number": "يشير  إلى رقم الإشاري لعملية الدفع ",
+  "sms_notification.payment.var.customer_name": "يشير  إلى اسم العميل الدفع",
+  "sms_notification.payment.var.amount": "يشير  إلى مبلغ معاملة الدفع.",
+  "sms_notification.payment.company_name": "يشير إلي اسم الشركة.",
+  "sms_notification.payment.var.invoice_number": "يشير إلي رقم فاتورة التي تم دفعها.",
+
+  "sms_notification.estimate.var.estimate_number": "يشير  إلى رقم فاتورة عرض اسعار.",
+  "sms_notification.estimate.var.reference_number": "يشير  إلى رقم الإشاري لفاتورة عرض اسعار.",
+  "sms_notification.estimate.var.customer_name": "يشير  إلى اسم العميل الفاتورة",
+  "sms_notification.estimate.var.amount": "يشير  إلى قيمة الفاتورة",
+  "sms_notification.estimate.var.company_name": "يشير إلي اسم الشركة.",
+  "sms_notification.estimate.var.expiration_date": "يشير إلي تاريخ الصلاحية الفاتورة.",
+  "sms_notification.estimate.var.estimate_date": "يشير إلي تاريخ الفاتورة.",
+
+  "sms_notification.customer.var.customer_name": "يشير إلي اسم الزبون",
+  "sms_notification.customer.var.balance": "يشير إلي رصيد زبون المستحق.",
+  "sms_notification.customer.var.company_name": "يشير إلي اسم الشركة.",
+
+  "ability.accounts": "شجرة الحسابات",
+  "ability.manual_journal": "القيود اليدوية",
+  "ability.cashflow": "التدفقات النقدية",
+  "ability.inventory_adjustment": "تسويات المخزون",
+  "ability.customers": "الزبائن",
+  "ability.vendors": "الموردين",
+  "ability.sale_estimates": "فواتير عرض الاسعار",
+  "ability.sale_invoices": "فواتير البيع",
+  "ability.sale_receipts": "إيصالات البيع",
+  "ability.expenses": "المصاريف",
+  "ability.payments_receive": "سندات الزبائن",
+  "ability.purchase_invoices": "فواتير الشراء",
+  "ability.all_reports": "كل التقارير",
+  "ability.payments_made": "سندات الموردين",
+  "ability.preferences": "التفضيلات",
+  "ability.mutate_system_preferences": "تعديل تفضيلات النظام.",
+
+  "ability.items": "الأصناف",
+  "ability.view": "عرض",
+  "ability.create": "إضافة",
+  "ability.edit": "تعديل",
+  "ability.delete": "حذف",
+  "ability.transactions_locking": "إمكانية اغلاق المعاملات.",
+
+  "ability.balance_sheet_report": "ميزانية العمومية",
+  "ability.profit_loss_sheet": "قائمة الدخل",
+  "ability.journal": "اليومية العامة",
+  "ability.general_ledger": "دفتر الأستاذ العام",
+  "ability.cashflow_report": "تقرير التدفقات النقدية",
+  "ability.AR_aging_summary_report": "ملخص اعمار الديون للذمم المدينة",
+  "ability.AP_aging_summary_report": "ملخص اعمار الديون للذمم الدائنة",
+  "ability.purchases_by_items": "المشتريات حسب المنتجات",
+  "ability.sales_by_items_report": "المبيعات حسب المنتجات",
+  "ability.customers_transactions_report": "معاملات الزبائن",
+  "ability.vendors_transactions_report": "معاملات الموردين",
+  "ability.customers_summary_balance_report": "ملخص أرصدة الزبائن",
+  "ability.vendors_summary_balance_report": "ملخص أرصدة الموردين",
+  "ability.inventory_valuation_summary": "ملخص تقييم المخزون",
+  "ability.inventory_items_details": "تفاصيل منتج المخزون",
+
+  "vendor_credit.field.vendor": "المورد",
+  "vendor_credit.field.amount": "القيمة",
+  "vendor_credit.field.currency_code": "العملة",
+  "vendor_credit.field.credit_date": "تاريخ الاشعار",
+  "vendor_credit.field.credit_number": "رقم الاشعار",
+  "vendor_credit.field.note": "ملاحظة",
+  "vendor_credit.field.created_at": "أنشئت في",
+  "vendor_credit.field.reference_no": "رقم الإشاري",
+
+  "vendor_credit.field.status": "الحالة",
+  "vendor_credit.field.status.draft": "مسودة",
+  "vendor_credit.field.status.published": "تم نشرها",
+  "vendor_credit.field.status.open": "مفتوحة",
+  "vendor_credit.field.status.closed": "مغلقة",
+
+  "credit_note.field.terms_conditions": "الشروط والاحكام",
+  "credit_note.field.note": "ملاحظة",
+  "credit_note.field.currency_code": "العملة",
+  "credit_note.field.created_at": "أنشئت في",
+  "credit_note.field.amount": "القيمة",
+  "credit_note.field.credit_note_number": "رقم الاشعار",
+  "credit_note.field.credit_note_date": "تاريخ الاشعار",
+  "credit_note.field.customer": "الزبون",
+  "credit_note.field.reference_no": "رقم الإشاري",
+
+  "credit_note.field.status": "الحالة",
+  "credit_note.field.status.draft": "مسودة",
+  "credit_note.field.status.published": "تم نشرها",
+  "credit_note.field.status.open": "مفتوحة",
+  "credit_note.field.status.closed": "مغلقة",
+
+  "transactions_locking.module.sales.label": "المبيعات",
+  "transactions_locking.module.purchases.label": "المشتريات",
+  "transactions_locking.module.financial.label": "المالية",
+  "transactions_locking.module.all_transactions": "كل المعاملات",
+
+  "transactions_locking.module.sales.desc": "فواتير البيع ، والإيصالات ، والإشعارات الدائنة ، واستلام مدفوعات الزبائن ، والأرصدة الافتتاحية للزبائن.",
+  "transactions_locking.module.purchases.desc": "فواتير الشراء ومدفوعات الموردين وإشعارات المدينة والأرصدة الافتتاحية للموردين.",
+  "transactions_locking.module.financial.desc": "القيود اليدوية والمصروفات وتسويات المخزون.",
+
+  "inventory_adjustment.type.increment": "زيادة",
+  "inventory_adjustment.type.decrement": "نقصان",
+
+  "customer.type.individual": "فرد",
+  "customer.type.business": "اعمال",
+
+  "credit_note.view.draft": "مسودة",
+  "credit_note.view.closed": "مغلقة",
+  "credit_note.view.open": "مفتوحة",
+  "credit_note.view.published": "نشرت",
+
+  "vendor_credit.view.draft": "مسودة",
+  "vendor_credit.view.closed": "مغلقة",
+  "vendor_credit.view.open": "مفتوحة",
+  "vendor_credit.view.published": "نشرت",
+
+  "allocation_method.value.label": "القيمة",
+  "allocation_method.quantity.label": "الكمية",
+
+  "balance_sheet.assets": "الأصول",
+  "balance_sheet.current_asset": "الأصول المتداولة",
+  "balance_sheet.cash_and_cash_equivalents": "النقدية وما يعادلها",
+  "balance_sheet.accounts_receivable": "الذمم المدينة",
+  "balance_sheet.inventory": "المخزون",
+  "balance_sheet.other_current_assets": "اصول متداولة اخرى",
+  "balance_sheet.fixed_asset": "الأصول الثابتة",
+  "balance_sheet.non_current_assets": "الاصول غير المتداولة",
+  "balance_sheet.liabilities_and_equity": "الالتزامات وحقوق الملكية",
+  "balance_sheet.liabilities": "الإلتزامات",
+  "balance_sheet.current_liabilties": "الالتزامات المتداولة",
+  "balance_sheet.long_term_liabilities": "الالتزامات طويلة الاجل",
+  "balance_sheet.non_current_liabilities": "الالتزامات غير المتداولة",
+  "balance_sheet.equity": "حقوق الملكية",
+
+  "balance_sheet.account_name": "اسم الحساب",
+  "balance_sheet.total": "إجمالي",
+  "balance_sheet.percentage_of_column": "٪ التغير العمودي",
+  "balance_sheet.percentage_of_row": "٪ التغير الأفقي",
+
+  "financial_sheet.previoud_period_date": "(ف.س) {{date}}",
+  "fianncial_sheet.previous_period_change": "التغيرات (ف.س)",
+  "financial_sheet.previous_period_percentage": "٪ التغير (ف.س)",
+
+  "financial_sheet.previous_year_date": "(س.س) {{date}}",
+  "financial_sheet.previous_year_change": "التغيرات (س.س)",
+  "financial_sheet.previous_year_percentage": "٪ التغير (س.س)",
+  "financial_sheet.total_row": "إجمالي {{value}}",
+
+  "profit_loss_sheet.income": "الإيرادات",
+  "profit_loss_sheet.cost_of_sales": "تكلفة المبيعات",
+  "profit_loss_sheet.gross_profit": "إجمالي الدخل",
+  "profit_loss_sheet.expenses": "المصروفات",
+  "profit_loss_sheet.net_operating_income": "صافي الدخل التشغيلي",
+  "profit_loss_sheet.other_income": "إيرادات اخري",
+  "profit_loss_sheet.other_expenses": "مصاريف اخري",
+  "profit_loss_sheet.net_income": "صافي الدخل",
+
+  "profit_loss_sheet.account_name": "اسم الحساب",
+  "profit_loss_sheet.total": "إجمالي",
+
+  "profit_loss_sheet.percentage_of_income": "٪ التغير في الإيرادات",
+  "profit_loss_sheet.percentage_of_expenses": "٪ التغير في المصاريف",
+  "profit_loss_sheet.percentage_of_column": "٪ التغير العمودي",
+  "profit_loss_sheet.percentage_of_row": "٪ التغير الأفقي",
+
+  "warehouses.primary_warehouse": "المستودع الرئيسي",
+  "branches.head_branch": "الفرع الرئيسي",
+
+  "account.accounts_payable.currency": "الذمم الدائنة - {{currency}}",
+  "account.accounts_receivable.currency": "الذمم المدينة - {{currency}}",
+
+  "role.admin.name": "الادارة",
+  "role.admin.desc": "وصول غير مقيد لجميع الوحدات.",
+
+  "role.staff.name": "العاملين",
+  "role.staff.desc": "الوصول إلى جميع الوحدات باستثناء التقارير والإعدادات والمحاسبة.",
+
+  "warehouse_transfer.view.draft.name": "مسودة",
+  "warehouse_transfer.view.in_transit.name": "في النقل",
+  "warehouse_transfer.view.transferred.name": "تم النقل"
+}
\ No newline at end of file
diff --git a/packages/server/src/locales/en.json b/packages/server/src/locales/en.json
new file mode 100644
index 000000000..811db19e7
--- /dev/null
+++ b/packages/server/src/locales/en.json
@@ -0,0 +1,641 @@
+{
+  "Petty Cash": "Petty Cash",
+  "Cash": "Cash",
+  "Bank": "Bank",
+  "Other Income": "Other Income",
+  "Interest Income": "Interest Income",
+  "Depreciation Expense": "Depreciation Expense",
+  "Interest Expense": "Interest Expense",
+  "Sales of Product Income": "Sales of Product Income",
+  "Inventory Asset": "Inventory Asset",
+  "Cost of Goods Sold (COGS)": "Cost of Goods Sold (COGS)",
+  "Cost of Goods Sold": "Cost of Goods Sold",
+  "Accounts Payable": "Accounts Payable",
+  "Other Expense": "Other Expense",
+  "Payroll Expenses": "Payroll Expenses",
+  "Fixed Asset": "Fixed Asset",
+  "Credit Card": "Credit Card",
+  "Non-Current Asset": "Non-Current Asset",
+  "Current Asset": "Current Asset",
+  "Other Asset": "Other Asset",
+  "Long Term Liability": "Long Term Liability",
+  "Current Liability": "Current Liability",
+  "Other Liability": "Other Liability",
+  "Equity": "Equity",
+  "Expense": "Expense",
+  "Income": "Income",
+  "Accounts Receivable (A/R)": "Accounts Receivable (A/R)",
+  "Accounts Receivable": "Accounts Receivable",
+  "Accounts Payable (A/P)": "Accounts Payable (A/P)",
+  "Inactive": "Inactive",
+  "Other Current Asset": "Other Current Asset",
+  "Tax Payable": "Tax Payable",
+  "Other Current Liability": "Other Current Liability",
+  "Non-Current Liability": "Non-Current Liability",
+  "Assets": "Assets",
+  "Liabilities": "Liabilities",
+  "Account name": "Account name",
+  "Account type": "Account type",
+  "Account normal": "Account normal",
+  "Description": "Description",
+  "Account code": "Account code",
+  "Currency": "Currency",
+  "Balance": "Balance",
+  "Active": "Active",
+  "Created at": "Created at",
+  "fixed_asset": "Fixed asset",
+  "Journal": "Journal",
+  "Reconciliation": "Reconciliation",
+  "Credit": "Credit",
+  "Debit": "Debit",
+  "Interest": "Interest",
+  "Depreciation": "Depreciation",
+  "Payroll": "Payroll",
+  "Type": "Type",
+  "Name": "Name",
+  "Sellable": "Sellable",
+  "Purchasable": "Purchasable",
+  "Sell price": "Sell price",
+  "Cost price": "Cost price",
+  "User": "User",
+  "Category": "Category",
+  "Note": "Note",
+  "Quantity on hand": "Quantity on hand",
+  "Quantity": "Quantity",
+  "Purchase description": "Purchase description",
+  "Sell description": "Sell description",
+  "Sell account": "Sell account",
+  "Cost account": "Cost account",
+  "Inventory account": "Inventory account",
+  "Payment date": "Payment date",
+  "Payment account": "Payment account",
+  "Amount": "Amount",
+  "Reference No.": "Reference No.",
+  "Journal number": "Journal number",
+  "Status": "Status",
+  "Journal type": "Journal type",
+  "Date": "Date",
+  "Asset": "Asset",
+  "Liability": "Liability",
+  "First-in first-out (FIFO)": "First-in first-out (FIFO)",
+  "Last-in first-out (LIFO)": "Last-in first-out (LIFO)",
+  "Average rate": "Average rate",
+  "Total": "Total",
+  "Transaction type": "Transaction type",
+  "Transaction #": "Transaction #",
+  "Running Value": "Running Value",
+  "Running quantity": "Running quantity",
+  "Profit Margin": "Profit Margin",
+  "Value": "Value",
+  "Rate": "Rate",
+  "OPERATING ACTIVITIES": "OPERATING ACTIVITIES",
+  "FINANCIAL ACTIVITIES": "FINANCIAL ACTIVITIES",
+  "Net income": "Net income",
+  "Adjustments net income by operating activities.": "Adjustments net income by operating activities.",
+  "Net cash provided by operating activities": "Net cash provided by operating activities",
+  "Net cash provided by investing activities": "Net cash provided by investing activities",
+  "Net cash provided by financing activities": "Net cash provided by financing activities",
+  "Cash at beginning of period": "Cash at beginning of period",
+  "NET CASH INCREASE FOR PERIOD": "NET CASH INCREASE FOR PERIOD",
+  "CASH AT END OF PERIOD": "CASH AT END OF PERIOD",
+  "Expenses": "Expenses",
+  "Services": "Services",
+  "Inventory": "Inventory",
+  "Non Inventory": "Non Inventory",
+  "Draft": "Draft",
+  "Published": "Published",
+  "Delivered": "Delivered",
+  "Overdue": "Overdue",
+  "Partially paid": "Partially paid",
+  "Paid": "Paid",
+  "Opened": "Opened",
+  "Unpaid": "Unpaid",
+  "Approved": "Approved",
+  "Rejected": "Rejected",
+  "Invoiced": "Invoiced",
+  "Expired": "Expired",
+  "Closed": "Closed",
+  "Manual journal": "Manual journal",
+  "Owner contribution": "Owner contribution",
+  "Transfer to account": "Transfer to account",
+  "Transfer from account": "Transfer from account",
+  "Other income": "Other income",
+  "Other expense": "Other expense",
+  "Owner drawing": "Owner drawing",
+  "Inventory adjustment": "Inventory adjustment",
+  "Customer opening balance": "Customer opening balance",
+  "Vendor opening balance": "Vendor opening balance",
+  "Payment made": "Payment made",
+  "Bill": "Bill",
+  "Payment receive": "Payment receive",
+  "Sale receipt": "Sale receipt",
+  "Sale invoice": "Sale invoice",
+  "Bank Account": "Bank Account",
+  "Saving Bank Account": "Saving Bank Account",
+  "Undeposited Funds": "Undeposited Funds",
+  "Computer Equipment": "Computer Equipment",
+  "Office Equipment": "Office Equipment",
+  "Uncategorized Income": "Uncategorized Income",
+  "Sales of Service Income": "Sales of Service Income",
+  "Bank Fees and Charges": "Bank Fees and Charges",
+  "Exchange Gain or Loss": "Exchange Gain or Loss",
+  "Rent": "Rent",
+  "Office expenses": "Office expenses",
+  "Other Expenses": "Other Expenses",
+  "Drawings": "Drawings",
+  "Owner's Equity": "Owner's Equity",
+  "Opening Balance Equity": "Opening Balance Equity",
+  "Retained Earnings": "Retained Earnings",
+  "Sales Tax Payable": "Sales Tax Payable",
+  "Revenue Received in Advance": "Revenue Received in Advance",
+  "Opening Balance Liabilities": "Opening Balance Liabilities",
+  "Loan": "Loan",
+  "Owner A Drawings": "Owner A Drawings",
+  "An account that holds valuation of products or goods that availiable for sale.": "An account that holds valuation of products or goods that availiable for sale.",
+  "Tracks the gain and losses of the exchange differences.": "Tracks the gain and losses of the exchange differences.",
+  "Any bank fees levied is recorded into the bank fees and charges account. A bank account maintenance fee, transaction charges, a late payment fee are some examples.": "Any bank fees levied is recorded into the bank fees and charges account. A bank account maintenance fee, transaction charges, a late payment fee are some examples.",
+  "The income activities are not associated to the core business.": "The income activities are not associated to the core business.",
+  "Cash and cash equivalents": "Cash and cash equivalents",
+  "Inventories": "Inventories",
+  "Other current assets": "Other current assets",
+  "Non-Current Assets": "Non-Current Assets",
+  "Current Liabilties": "Current Liabilties",
+  "Long-Term Liabilities": "Long-Term Liabilities",
+  "Non-Current Liabilities": "Non-Current Liabilities",
+  "Liabilities and Equity": "Liabilities and Equity",
+  "Closing balance": "Closing balance",
+  "Opening Balance": "Opening balance",
+  "Total {{accountName}}": "Total {{accountName}}",
+  "invoice.paper.invoice": "Invoice",
+  "invoice.paper.invoice_amount": "Invoice amount",
+  "invoice.paper.due_amount": "Due amount",
+  "invoice.paper.billed_to": "Billed to",
+  "invoice.paper.invoice_date": "Invoice date",
+  "invoice.paper.invoice_number": "Invoice No.",
+  "invoice.paper.due_date": "Due date",
+  "invoice.paper.conditions_title": "Conditions & terms",
+  "invoice.paper.notes_title": "Notes",
+  "invoice.paper.total": "Total",
+  "invoice.paper.payment_amount": "Payment Amount",
+  "invoice.paper.balance_due": "Balance Due",
+
+  "item_entry.paper.item_name": "Item name",
+  "item_entry.paper.rate": "Rate",
+  "item_entry.paper.quantity": "Quantity",
+  "item_entry.paper.total": "Total",
+
+  "estimate.paper.estimate": "Estimate",
+  "estimate.paper.estimate_amount": "Estimate amount",
+  "estimate.paper.billed_to": "Billed to",
+  "estimate.paper.estimate_date": "Estimate date",
+  "estimate.paper.estimate_number": "Estimate number",
+  "estimate.paper.expiration_date": "Expiration date",
+  "estimate.paper.conditions_title": "Conditions & terms",
+  "estimate.paper.notes_title": "Notes",
+  "estimate.paper.amount": "Estimate amount",
+  "estimate.paper.subtotal": "Subtotal",
+  "estimate.paper.total": "Total",
+
+  "receipt.paper.receipt": "Receipt",
+  "receipt.paper.billed_to": "Billed to",
+  "receipt.paper.receipt_date": "Receipt date",
+  "receipt.paper.receipt_number": "Receipt number",
+  "receipt.paper.expiration_date": "Expiration date",
+  "receipt.paper.conditions_title": "Conditions & terms",
+  "receipt.paper.notes": "Notes",
+  "receipt.paper.statement": "Statement",
+  "receipt.paper.receipt_amount": "Receipt amount",
+  "receipt.paper.total": "Total",
+  "receipt.paper.balance_due": "Balance Due",
+  "receipt.paper.payment_amount": "Payment Amount",
+
+  "credit.paper.credit_note": "Credit Note",
+  "credit.paper.remaining": "Credit remaining",
+  "credit.paper.amount": "Credit amount",
+  "credit.paper.billed_to": "Bill to",
+  "credit.paper.credit_date": "Credit date",
+  "credit.paper.total": "Total",
+  "credit.paper.credits_used": "Credits used",
+  "credit.paper.credits_remaining": "Credits remaining",
+  "credit.paper.conditions_title": "Conditions & terms",
+  "credit.paper.notes": "Notes",
+
+  "payment.paper.payment_receipt": "Payment Receipt",
+  "payment.paper.amount_received": "Amount received",
+  "payment.paper.billed_to": "Billed to",
+  "payment.paper.payment_date": "Payment date",
+  "payment.paper.invoice_number": "Invoice number",
+  "payment.paper.invoice_date": "Invoice date",
+  "payment.paper.invoice_amount": "Invoice amount",
+  "payment.paper.payment_amount": "Payment amount",
+  "payment.paper.balance_due": "Balance Due",
+  "payment.paper.statement": "Statement",
+
+  "account.field.name": "Account name",
+  "account.field.description": "Description",
+  "account.field.slug": "Account slug",
+  "account.field.code": "Account code",
+  "account.field.root_type": "Root type",
+  "account.field.normal": "Account normal",
+  "account.field.normal.credit": "Credit",
+  "account.field.normal.debit": "Debit",
+  "account.field.type": "Type",
+  "account.field.active": "Activity",
+  "account.field.balance": "Balance",
+  "account.field.created_at": "Created at",
+  "item.field.type": "Item type",
+  "item.field.type.inventory": "Inventory",
+  "item.field.type.service": "Service",
+  "item.field.type.non-inventory": "Non inventory",
+  "item.field.name": "Name",
+  "item.field.code": "Code",
+  "item.field.sellable": "Sellable",
+  "item.field.purchasable": "Purchasable",
+  "item.field.cost_price": "Cost price",
+  "item.field.cost_account": "Cost account",
+  "item.field.sell_account": "Sell account",
+  "item.field.sell_description": "Sell description",
+  "item.field.inventory_account": "Inventory account",
+  "item.field.purchase_description": "Purchase description",
+  "item.field.quantity_on_hand": "Quantity on hand",
+  "item.field.note": "Note",
+  "item.field.category": "Category",
+  "item.field.active": "Active",
+  "item.field.created_at": "Created at",
+  "item_category.field.name": "Name",
+  "item_category.field.description": "Description",
+  "item_category.field.count": "Count",
+  "item_category.field.created_at": "Created at",
+  "invoice.field.customer": "Customer",
+  "invoice.field.invoice_date": "Invoice date",
+  "invoice.field.due_date": "Due date",
+  "invoice.field.invoice_no": "Invoice No.",
+  "invoice.field.reference_no": "Reference No.",
+  "invoice.field.invoice_message": "Invoice message",
+  "invoice.field.terms_conditions": "Terms & conditions",
+  "invoice.field.amount": "Amount",
+  "invoice.field.payment_amount": "Payment amount",
+  "invoice.field.due_amount": "Due amount",
+  "invoice.field.status": "Status",
+  "invoice.field.status.paid": "Paid",
+  "invoice.field.status.partially-paid": "Partially paid",
+  "invoice.field.status.overdue": "Overdue",
+  "invoice.field.status.unpaid": "Unpaid",
+  "invoice.field.status.delivered": "Delivered",
+  "invoice.field.status.draft": "Draft",
+  "invoice.field.created_at": "Created at",
+  "estimate.field.amount": "Amount",
+  "estimate.field.estimate_number": "Estimate number",
+  "estimate.field.customer": "Customer",
+  "estimate.field.estimate_date": "Estimate date",
+  "estimate.field.expiration_date": "Expiration date",
+  "estimate.field.reference_no": "Reference No.",
+  "estimate.field.note": "Note",
+  "estimate.field.terms_conditions": "Terms & conditions",
+  "estimate.field.status": "Status",
+  "estimate.field.status.delivered": "Delivered",
+  "estimate.field.status.rejected": "Rejected",
+  "estimate.field.status.approved": "Approved",
+  "estimate.field.status.draft": "Draft",
+  "estimate.field.created_at": "Created at",
+  "payment_receive.field.customer": "Customer",
+  "payment_receive.field.payment_date": "Payment date",
+  "payment_receive.field.amount": "Amount",
+  "payment_receive.field.reference_no": "Reference No.",
+  "payment_receive.field.deposit_account": "Deposit account",
+  "payment_receive.field.payment_receive_no": "Payment receive No.",
+  "payment_receive.field.statement": "Statement",
+  "payment_receive.field.created_at": "Created at",
+  "bill_payment.field.vendor": "Vendor",
+  "bill_payment.field.amount": "Amount",
+  "bill_payment.field.due_amount": "Due amount",
+  "bill_payment.field.payment_account": "Payment account",
+  "bill_payment.field.payment_number": "Payment number",
+  "bill_payment.field.payment_date": "Payment date",
+  "bill_payment.field.reference_no": "Reference No.",
+  "bill_payment.field.description": "Description",
+  "bill_payment.field.created_at": "Created at",
+  "bill.field.vendor": "Vendor",
+  "bill.field.bill_number": "Bill number",
+  "bill.field.bill_date": "Bill date",
+  "bill.field.due_date": "Due date",
+  "bill.field.reference_no": "Reference No.",
+  "bill.field.status": "Status",
+  "bill.field.status.paid": "Paid",
+  "bill.field.status.partially-paid": "Partially paid",
+  "bill.field.status.unpaid": "Unpaid",
+  "bill.field.status.opened": "Opened",
+  "bill.field.status.draft": "Draft",
+  "bill.field.status.overdue": "overdue",
+  "bill.field.amount": "Amount",
+  "bill.field.payment_amount": "Payment amount",
+  "bill.field.note": "Note",
+  "bill.field.created_at": "Created at",
+  "inventory_adjustment.field.date": "Date",
+  "inventory_adjustment.field.type": "Type",
+  "inventory_adjustment.field.type.increment": "Increment",
+  "inventory_adjustment.field.type.decrement": "Decrement",
+  "inventory_adjustment.field.adjustment_account": "Adjustment account",
+  "inventory_adjustment.field.reason": "Reason",
+  "inventory_adjustment.field.reference_no": "Reference No.",
+  "inventory_adjustment.field.description": "Description",
+  "inventory_adjustment.field.published_at": "Published at",
+  "inventory_adjustment.field.created_at": "Created at",
+  "expense.field.payment_date": "Payment date",
+  "expense.field.payment_account": "Payment account",
+  "expense.field.amount": "Amount",
+  "expense.field.reference_no": "Reference No.",
+  "expense.field.description": "Description",
+  "expense.field.published": "Published",
+  "expense.field.status": "Status",
+  "expense.field.status.draft": "Draft",
+  "expense.field.status.published": "Published",
+  "expense.field.created_at": "Created at",
+  "manual_journal.field.date": "Date",
+  "manual_journal.field.journal_number": "Journal number",
+  "manual_journal.field.reference": "Reference No.",
+  "manual_journal.field.journal_type": "Journal type",
+  "manual_journal.field.amount": "Amount",
+  "manual_journal.field.description": "Description",
+  "manual_journal.field.status": "Status",
+  "manual_journal.field.created_at": "Created at",
+  "receipt.field.amount": "Amount",
+  "receipt.field.deposit_account": "Deposit account",
+  "receipt.field.customer": "Customer",
+  "receipt.field.receipt_date": "Receipt date",
+  "receipt.field.receipt_number": "Receipt number",
+  "receipt.field.reference_no": "Reference No.",
+  "receipt.field.receipt_message": "Receipt message",
+  "receipt.field.statement": "Statement",
+  "receipt.field.created_at": "Created at",
+  "receipt.field.status": "Status",
+  "receipt.field.status.draft": "Draft",
+  "receipt.field.status.closed": "Closed",
+  "customer.field.first_name": "First name",
+  "customer.field.last_name": "Last name",
+  "customer.field.display_name": "Display name",
+  "customer.field.email": "Email",
+  "customer.field.work_phone": "Work phone",
+  "customer.field.personal_phone": "Personal phone",
+  "customer.field.company_name": "Company name",
+  "customer.field.website": "Website",
+  "customer.field.opening_balance_at": "Opening balance at",
+  "customer.field.opening_balance": "Opening balance",
+  "customer.field.created_at": "Created at",
+  "customer.field.balance": "Balance",
+  "customer.field.status": "Status",
+  "customer.field.currency": "Curreny",
+  "customer.field.status.active": "Active",
+  "customer.field.status.inactive": "Inactive",
+  "customer.field.status.overdue": "Overdue",
+  "customer.field.status.unpaid": "Unpaid",
+  "vendor.field.first_name": "First name",
+  "vendor.field.last_name": "Last name",
+  "vendor.field.display_name": "Display name",
+  "vendor.field.email": "Email",
+  "vendor.field.work_phone": "Work phone",
+  "vendor.field.personal_phone": "Personal phone",
+  "vendor.field.company_name": "Company name",
+  "vendor.field.website": "Website",
+  "vendor.field.opening_balance_at": "Opening balance at",
+  "vendor.field.opening_balance": "Opening balance",
+  "vendor.field.created_at": "Created at",
+  "vendor.field.balance": "Balance",
+  "vendor.field.status": "Status",
+  "vendor.field.currency": "Curreny",
+  "vendor.field.status.active": "Active",
+  "vendor.field.status.inactive": "Inactive",
+  "vendor.field.status.overdue": "Overdue",
+  "vendor.field.status.unpaid": "Unpaid",
+  "Invoice write-off": "Invoice write-off",
+
+  "transaction_type.credit_note": "Credit note",
+  "transaction_type.refund_credit_note": "Refund credit note",
+  "transaction_type.vendor_credit": "Vendor credit",
+  "transaction_type.refund_vendor_credit": "Refund vendor credit",
+  "transaction_type.landed_cost": "Landed cost",
+
+  "sms_notification.invoice_details.label": "Sale invoice details",
+  "sms_notification.invoice_reminder.label": "Sale invoice reminder",
+  "sms_notification.receipt_details.label": "Sale receipt details",
+  "sms_notification.sale_estimate_details.label": "Sale estimate details",
+  "sms_notification.payment_receive_details.label": "Payment receive details",
+  "sms_notification.customer_balance.label": "Customer balance",
+
+  "sms_notification.invoice_details.description": "SMS notification will be sent to your customer once invoice created and published or when notify customer via SMS about the invoice.",
+  "sms_notification.payment_receive.description": "Payment thank you message notification will be sent to customer once the payment created and published or notify customer about payment manually.",
+  "sms_notification.receipt_details.description": "SMS notification will be sent to your cusotmer once receipt created and published or when notify customer about the receipt manually.",
+  "sms_notification.customer_balance.description": "Send SMS to notify customers about their current outstanding balance.",
+  "sms_notification.estimate_details.description": "SMS notification will be sent to your customer once estimate publish or notify customer about estimate manually.",
+  "sms_notification.invoice_reminder.description": "SMS notification will be sent to remind the customer to pay earliest, either automatically or manually.",
+
+  "sms_notification.customer_balance.default_message": "Dear {CustomerName}, This is reminder about your current outstanding balance of {Balance}, Please pay at the earliest. - {CompanyName}",
+  "sms_notification.payment_receive.default_message": "'Hi, {CustomerName}, We have received your payment for the invoice - {InvoiceNumber}. We look forward to serving you again. Thank you. - {CompanyName}'",
+  "sms_notification.estimate.default_message": "Hi, {CustomerName}, We have created an estimate - {EstimateNumber} for you. Please take a look and accept it to proceed further. Looking forward to hearing from you. - {CompanyName}",
+
+  "sms_notification.invoice_details.default_message": "Hi, {CustomerName}, You have an outstanding amount of {DueAmount} for the invoice {InvoiceNumber}. - {CompanyName}",
+  "sms_notification.receipt_details.default_message": "Hi, {CustomerName}, We have created receipt - {ReceiptNumber} for you. we look forward to serveing you again. Thank your - {CompanyName}",
+  "sms_notification.invoice_reminder.default_message": "Dear {CustomerName}, The payment towards the invoice - {InvoiceNumber} is due. Please pay before {DueDate}. Thank you. - {CompanyName}",
+
+  "module.sale_invoices.label": "Sale invoices",
+  "module.sale_receipts.label": "Sale receipts",
+  "module.sale_estimates.label": "Sale estimates",
+  "module.payment_receives.label": "Payment receive",
+  "module.customers.label": "Customers",
+
+  "sms_notification.invoice.var.invoice_number": "References to invoice number.",
+  "sms_notification.invoice.var.reference_number": "References to invoice reference number.",
+  "sms_notification.invoice.var.customer_name": "References to invoice customer name.",
+  "sms_notification.invoice.var.due_amount": "References to invoice due amount.",
+  "sms_notification.invoice.var.amount": "References to invoice amount.",
+  "sms_notification.invoice.var.company_name": "References to company name.",
+  "sms_notification.invoice.var.due_date": "References to invoice due date.",
+
+  "sms_notification.receipt.var.receipt_number": "References to receipt number.",
+  "sms_notification.receipt.var.reference_number": "References to receipt reference number.",
+  "sms_notification.receipt.var.customer_name": "References to receipt customer name.",
+  "sms_notification.receipt.var.amount": "References to receipt amount.",
+  "sms_notification.receipt.var.company_name": "References to company name.",
+
+  "sms_notification.payment.var.payment_number": "References to payment transaction number.",
+  "sms_notification.payment.var.reference_number": "References to payment reference number",
+  "sms_notification.payment.var.customer_name": "References to payment customer name.",
+  "sms_notification.payment.var.amount": "References to payment transaction amount.",
+  "sms_notification.payment.company_name": "References to company name",
+  "sms_notification.payment.var.invoice_number": "Reference to payment invoice number.",
+
+  "sms_notification.estimate.var.estimate_number": "References to estimate number.",
+  "sms_notification.estimate.var.reference_number": "References to estimate reference number.",
+  "sms_notification.estimate.var.customer_name": "References to estimate customer name.",
+  "sms_notification.estimate.var.amount": "References to estimate amount.",
+  "sms_notification.estimate.var.company_name": "References to company name.",
+  "sms_notification.estimate.var.expiration_date": "References to estimate expirtaion date.",
+  "sms_notification.estimate.var.estimate_date": "References to estimate date.",
+
+  "sms_notification.customer.var.customer_name": "References to customer name.",
+  "sms_notification.customer.var.balance": "References to customer outstanding balance.",
+  "sms_notification.customer.var.company_name": "References to company name.",
+
+  "ability.accounts": "Chart of accounts",
+  "ability.manual_journal": "Manual journals",
+  "ability.cashflow": "Cash flow",
+  "ability.inventory_adjustment": "Inventory adjustments",
+  "ability.customers": "Customers",
+  "ability.vendors": "vendors",
+  "ability.sale_estimates": "Sale estimates",
+  "ability.sale_invoices": "Sale invoices",
+  "ability.sale_receipts": "Sale receipts",
+  "ability.expenses": "Expenses",
+  "ability.payments_receive": "Payments receive",
+  "ability.purchase_invoices": "Purchase invoices",
+  "ability.all_reports": "All reports",
+  "ability.payments_made": "Payments made",
+  "ability.preferences": "Preferences",
+  "ability.mutate_system_preferences": "Mutate the system preferences.",
+
+  "ability.items": "Items",
+  "ability.view": "View",
+  "ability.create": "Create",
+  "ability.edit": "Edit",
+  "ability.delete": "Delete",
+  "ability.transactions_locking": "Ability to transactions locking.",
+
+  "ability.balance_sheet_report": "Balance sheet.",
+  "ability.profit_loss_sheet": "Profit/loss sheet",
+  "ability.journal": "Journal",
+  "ability.general_ledger": "General ledger",
+  "ability.cashflow_report": "Cashflow",
+  "ability.AR_aging_summary_report": "A/R aging summary",
+  "ability.AP_aging_summary_report": "A/P aging summary",
+  "ability.purchases_by_items": "Purchases by items",
+  "ability.sales_by_items_report": "Sales by items",
+  "ability.customers_transactions_report": "Customers transactions",
+  "ability.vendors_transactions_report": "Vendors transactions",
+  "ability.customers_summary_balance_report": "Customers summary balance",
+  "ability.vendors_summary_balance_report": "Vendors summary balance",
+  "ability.inventory_valuation_summary": "Inventory valuation summary",
+  "ability.inventory_items_details": "Inventory items details",
+
+  "vendor_credit.field.vendor": "Vendor name",
+  "vendor_credit.field.amount": "Amount",
+  "vendor_credit.field.currency_code": "Currency code",
+  "vendor_credit.field.credit_date": "Credit date",
+  "vendor_credit.field.credit_number": "Credit number",
+  "vendor_credit.field.note": "Note",
+  "vendor_credit.field.created_at": "Created at",
+  "vendor_credit.field.reference_no": "Reference No.",
+
+  "credit_note.field.terms_conditions": "Terms and conditions",
+  "credit_note.field.note": "Note",
+  "credit_note.field.currency_code": "Currency code",
+  "credit_note.field.created_at": "Created at",
+  "credit_note.field.amount": "Amount",
+  "credit_note.field.credit_note_number": "Credit note number",
+  "credit_note.field.credit_note_date": "Credit date",
+  "credit_note.field.customer": "Customer",
+  "credit_note.field.reference_no": "Reference No.",
+
+  "Credit note": "Credit note",
+  "Vendor credit": "Vendor credit",
+  "Refund credit note": "Refund credit note",
+  "Refund vendor credit": "Refund vendor credit",
+  "credit_note.field.status": "Status",
+  "credit_note.field.status.draft": "Draft",
+  "credit_note.field.status.published": "Published",
+  "credit_note.field.status.open": "Open",
+  "credit_note.field.status.closed": "Closed",
+
+  "transactions_locking.module.sales.label": "Sales",
+  "transactions_locking.module.purchases.label": "Purchases",
+  "transactions_locking.module.financial.label": "Financial",
+  "transactions_locking.module.all_transactions": "All transactions",
+
+  "transactions_locking.module.sales.desc": "Sale invoices, Receipts, credit notes, customers payment receive and customers opening balances.",
+  "transactions_locking.module.purchases.desc": "Purchase invoices, vendors payments, vendor credit notes and vendors opening balances.",
+  "transactions_locking.module.financial.desc": "Manual journal, expenses and inventory adjustments.",
+
+  "inventory_adjustment.type.increment": "Increment",
+  "inventory_adjustment.type.decrement": "Decrement",
+
+  "customer.type.individual": "Individual",
+  "customer.type.business": "Business",
+
+  "credit_note.view.draft": "Draft",
+  "credit_note.view.closed": "Closed",
+  "credit_note.view.open": "Open",
+  "credit_note.view.published": "Published",
+
+  "vendor_credit.view.draft": "Draft",
+  "vendor_credit.view.closed": "Closed",
+  "vendor_credit.view.open": "Open",
+  "vendor_credit.view.published": "Published",
+
+  "allocation_method.value.label": "Value",
+  "allocation_method.quantity.label": "Quantity",
+
+  "balance_sheet.assets": "Assets",
+  "balance_sheet.current_asset": "Current Asset",
+  "balance_sheet.cash_and_cash_equivalents": "Cash and cash equivalents",
+  "balance_sheet.accounts_receivable": "Accounts Receivable",
+  "balance_sheet.inventory": "Inventory",
+  "balance_sheet.other_current_assets": "Other current assets",
+  "balance_sheet.fixed_asset": "Fixed Asset",
+  "balance_sheet.non_current_assets": "Non-Current Assets",
+  "balance_sheet.liabilities_and_equity": "Liabilities and Equity",
+  "balance_sheet.liabilities": "Liabilities",
+  "balance_sheet.current_liabilties": "Current Liabilties",
+  "balance_sheet.long_term_liabilities": "Long-Term Liabilities",
+  "balance_sheet.non_current_liabilities": "Non-Current Liabilities",
+  "balance_sheet.equity": "Equity",
+
+  "balance_sheet.account_name": "Account name",
+  "balance_sheet.total": "Total",
+  "balance_sheet.percentage_of_column": "% of Column",
+  "balance_sheet.percentage_of_row": "% of Row",
+
+  "financial_sheet.previoud_period_date": "{{date}} (PP)",
+  "fianncial_sheet.previous_period_change": "Change (PP)",
+  "financial_sheet.previous_period_percentage": "% Change (PP)",
+
+  "financial_sheet.previous_year_date": "{{date}} (PY)",
+  "financial_sheet.previous_year_change": "Change (PY)",
+  "financial_sheet.previous_year_percentage": "% Change (PY)",
+  "financial_sheet.total_row": "Total {{value}}",
+
+  "profit_loss_sheet.income": "Income",
+  "profit_loss_sheet.cost_of_sales": "Cost of sales",
+  "profit_loss_sheet.gross_profit": "GROSS PROFIT",
+  "profit_loss_sheet.expenses": "Expenses",
+  "profit_loss_sheet.net_operating_income": "NET OPERATING INCOME",
+  "profit_loss_sheet.other_income": "Other income",
+  "profit_loss_sheet.other_expenses": "Other expenses",
+  "profit_loss_sheet.net_income": "NET INCOME",
+
+  "profit_loss_sheet.account_name": "Account name",
+  "profit_loss_sheet.total": "Total",
+
+  "profit_loss_sheet.percentage_of_income": "% of Income",
+  "profit_loss_sheet.percentage_of_expenses": "% of Expenses",
+  "profit_loss_sheet.percentage_of_column": "% of Column",
+  "profit_loss_sheet.percentage_of_row": "% of Row",
+
+  "contact_summary_balance.account_name": "Account name",
+  "contact_summary_balance.total": "Total",
+  "contact_summary_balance.percentage_column": "% of Column",
+
+  "warehouses.primary_warehouse": "Primary warehouse",
+  "branches.head_branch": "Head Branch",
+
+  "account.accounts_payable.currency": "Accounts Payable (A/P) - {{currency}}",
+  "account.accounts_receivable.currency": "Accounts Receivable (A/R) - {{currency}}",
+
+  "role.admin.name": "Admin",
+  "role.admin.desc": "Unrestricted access to all modules.",
+
+  "role.staff.name": "Staff",
+  "role.staff.desc": "Access to all modules except reports, settings and accountant.",
+
+  "warehouse_transfer.view.draft.name": "Draft",
+  "warehouse_transfer.view.in_transit.name": "In Transit",
+  "warehouse_transfer.view.transferred.name": "Transferred"
+}
\ No newline at end of file
diff --git a/packages/server/src/models/Account.Settings.ts b/packages/server/src/models/Account.Settings.ts
new file mode 100644
index 000000000..3d0698d0d
--- /dev/null
+++ b/packages/server/src/models/Account.Settings.ts
@@ -0,0 +1,101 @@
+import { ACCOUNT_TYPES } from '@/data/AccountTypes';
+
+export default {
+  defaultFilterField: 'name',
+  defaultSort: {
+    sortOrder: 'DESC',
+    sortField: 'name',
+  },
+  fields: {
+    name: {
+      name: 'account.field.name',
+      column: 'name',
+      fieldType: 'text',
+    },
+    description: {
+      name: 'account.field.description',
+      column: 'description',
+      fieldType: 'text',
+    },
+    slug: {
+      name: 'account.field.slug',
+      column: 'slug',
+      fieldType: 'text',
+      columnable: false,
+      filterable: false,
+    },
+    code: {
+      name: 'account.field.code',
+      column: 'code',
+      fieldType: 'text',
+    },
+    root_type: {
+      name: 'account.field.root_type',
+      fieldType: 'enumeration',
+      options: [
+        { key: 'asset', label: 'Asset' },
+        { key: 'liability', label: 'Liability' },
+        { key: 'equity', label: 'Equity' },
+        { key: 'Income', label: 'Income' },
+        { key: 'expense', label: 'Expense' },
+      ],
+      filterCustomQuery: RootTypeFieldFilterQuery,
+      sortable: false,
+    },
+    normal: {
+      name: 'account.field.normal',
+      fieldType: 'enumeration',
+      options: [
+        { key: 'debit', label: 'account.field.normal.debit' },
+        { key: 'credit', label: 'account.field.normal.credit' },
+      ],
+      filterCustomQuery: NormalTypeFieldFilterQuery,
+      sortable: false,
+    },
+    type: {
+      name: 'account.field.type',
+      column: 'account_type',
+      fieldType: 'enumeration',
+      options: ACCOUNT_TYPES.map((accountType) => ({
+        label: accountType.label,
+        key: accountType.key
+      })),
+    },
+    active: {
+      name: 'account.field.active',
+      column: 'active',
+      fieldType: 'boolean',
+      filterable: false,
+    },
+    balance: {
+      name: 'account.field.balance',
+      column: 'amount',
+      fieldType: 'number',
+    },
+    currency: {
+      name: 'account.field.currency',
+      column: 'currency_code',
+      fieldType: 'text',
+      filterable: false,
+    },
+    created_at: {
+      name: 'account.field.created_at',
+      column: 'created_at',
+      fieldType: 'date',
+    },
+  },
+};
+
+/**
+ * Filter query of root type field .
+ */
+function RootTypeFieldFilterQuery(query, role) {
+  query.modify('filterByRootType', role.value);
+}
+
+/**
+ * Filter query of normal field .
+ */
+function NormalTypeFieldFilterQuery(query, role) {
+  query.modify('filterByAccountNormal', role.value);
+}
diff --git a/packages/server/src/models/Account.ts b/packages/server/src/models/Account.ts
new file mode 100644
index 000000000..a3d9f74f3
--- /dev/null
+++ b/packages/server/src/models/Account.ts
@@ -0,0 +1,419 @@
+/* eslint-disable global-require */
+import { mixin, Model } from 'objection';
+import { castArray } from 'lodash';
+import TenantModel from '@/models/TenantModel';
+import { buildFilterQuery, buildSortColumnQuery } from '@/lib/ViewRolesBuilder';
+import { flatToNestedArray } from 'utils';
+import DependencyGraph from '@/lib/DependencyGraph';
+import AccountTypesUtils from '@/lib/AccountTypes';
+import AccountSettings from './Account.Settings';
+import ModelSettings from './ModelSetting';
+import {
+  ACCOUNT_TYPES,
+  getAccountsSupportsMultiCurrency,
+} from '@/data/AccountTypes';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import { DEFAULT_VIEWS } from '@/services/Accounts/constants';
+import ModelSearchable from './ModelSearchable';
+
+export default class Account extends mixin(TenantModel, [
+  ModelSettings,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'accounts';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  static get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return [
+      'accountTypeLabel',
+      'accountParentType',
+      'accountRootType',
+      'accountNormal',
+      'accountNormalFormatted',
+      'isBalanceSheetAccount',
+      'isPLSheet',
+    ];
+  }
+
+  /**
+   * Account normal.
+   */
+  get accountNormal() {
+    return AccountTypesUtils.getType(this.accountType, 'normal');
+  }
+
+  get accountNormalFormatted() {
+    const paris = {
+      credit: 'Credit',
+      debit: 'Debit',
+    };
+    return paris[this.accountNormal] || '';
+  }
+
+  /**
+   * Retrieve account type label.
+   */
+  get accountTypeLabel() {
+    return AccountTypesUtils.getType(this.accountType, 'label');
+  }
+
+  /**
+   * Retrieve account parent type.
+   */
+  get accountParentType() {
+    return AccountTypesUtils.getType(this.accountType, 'parentType');
+  }
+
+  /**
+   * Retrieve account root type.
+   */
+  get accountRootType() {
+    return AccountTypesUtils.getType(this.accountType, 'rootType');
+  }
+
+  /**
+   * Retrieve whether the account is balance sheet account.
+   */
+  get isBalanceSheetAccount() {
+    return this.isBalanceSheet();
+  }
+
+  /**
+   * Retrieve whether the account is profit/loss sheet account.
+   */
+  get isPLSheet() {
+    return this.isProfitLossSheet();
+  }
+  /**
+   * Allows to mark model as resourceable to viewable and filterable.
+   */
+  static get resourceable() {
+    return true;
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    const TABLE_NAME = Account.tableName;
+
+    return {
+      /**
+       * Inactive/Active mode.
+       */
+      inactiveMode(query, active = false) {
+        query.where('accounts.active', !active);
+      },
+
+      filterAccounts(query, accountIds) {
+        if (accountIds.length > 0) {
+          query.whereIn(`${TABLE_NAME}.id`, accountIds);
+        }
+      },
+      filterAccountTypes(query, typesIds) {
+        if (typesIds.length > 0) {
+          query.whereIn('account_types.accoun_type_id', typesIds);
+        }
+      },
+      viewRolesBuilder(query, conditionals, expression) {
+        buildFilterQuery(Account.tableName, conditionals, expression)(query);
+      },
+      sortColumnBuilder(query, columnKey, direction) {
+        buildSortColumnQuery(Account.tableName, columnKey, direction)(query);
+      },
+
+      /**
+       * Filter by root type.
+       */
+      filterByRootType(query, rootType) {
+        const filterTypes = ACCOUNT_TYPES.filter(
+          (accountType) => accountType.rootType === rootType
+        ).map((accountType) => accountType.key);
+
+        query.whereIn('account_type', filterTypes);
+      },
+
+      /**
+       * Filter by account normal
+       */
+      filterByAccountNormal(query, accountNormal) {
+        const filterTypes = ACCOUNT_TYPES.filter(
+          (accountType) => accountType.normal === accountNormal
+        ).map((accountType) => accountType.key);
+
+        query.whereIn('account_type', filterTypes);
+      },
+
+      /**
+       * Finds account by the given slug.
+       * @param {*} query
+       * @param {*} slug
+       */
+      findBySlug(query, slug) {
+        query.where('slug', slug).first();
+      },
+
+      /**
+       *
+       * @param {*} query
+       * @param {*} baseCyrrency
+       */
+      preventMutateBaseCurrency(query) {
+        const accountsTypes = getAccountsSupportsMultiCurrency();
+        const accountsTypesKeys = accountsTypes.map((type) => type.key);
+
+        query
+          .whereIn('accountType', accountsTypesKeys)
+          .where('seededAt', null)
+          .first();
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const AccountTransaction = require('models/AccountTransaction');
+    const Item = require('models/Item');
+    const InventoryAdjustment = require('models/InventoryAdjustment');
+    const ManualJournalEntry = require('models/ManualJournalEntry');
+    const Expense = require('models/Expense');
+    const ExpenseEntry = require('models/ExpenseCategory');
+    const ItemEntry = require('models/ItemEntry');
+
+    return {
+      /**
+       * Account model may has many transactions.
+       */
+      transactions: {
+        relation: Model.HasManyRelation,
+        modelClass: AccountTransaction.default,
+        join: {
+          from: 'accounts.id',
+          to: 'accounts_transactions.accountId',
+        },
+      },
+
+      /**
+       *
+       */
+      itemsCostAccount: {
+        relation: Model.HasManyRelation,
+        modelClass: Item.default,
+        join: {
+          from: 'accounts.id',
+          to: 'items.costAccountId',
+        },
+      },
+
+      /**
+       *
+       */
+      itemsSellAccount: {
+        relation: Model.HasManyRelation,
+        modelClass: Item.default,
+        join: {
+          from: 'accounts.id',
+          to: 'items.sellAccountId',
+        },
+      },
+
+      /**
+       *
+       */
+      inventoryAdjustments: {
+        relation: Model.HasManyRelation,
+        modelClass: InventoryAdjustment.default,
+        join: {
+          from: 'accounts.id',
+          to: 'inventory_adjustments.adjustmentAccountId',
+        },
+      },
+
+      /**
+       *
+       */
+      manualJournalEntries: {
+        relation: Model.HasManyRelation,
+        modelClass: ManualJournalEntry.default,
+        join: {
+          from: 'accounts.id',
+          to: 'manual_journals_entries.accountId',
+        },
+      },
+
+      /**
+       *
+       */
+      expensePayments: {
+        relation: Model.HasManyRelation,
+        modelClass: Expense.default,
+        join: {
+          from: 'accounts.id',
+          to: 'expenses_transactions.paymentAccountId',
+        },
+      },
+
+      /**
+       *
+       */
+      expenseEntries: {
+        relation: Model.HasManyRelation,
+        modelClass: ExpenseEntry.default,
+        join: {
+          from: 'accounts.id',
+          to: 'expense_transaction_categories.expenseAccountId',
+        },
+      },
+
+      /**
+       *
+       */
+      entriesCostAccount: {
+        relation: Model.HasManyRelation,
+        modelClass: ItemEntry.default,
+        join: {
+          from: 'accounts.id',
+          to: 'items_entries.costAccountId',
+        },
+      },
+
+      /**
+       *
+       */
+      entriesSellAccount: {
+        relation: Model.HasManyRelation,
+        modelClass: ItemEntry.default,
+        join: {
+          from: 'accounts.id',
+          to: 'items_entries.sellAccountId',
+        },
+      },
+    };
+  }
+
+  /**
+   * Detarmines whether the given type equals the account type.
+   * @param {string} accountType
+   * @return {boolean}
+   */
+  isAccountType(accountType) {
+    const types = castArray(accountType);
+    return types.indexOf(this.accountType) !== -1;
+  }
+
+  /**
+   * Detarmines whether the given root type equals the account type.
+   * @param {string} rootType
+   * @return {boolean}
+   */
+  isRootType(rootType) {
+    return AccountTypesUtils.isRootTypeEqualsKey(this.accountType, rootType);
+  }
+
+  /**
+   * Detarmine whether the given parent type equals the account type.
+   * @param {string} parentType
+   * @return {boolean}
+   */
+  isParentType(parentType) {
+    return AccountTypesUtils.isParentTypeEqualsKey(
+      this.accountType,
+      parentType
+    );
+  }
+
+  /**
+   * Detarmines whether the account is balance sheet account.
+   * @return {boolean}
+   */
+  isBalanceSheet() {
+    return AccountTypesUtils.isTypeBalanceSheet(this.accountType);
+  }
+
+  /**
+   * Detarmines whether the account is profit/loss account.
+   * @return {boolean}
+   */
+  isProfitLossSheet() {
+    return AccountTypesUtils.isTypePLSheet(this.accountType);
+  }
+
+  /**
+   * Detarmines whether the account is income statement account
+   * @return {boolean}
+   */
+  isIncomeSheet() {
+    return this.isProfitLossSheet();
+  }
+
+  /**
+   * Converts flatten accounts list to nested array.
+   * @param {Array} accounts
+   * @param {Object} options
+   */
+  static toNestedArray(accounts, options = { children: 'children' }) {
+    return flatToNestedArray(accounts, {
+      id: 'id',
+      parentId: 'parentAccountId',
+    });
+  }
+
+  /**
+   * Transformes the accounts list to depenedency graph structure.
+   * @param {IAccount[]} accounts
+   */
+  static toDependencyGraph(accounts) {
+    return DependencyGraph.fromArray(accounts, {
+      itemId: 'id',
+      parentItemId: 'parentAccountId',
+    });
+  }
+
+  /**
+   * Model settings.
+   */
+  static get meta() {
+    return AccountSettings;
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model search roles.
+   */
+  static get searchRoles() {
+    return [
+      { condition: 'or', fieldKey: 'name', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'code', comparator: 'like' },
+    ];
+  }
+
+  /**
+   * Prevents mutate base currency since the model is not empty.
+   */
+  static get preventMutateBaseCurrency() {
+    return true;
+  }
+}
diff --git a/packages/server/src/models/AccountTransaction.ts b/packages/server/src/models/AccountTransaction.ts
new file mode 100644
index 000000000..2aa70aa75
--- /dev/null
+++ b/packages/server/src/models/AccountTransaction.ts
@@ -0,0 +1,230 @@
+import { Model, raw } from 'objection';
+import moment from 'moment';
+import { isEmpty, castArray } from 'lodash';
+import TenantModel from 'models/TenantModel';
+
+export default class AccountTransaction extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'accounts_transactions';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['referenceTypeFormatted'];
+  }
+
+  /**
+   * Retrieve formatted reference type.
+   * @return {string}
+   */
+  get referenceTypeFormatted() {
+    return AccountTransaction.getReferenceTypeFormatted(this.referenceType);
+  }
+
+  /**
+   * Reference type formatted.
+   */
+  static getReferenceTypeFormatted(referenceType) {
+    const mapped = {
+      SaleInvoice: 'Sale invoice',
+      SaleReceipt: 'Sale receipt',
+      PaymentReceive: 'Payment receive',
+      Bill: 'Bill',
+      BillPayment: 'Payment made',
+      VendorOpeningBalance: 'Vendor opening balance',
+      CustomerOpeningBalance: 'Customer opening balance',
+      InventoryAdjustment: 'Inventory adjustment',
+      ManualJournal: 'Manual journal',
+      Journal: 'Manual journal',
+      Expense: 'Expense',
+      OwnerContribution: 'Owner contribution',
+      TransferToAccount: 'Transfer to account',
+      TransferFromAccount: 'Transfer from account',
+      OtherIncome: 'Other income',
+      OtherExpense: 'Other expense',
+      OwnerDrawing: 'Owner drawing',
+      InvoiceWriteOff: 'Invoice write-off',
+
+      CreditNote: 'transaction_type.credit_note',
+      VendorCredit: 'transaction_type.vendor_credit',
+
+      RefundCreditNote: 'transaction_type.refund_credit_note',
+      RefundVendorCredit: 'transaction_type.refund_vendor_credit',
+    };
+    return mapped[referenceType] || '';
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Filters accounts by the given ids.
+       * @param {Query} query
+       * @param {number[]} accountsIds
+       */
+      filterAccounts(query, accountsIds) {
+        if (Array.isArray(accountsIds) && accountsIds.length > 0) {
+          query.whereIn('account_id', accountsIds);
+        }
+      },
+      filterTransactionTypes(query, types) {
+        if (Array.isArray(types) && types.length > 0) {
+          query.whereIn('reference_type', types);
+        } else if (typeof types === 'string') {
+          query.where('reference_type', types);
+        }
+      },
+      filterDateRange(query, startDate, endDate, type = 'day') {
+        const dateFormat = 'YYYY-MM-DD HH:mm:ss';
+        const fromDate = moment(startDate)
+          .utcOffset(0)
+          .startOf(type)
+          .format(dateFormat);
+        const toDate = moment(endDate)
+          .utcOffset(0)
+          .endOf(type)
+          .format(dateFormat);
+
+        if (startDate) {
+          query.where('date', '>=', fromDate);
+        }
+        if (endDate) {
+          query.where('date', '<=', toDate);
+        }
+      },
+      filterAmountRange(query, fromAmount, toAmount) {
+        if (fromAmount) {
+          query.andWhere((q) => {
+            q.where('credit', '>=', fromAmount);
+            q.orWhere('debit', '>=', fromAmount);
+          });
+        }
+        if (toAmount) {
+          query.andWhere((q) => {
+            q.where('credit', '<=', toAmount);
+            q.orWhere('debit', '<=', toAmount);
+          });
+        }
+      },
+      sumationCreditDebit(query) {
+        query.select(['accountId']);
+
+        query.sum('credit as credit');
+        query.sum('debit as debit');
+        query.groupBy('account_id');
+      },
+      filterContactType(query, contactType) {
+        query.where('contact_type', contactType);
+      },
+      filterContactIds(query, contactIds) {
+        query.whereIn('contact_id', contactIds);
+      },
+      openingBalance(query, fromDate) {
+        query.modify('filterDateRange', null, fromDate);
+        query.modify('sumationCreditDebit');
+      },
+      closingBalance(query, toDate) {
+        query.modify('filterDateRange', null, toDate);
+        query.modify('sumationCreditDebit');
+      },
+
+      contactsOpeningBalance(
+        query,
+        openingDate,
+        receivableAccounts,
+        customersIds
+      ) {
+        // Filter by date.
+        query.modify('filterDateRange', null, openingDate);
+
+        // Filter by customers.
+        query.whereNot('contactId', null);
+        query.whereIn('accountId', castArray(receivableAccounts));
+
+        if (!isEmpty(customersIds)) {
+          query.whereIn('contactId', castArray(customersIds));
+        }
+        // Group by the contact transactions.
+        query.groupBy('contactId');
+        query.sum('credit as credit');
+        query.sum('debit as debit');
+        query.select('contactId');
+      },
+      creditDebitSummation(query) {
+        query.sum('credit as credit');
+        query.sum('debit as debit');
+      },
+      groupByDateFormat(query, groupType = 'month') {
+        const groupBy = {
+          day: '%Y-%m-%d',
+          month: '%Y-%m',
+          year: '%Y',
+        };
+        const dateFormat = groupBy[groupType];
+
+        query.select(raw(`DATE_FORMAT(DATE, '${dateFormat}')`).as('date'));
+        query.groupByRaw(`DATE_FORMAT(DATE, '${dateFormat}')`);
+      },
+
+      filterByBranches(query, branchesIds) {
+        const formattedBranchesIds = castArray(branchesIds);
+
+        query.whereIn('branchId', formattedBranchesIds);
+      },
+
+      filterByProjects(query, projectsIds) {
+        const formattedProjectsIds = castArray(projectsIds);
+
+        query.whereIn('projectId', formattedProjectsIds);
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Account = require('models/Account');
+    const Contact = require('models/Contact');
+
+    return {
+      account: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'accounts_transactions.accountId',
+          to: 'accounts.id',
+        },
+      },
+      contact: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Contact.default,
+        join: {
+          from: 'accounts_transactions.contactId',
+          to: 'contacts.id',
+        },
+      },
+    };
+  }
+
+  /**
+   * Prevents mutate base currency since the model is not empty.
+   */
+  static get preventMutateBaseCurrency() {
+    return true;
+  }
+}
diff --git a/packages/server/src/models/Auth.ts b/packages/server/src/models/Auth.ts
new file mode 100644
index 000000000..93dc11103
--- /dev/null
+++ b/packages/server/src/models/Auth.ts
@@ -0,0 +1,38 @@
+
+export default class Auth {
+  /**
+   * Retrieve the authenticated user.
+   */
+  static get user() {
+    return null;
+  }
+
+  /**
+   * Sets the authenticated user.
+   * @param {User} user
+   */
+  static setAuthenticatedUser(user) {
+    this.user = user;
+  }
+
+  /**
+   * Retrieve the authenticated user ID.
+   */
+  static userId() {
+    if (!this.user) {
+      return false;
+    }
+    return this.user.id;
+  }
+
+  /**
+   * Whether the user is logged or not.
+   */
+  static isLogged() {
+    return !!this.user;
+  }
+
+  static loggedOut() {
+    this.user = null;
+  }
+}
diff --git a/packages/server/src/models/Bill.Settings.ts b/packages/server/src/models/Bill.Settings.ts
new file mode 100644
index 000000000..166648a0c
--- /dev/null
+++ b/packages/server/src/models/Bill.Settings.ts
@@ -0,0 +1,94 @@
+
+export default {
+  defaultFilterField: 'vendor',
+  defaultSort: {
+    sortOrder: 'DESC',
+    sortField: 'bill_date',
+  },
+  fields: {
+    vendor: {
+      name: 'bill.field.vendor',
+      column: 'vendor_id',
+      fieldType: 'relation',
+
+      relationType: 'enumeration',
+      relationKey: 'vendor',
+
+      relationEntityLabel: 'display_name',
+      relationEntityKey: 'id',
+    },
+    bill_number: {
+      name: 'bill.field.bill_number',
+      column: 'bill_number',
+      columnable: true,
+      fieldType: 'text',
+    },
+    bill_date: {
+      name: 'bill.field.bill_date',
+      column: 'bill_date',
+      columnable: true,
+      fieldType: 'date',
+    },
+    due_date: {
+      name: 'bill.field.due_date',
+      column: 'due_date',
+      columnable: true,
+      fieldType: 'date',
+    },
+    reference_no: {
+      name: 'bill.field.reference_no',
+      column: 'reference_no',
+      columnable: true,
+      fieldType: 'text',
+    },
+    status: {
+      name: 'bill.field.status',
+      fieldType: 'enumeration',
+      columnable: true,
+      options: [
+        { label: 'bill.field.status.paid', key: 'paid' },
+        { label: 'bill.field.status.partially-paid', key: 'partially-paid' },
+        { label: 'bill.field.status.overdue', key: 'overdue' },
+        { label: 'bill.field.status.unpaid', key: 'unpaid' },
+        { label: 'bill.field.status.opened', key: 'opened' },
+        { label: 'bill.field.status.draft', key: 'draft' },
+      ],
+      filterCustomQuery: StatusFieldFilterQuery,
+      sortCustomQuery: StatusFieldSortQuery,
+    },
+    amount: {
+      name: 'bill.field.amount',
+      column: 'amount',
+      fieldType: 'number',
+    },
+    payment_amount: {
+      name: 'bill.field.payment_amount',
+      column: 'payment_amount',
+      fieldType: 'number',
+    },
+    note: {
+      name: 'bill.field.note',
+      column: 'note',
+      fieldType: 'text',
+    },
+    created_at: {
+      name: 'bill.field.created_at',
+      column: 'created_at',
+      fieldType: 'date',
+    },
+  },
+};
+
+/**
+ * Status field filter custom query.
+ */
+function StatusFieldFilterQuery(query, role) {
+  query.modify('statusFilter', role.value);
+}
+
+/**
+ * Status field sort custom query.
+ */
+function StatusFieldSortQuery(query, role) {
+  query.modify('sortByStatus', role.order);
+}
diff --git a/packages/server/src/models/Bill.ts b/packages/server/src/models/Bill.ts
new file mode 100644
index 000000000..18d375d1e
--- /dev/null
+++ b/packages/server/src/models/Bill.ts
@@ -0,0 +1,431 @@
+import { Model, raw, mixin } from 'objection';
+import { castArray, difference } from 'lodash';
+import moment from 'moment';
+import TenantModel from 'models/TenantModel';
+import BillSettings from './Bill.Settings';
+import ModelSetting from './ModelSetting';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import { DEFAULT_VIEWS } from '@/services/Purchases/constants';
+import ModelSearchable from './ModelSearchable';
+
+export default class Bill extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'bills';
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Filters the bills in draft status.
+       */
+      draft(query) {
+        query.where('opened_at', null);
+      },
+
+      /**
+       * Filters the opened bills.
+       */
+      published(query) {
+        query.whereNot('openedAt', null);
+      },
+
+      /**
+       * Filters the opened bills.
+       */
+      opened(query) {
+        query.whereNot('opened_at', null);
+      },
+      /**
+       * Filters the unpaid bills.
+       */
+      unpaid(query) {
+        query.where('payment_amount', 0);
+      },
+      /**
+       * Filters the due bills.
+       */
+      dueBills(query) {
+        query.where(
+          raw(`COALESCE(AMOUNT, 0) -
+            COALESCE(PAYMENT_AMOUNT, 0) -
+            COALESCE(CREDITED_AMOUNT, 0) > 0
+          `)
+        );
+      },
+      /**
+       * Filters the overdue bills.
+       */
+      overdue(query) {
+        query.where('due_date', '<', moment().format('YYYY-MM-DD'));
+      },
+      /**
+       * Filters the not overdue invoices.
+       */
+      notOverdue(query, asDate = moment().format('YYYY-MM-DD')) {
+        query.where('due_date', '>=', asDate);
+      },
+      /**
+       * Filters the partially paid bills.
+       */
+      partiallyPaid(query) {
+        query.whereNot('payment_amount', 0);
+        query.whereNot(raw('`PAYMENT_AMOUNT` = `AMOUNT`'));
+      },
+      /**
+       * Filters the paid bills.
+       */
+      paid(query) {
+        query.where(raw('`PAYMENT_AMOUNT` = `AMOUNT`'));
+      },
+      /**
+       * Filters the bills from the given date.
+       */
+      fromDate(query, fromDate) {
+        query.where('bill_date', '<=', fromDate);
+      },
+
+      /**
+       * Sort the bills by full-payment bills.
+       */
+      sortByStatus(query, order) {
+        query.orderByRaw(`PAYMENT_AMOUNT = AMOUNT ${order}`);
+      },
+
+      /**
+       * Status filter.
+       */
+      statusFilter(query, filterType) {
+        switch (filterType) {
+          case 'draft':
+            query.modify('draft');
+            break;
+          case 'delivered':
+            query.modify('delivered');
+            break;
+          case 'unpaid':
+            query.modify('unpaid');
+            break;
+          case 'overdue':
+          default:
+            query.modify('overdue');
+            break;
+          case 'partially-paid':
+            query.modify('partiallyPaid');
+            break;
+          case 'paid':
+            query.modify('paid');
+            break;
+        }
+      },
+
+      /**
+       * Filters by branches.
+       */
+      filterByBranches(query, branchesIds) {
+        const formattedBranchesIds = castArray(branchesIds);
+
+        query.whereIn('branchId', formattedBranchesIds);
+      },
+
+      dueBillsFromDate(query, asDate = moment().format('YYYY-MM-DD')) {
+        query.modify('dueBills');
+        query.modify('notOverdue');
+        query.modify('fromDate', asDate);
+      },
+
+      overdueBillsFromDate(query, asDate = moment().format('YYYY-MM-DD')) {
+        query.modify('dueBills');
+        query.modify('overdue', asDate);
+        query.modify('fromDate', asDate);
+      },
+
+      /**
+       *
+       */
+      billable(query) {
+        query.where(raw('AMOUNT > INVOICED_AMOUNT'));
+      },
+    };
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return [
+      'balance',
+      'dueAmount',
+      'isOpen',
+      'isPartiallyPaid',
+      'isFullyPaid',
+      'isPaid',
+      'remainingDays',
+      'overdueDays',
+      'isOverdue',
+      'unallocatedCostAmount',
+      'localAmount',
+      'localAllocatedCostAmount',
+      'billableAmount',
+    ];
+  }
+
+  /**
+   * Invoice amount in organization base currency.
+   * @returns {number}
+   */
+  get localAmount() {
+    return this.amount * this.exchangeRate;
+  }
+
+  /**
+   * Retrieves the local allocated cost amount.
+   * @returns {number}
+   */
+  get localAllocatedCostAmount() {
+    return this.allocatedCostAmount * this.exchangeRate;
+  }
+
+  /**
+   * Retrieves the local landed cost amount.
+   * @returns {number}
+   */
+  get localLandedCostAmount() {
+    return this.landedCostAmount * this.exchangeRate;
+  }
+
+  /**
+   * Retrieves the local unallocated cost amount.
+   * @returns {number}
+   */
+  get localUnallocatedCostAmount() {
+    return this.unallocatedCostAmount * this.exchangeRate;
+  }
+
+  /**
+   * Retrieve the balance of bill.
+   * @return {number}
+   */
+  get balance() {
+    return this.paymentAmount + this.creditedAmount;
+  }
+
+  /**
+   * Due amount of the given.
+   * @return {number}
+   */
+  get dueAmount() {
+    return Math.max(this.amount - this.balance, 0);
+  }
+
+  /**
+   * Detarmine whether the bill is open.
+   * @return {boolean}
+   */
+  get isOpen() {
+    return !!this.openedAt;
+  }
+
+  /**
+   * Deetarmine whether the bill paid partially.
+   * @return {boolean}
+   */
+  get isPartiallyPaid() {
+    return this.dueAmount !== this.amount && this.dueAmount > 0;
+  }
+
+  /**
+   * Deetarmine whether the bill paid fully.
+   * @return {boolean}
+   */
+  get isFullyPaid() {
+    return this.dueAmount === 0;
+  }
+
+  /**
+   * Detarmines whether the bill paid fully or partially.
+   * @return {boolean}
+   */
+  get isPaid() {
+    return this.isPartiallyPaid || this.isFullyPaid;
+  }
+
+  /**
+   * Retrieve the remaining days in number
+   * @return {number|null}
+   */
+  get remainingDays() {
+    const currentMoment = moment();
+    const dueDateMoment = moment(this.dueDate);
+
+    return Math.max(dueDateMoment.diff(currentMoment, 'days'), 0);
+  }
+
+  /**
+   * Retrieve the overdue days in number.
+   * @return {number|null}
+   */
+  get overdueDays() {
+    const currentMoment = moment();
+    const dueDateMoment = moment(this.dueDate);
+
+    return Math.max(currentMoment.diff(dueDateMoment, 'days'), 0);
+  }
+
+  /**
+   * Detarmines the due date is over.
+   * @return {boolean}
+   */
+  get isOverdue() {
+    return this.overdueDays > 0;
+  }
+
+  /**
+   * Retrieve the unallocated cost amount.
+   * @return {number}
+   */
+  get unallocatedCostAmount() {
+    return Math.max(this.landedCostAmount - this.allocatedCostAmount, 0);
+  }
+
+  /**
+   * Retrieves the calculated amount which have not been invoiced.
+   */
+  get billableAmount() {
+    return Math.max(this.amount - this.invoicedAmount, 0);
+  }
+
+  /**
+   * Bill model settings.
+   */
+  static get meta() {
+    return BillSettings;
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Vendor = require('models/Vendor');
+    const ItemEntry = require('models/ItemEntry');
+    const BillLandedCost = require('models/BillLandedCost');
+    const Branch = require('models/Branch');
+
+    return {
+      vendor: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Vendor.default,
+        join: {
+          from: 'bills.vendorId',
+          to: 'contacts.id',
+        },
+        filter(query) {
+          query.where('contact_service', 'vendor');
+        },
+      },
+
+      entries: {
+        relation: Model.HasManyRelation,
+        modelClass: ItemEntry.default,
+        join: {
+          from: 'bills.id',
+          to: 'items_entries.referenceId',
+        },
+        filter(builder) {
+          builder.where('reference_type', 'Bill');
+          builder.orderBy('index', 'ASC');
+        },
+      },
+
+      locatedLandedCosts: {
+        relation: Model.HasManyRelation,
+        modelClass: BillLandedCost.default,
+        join: {
+          from: 'bills.id',
+          to: 'bill_located_costs.billId',
+        },
+      },
+
+      /**
+       * Bill may belongs to associated branch.
+       */
+      branch: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Branch.default,
+        join: {
+          from: 'bills.branchId',
+          to: 'branches.id',
+        },
+      },
+    };
+  }
+
+  /**
+   * Retrieve the not found bills ids as array that associated to the given vendor.
+   * @param {Array} billsIds
+   * @param {number} vendorId -
+   * @return {Array}
+   */
+  static async getNotFoundBills(billsIds, vendorId) {
+    const storedBills = await this.query().onBuild((builder) => {
+      builder.whereIn('id', billsIds);
+
+      if (vendorId) {
+        builder.where('vendor_id', vendorId);
+      }
+    });
+
+    const storedBillsIds = storedBills.map((t) => t.id);
+
+    const notFoundBillsIds = difference(billsIds, storedBillsIds);
+    return notFoundBillsIds;
+  }
+
+  static changePaymentAmount(billId, amount) {
+    const changeMethod = amount > 0 ? 'increment' : 'decrement';
+    return this.query()
+      .where('id', billId)
+      [changeMethod]('payment_amount', Math.abs(amount));
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model search attributes.
+   */
+  static get searchRoles() {
+    return [
+      { fieldKey: 'bill_number', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'reference_no', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'amount', comparator: 'equals' },
+    ];
+  }
+
+  /**
+   * Prevents mutate base currency since the model is not empty.
+   */
+  static get preventMutateBaseCurrency() {
+    return true;
+  }
+}
diff --git a/packages/server/src/models/BillLandedCost.ts b/packages/server/src/models/BillLandedCost.ts
new file mode 100644
index 000000000..cc06b4f3c
--- /dev/null
+++ b/packages/server/src/models/BillLandedCost.ts
@@ -0,0 +1,92 @@
+import { Model } from 'objection';
+import { lowerCase } from 'lodash';
+import TenantModel from 'models/TenantModel';
+
+export default class BillLandedCost extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'bill_located_costs';
+  }
+
+  /**
+   * Model timestamps.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['localAmount', 'allocationMethodFormatted'];
+  }
+
+  /**
+   * Retrieves the cost local amount.
+   * @returns {number}
+   */
+  get localAmount() {
+    return this.amount * this.exchangeRate;
+  }
+
+  /**
+   * Allocation method formatted.
+   */
+  get allocationMethodFormatted() {
+    const allocationMethod = lowerCase(this.allocationMethod);
+
+    const keyLabelsPairs = {
+      value: 'allocation_method.value.label',
+      quantity: 'allocation_method.quantity.label',
+    };
+    return keyLabelsPairs[allocationMethod] || '';
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const BillLandedCostEntry = require('models/BillLandedCostEntry');
+    const Bill = require('models/Bill');
+    const ItemEntry = require('models/ItemEntry');
+    const ExpenseCategory = require('models/ExpenseCategory');
+
+    return {
+      bill: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Bill.default,
+        join: {
+          from: 'bill_located_costs.billId',
+          to: 'bills.id',
+        },
+      },
+      allocateEntries: {
+        relation: Model.HasManyRelation,
+        modelClass: BillLandedCostEntry.default,
+        join: {
+          from: 'bill_located_costs.id',
+          to: 'bill_located_cost_entries.billLocatedCostId',
+        },
+      },
+      allocatedFromBillEntry: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: ItemEntry.default,
+        join: {
+          from: 'bill_located_costs.fromTransactionEntryId',
+          to: 'items_entries.id',
+        },
+      },
+      allocatedFromExpenseEntry: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: ExpenseCategory.default,
+        join: {
+          from: 'bill_located_costs.fromTransactionEntryId',
+          to: 'expense_transaction_categories.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/BillLandedCostEntry.ts b/packages/server/src/models/BillLandedCostEntry.ts
new file mode 100644
index 000000000..049bef1c5
--- /dev/null
+++ b/packages/server/src/models/BillLandedCostEntry.ts
@@ -0,0 +1,32 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class BillLandedCostEntry extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'bill_located_cost_entries';
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const ItemEntry = require('models/ItemEntry');
+
+    return {
+      itemEntry: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: ItemEntry.default,
+        join: {
+          from: 'bill_located_cost_entries.entryId',
+          to: 'items_entries.id',
+        },
+        filter(builder) {
+          builder.where('reference_type', 'Bill');
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/BillPayment.Settings.ts b/packages/server/src/models/BillPayment.Settings.ts
new file mode 100644
index 000000000..8ca4113b2
--- /dev/null
+++ b/packages/server/src/models/BillPayment.Settings.ts
@@ -0,0 +1,66 @@
+export default {
+  defaultFilterField: 'vendor',
+  defaultSort: {
+    sortOrder: 'DESC',
+    sortField: 'bill_date',
+  },
+  fields: {
+    vendor: {
+      name: 'bill_payment.field.vendor',
+      column: 'vendor_id',
+      fieldType: 'relation',
+
+      relationType: 'enumeration',
+      relationKey: 'vendor',
+
+      relationEntityLabel: 'display_name',
+      relationEntityKey: 'id',
+    },
+    amount: {
+      name: 'bill_payment.field.amount',
+      column: 'amount',
+      fieldType: 'number',
+    },
+    due_amount: {
+      name: 'bill_payment.field.due_amount',
+      column: 'due_amount',
+      fieldType: 'number',
+    },
+    payment_account: {
+      name: 'bill_payment.field.payment_account',
+      column: 'payment_account_id',
+      fieldType: 'relation',
+
+      relationType: 'enumeration',
+      relationKey: 'paymentAccount',
+      
+      relationEntityLabel: 'name',
+      relationEntityKey: 'slug',
+    },
+    payment_number: {
+      name: 'bill_payment.field.payment_number',
+      column: 'payment_number',
+      fieldType: 'text',
+    },
+    payment_date: {
+      name: 'bill_payment.field.payment_date',
+      column: 'payment_date',
+      fieldType: 'date',
+    },
+    reference_no: {
+      name: 'bill_payment.field.reference_no',
+      column: 'reference',
+      fieldType: 'text',
+    },
+    description: {
+      name: 'bill_payment.field.description',
+      column: 'description',
+      fieldType: 'text',
+    },
+    created_at: {
+      name: 'bill_payment.field.created_at',
+      column: 'created_at',
+      fieldType: 'date',
+    },
+  },
+};
diff --git a/packages/server/src/models/BillPayment.ts b/packages/server/src/models/BillPayment.ts
new file mode 100644
index 000000000..488f32793
--- /dev/null
+++ b/packages/server/src/models/BillPayment.ts
@@ -0,0 +1,144 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import ModelSetting from './ModelSetting';
+import BillPaymentSettings from './BillPayment.Settings';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import { DEFAULT_VIEWS } from '@/services/Sales/PaymentReceives/constants';
+import ModelSearchable from './ModelSearchable';
+
+export default class BillPayment extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'bills_payments';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['localAmount'];
+  }
+
+  /**
+   * Payment amount in local currency.
+   * @returns {number}
+   */
+  get localAmount() {
+    return this.amount * this.exchangeRate;
+  }
+
+  /**
+   * Model settings.
+   */
+  static get meta() {
+    return BillPaymentSettings;
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const BillPaymentEntry = require('models/BillPaymentEntry');
+    const AccountTransaction = require('models/AccountTransaction');
+    const Vendor = require('models/Vendor');
+    const Account = require('models/Account');
+    const Branch = require('models/Branch');
+
+    return {
+      entries: {
+        relation: Model.HasManyRelation,
+        modelClass: BillPaymentEntry.default,
+        join: {
+          from: 'bills_payments.id',
+          to: 'bills_payments_entries.billPaymentId',
+        },
+        filter: (query) => {
+          query.orderBy('index', 'ASC');
+        },
+      },
+
+      vendor: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Vendor.default,
+        join: {
+          from: 'bills_payments.vendorId',
+          to: 'contacts.id',
+        },
+        filter(query) {
+          query.where('contact_service', 'vendor');
+        },
+      },
+
+      paymentAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'bills_payments.paymentAccountId',
+          to: 'accounts.id',
+        },
+      },
+
+      transactions: {
+        relation: Model.HasManyRelation,
+        modelClass: AccountTransaction.default,
+        join: {
+          from: 'bills_payments.id',
+          to: 'accounts_transactions.referenceId',
+        },
+        filter(builder) {
+          builder.where('reference_type', 'BillPayment');
+        },
+      },
+
+      /**
+       * Bill payment may belongs to branch.
+       */
+      branch: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Branch.default,
+        join: {
+          from: 'bills_payments.branchId',
+          to: 'branches.id',
+        },
+      },
+    };
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model search attributes.
+   */
+  static get searchRoles() {
+    return [
+      { fieldKey: 'payment_number', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'reference_no', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'amount', comparator: 'equals' },
+    ];
+  }
+
+  /**
+   * Prevents mutate base currency since the model is not empty.
+   */
+  static get preventMutateBaseCurrency() {
+    return true;
+  }
+}
diff --git a/packages/server/src/models/BillPaymentEntry.ts b/packages/server/src/models/BillPaymentEntry.ts
new file mode 100644
index 000000000..4600eebb0
--- /dev/null
+++ b/packages/server/src/models/BillPaymentEntry.ts
@@ -0,0 +1,45 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class BillPaymentEntry extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'bills_payments_entries';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return [];
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Bill = require('models/Bill');
+    const BillPayment = require('models/BillPayment');
+
+    return {
+      payment: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: BillPayment.default,
+        join: {
+          from: 'bills_payments_entries.billPaymentId',
+          to: 'bills_payments.id',
+        },
+      },
+      bill: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Bill.default,
+        join: {
+          from: 'bills_payments_entries.billId',
+          to: 'bills.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/Branch.ts b/packages/server/src/models/Branch.ts
new file mode 100644
index 000000000..d8097a45d
--- /dev/null
+++ b/packages/server/src/models/Branch.ts
@@ -0,0 +1,172 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class Branch extends TenantModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'branches';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Filters accounts by the given ids.
+       * @param {Query} query
+       * @param {number[]} accountsIds
+       */
+      isPrimary(query) {
+        query.where('primary', true);
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const SaleInvoice = require('models/SaleInvoice');
+    const SaleEstimate = require('models/SaleEstimate');
+    const SaleReceipt = require('models/SaleReceipt');
+    const Bill = require('models/Bill');
+    const PaymentReceive = require('models/PaymentReceive');
+    const PaymentMade = require('models/BillPayment');
+    const VendorCredit = require('models/VendorCredit');
+    const CreditNote = require('models/CreditNote');
+    const AccountTransaction = require('models/AccountTransaction');
+    const InventoryTransaction = require('models/InventoryTransaction');
+
+    return {
+      /**
+       * Branch may belongs to associated sale invoices.
+       */
+      invoices: {
+        relation: Model.HasManyRelation,
+        modelClass: SaleInvoice.default,
+        join: {
+          from: 'branches.id',
+          to: 'sales_invoices.branchId',
+        },
+      },
+
+      /**
+       * Branch may belongs to associated sale estimates.
+       */
+      estimates: {
+        relation: Model.HasManyRelation,
+        modelClass: SaleEstimate.default,
+        join: {
+          from: 'branches.id',
+          to: 'sales_estimates.branchId',
+        },
+      },
+
+      /**
+       * Branch may belongs to associated sale receipts.
+       */
+      receipts: {
+        relation: Model.HasManyRelation,
+        modelClass: SaleReceipt.default,
+        join: {
+          from: 'branches.id',
+          to: 'sales_receipts.branchId',
+        },
+      },
+
+      /**
+       * Branch may belongs to associated payment receives.
+       */
+      paymentReceives: {
+        relation: Model.HasManyRelation,
+        modelClass: PaymentReceive.default,
+        join: {
+          from: 'branches.id',
+          to: 'payment_receives.branchId',
+        },
+      },
+
+      /**
+       * Branch may belongs to assocaited bills.
+       */
+      bills: {
+        relation: Model.HasManyRelation,
+        modelClass: Bill.default,
+        join: {
+          from: 'branches.id',
+          to: 'bills.branchId',
+        },
+      },
+
+      /**
+       * Branch may belongs to associated payment mades.
+       */
+      paymentMades: {
+        relation: Model.HasManyRelation,
+        modelClass: PaymentMade.default,
+        join: {
+          from: 'branches.id',
+          to: 'bills_payments.branchId',
+        },
+      },
+
+      /**
+       * Branch may belongs to associated credit notes.
+       */
+      creditNotes: {
+        relation: Model.HasManyRelation,
+        modelClass: CreditNote.default,
+        join: {
+          from: 'branches.id',
+          to: 'credit_notes.branchId',
+        },
+      },
+
+      /**
+       * Branch may belongs to associated to vendor credits.
+       */
+      vendorCredit: {
+        relation: Model.HasManyRelation,
+        modelClass: VendorCredit.default,
+        join: {
+          from: 'branches.id',
+          to: 'vendor_credits.branchId',
+        },
+      },
+
+      /**
+       * Branch may belongs to associated to accounts transactions.
+       */
+      accountsTransactions: {
+        relation: Model.HasManyRelation,
+        modelClass: AccountTransaction.default,
+        join: {
+          from: 'branches.id',
+          to: 'accounts_transactions.branchId',
+        },
+      },
+
+      /**
+       * Branch may belongs to associated to inventory transactions.
+       */
+      inventoryTransactions: {
+        relation: Model.HasManyRelation,
+        modelClass: InventoryTransaction.default,
+        join: {
+          from: 'branches.id',
+          to: 'inventory_transactions.branchId',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/CashflowAccount.Settings.ts b/packages/server/src/models/CashflowAccount.Settings.ts
new file mode 100644
index 000000000..453f2dbbf
--- /dev/null
+++ b/packages/server/src/models/CashflowAccount.Settings.ts
@@ -0,0 +1,54 @@
+
+export default {
+  defaultFilterField: 'name',
+  defaultSort: {
+    sortOrder: 'DESC',
+    sortField: 'name',
+  },
+  fields: {
+    name: {
+      name: 'account.field.name',
+      column: 'name',
+      fieldType: 'text',
+    },
+    description: {
+      name: 'account.field.description',
+      column: 'description',
+      fieldType: 'text',
+    },
+    slug: {
+      name: 'account.field.slug',
+      column: 'slug',
+      fieldType: 'text',
+      columnable: false,
+      filterable: false,
+    },
+    code: {
+      name: 'account.field.code',
+      column: 'code',
+      fieldType: 'text',
+    },
+    active: {
+      name: 'account.field.active',
+      column: 'active',
+      fieldType: 'boolean',
+      filterable: false,
+    },
+    balance: {
+      name: 'account.field.balance',
+      column: 'amount',
+      fieldType: 'number',
+    },
+    currency: {
+      name: 'account.field.currency',
+      column: 'currency_code',
+      fieldType: 'text',
+      filterable: false,
+    },
+    created_at: {
+      name: 'account.field.created_at',
+      column: 'created_at',
+      fieldType: 'date',
+    },
+  },
+};
\ No newline at end of file
diff --git a/packages/server/src/models/CashflowAccount.ts b/packages/server/src/models/CashflowAccount.ts
new file mode 100644
index 000000000..132832bca
--- /dev/null
+++ b/packages/server/src/models/CashflowAccount.ts
@@ -0,0 +1,132 @@
+/* eslint-disable global-require */
+import { mixin, Model } from 'objection';
+import { castArray } from 'lodash';
+import TenantModel from 'models/TenantModel';
+import AccountTypesUtils from '@/lib/AccountTypes';
+import CashflowAccountSettings from './CashflowAccount.Settings';
+import ModelSettings from './ModelSetting';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import { DEFAULT_VIEWS } from '@/services/Accounts/constants';
+import ModelSearchable from './ModelSearchable';
+
+export default class CashflowAccount extends mixin(TenantModel, [
+  ModelSettings,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'accounts';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  static get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['accountTypeLabel'];
+  }
+
+  /**
+   * Retrieve account type label.
+   */
+  get accountTypeLabel() {
+    return AccountTypesUtils.getType(this.accountType, 'label');
+  }
+
+  /**
+   * Allows to mark model as resourceable to viewable and filterable.
+   */
+  static get resourceable() {
+    return true;
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Inactive/Active mode.
+       */
+      inactiveMode(query, active = false) {
+        query.where('accounts.active', !active);
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const AccountTransaction = require('models/AccountTransaction');
+
+    return {
+      /**
+       * Account model may has many transactions.
+       */
+      transactions: {
+        relation: Model.HasManyRelation,
+        modelClass: AccountTransaction.default,
+        join: {
+          from: 'accounts.id',
+          to: 'accounts_transactions.accountId',
+        },
+      },
+    };
+  }
+
+  /**
+   * Detarmines whether the given type equals the account type.
+   * @param {string} accountType
+   * @return {boolean}
+   */
+  isAccountType(accountType) {
+    const types = castArray(accountType);
+    return types.indexOf(this.accountType) !== -1;
+  }
+
+  /**
+   * Detarmine whether the given parent type equals the account type.
+   * @param {string} parentType
+   * @return {boolean}
+   */
+  isParentType(parentType) {
+    return AccountTypesUtils.isParentTypeEqualsKey(
+      this.accountType,
+      parentType
+    );
+  }
+
+  /**
+   * Model settings.
+   */
+  static get meta() {
+    return CashflowAccountSettings;
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model search roles.
+   */
+  static get searchRoles() {
+    return [
+      { condition: 'or', fieldKey: 'name', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'code', comparator: 'like' },
+    ];
+  }
+}
diff --git a/packages/server/src/models/CashflowTransaction.ts b/packages/server/src/models/CashflowTransaction.ts
new file mode 100644
index 000000000..6d6ffcc9b
--- /dev/null
+++ b/packages/server/src/models/CashflowTransaction.ts
@@ -0,0 +1,148 @@
+/* eslint-disable global-require */
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+import {
+  getCashflowAccountTransactionsTypes,
+  getCashflowTransactionType,
+} from '@/services/Cashflow/utils';
+import AccountTransaction from './AccountTransaction';
+import { CASHFLOW_DIRECTION } from '@/services/Cashflow/constants';
+
+export default class CashflowTransaction extends TenantModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'cashflow_transactions';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  static get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return [
+      'localAmount',
+      'transactionTypeFormatted',
+      'isPublished',
+      'typeMeta',
+      'isCashCredit',
+      'isCashDebit',
+    ];
+  }
+
+  /**
+   * Retrieves the local amount of cashflow transaction.
+   * @returns {number}
+   */
+  get localAmount() {
+    return this.amount * this.exchangeRate;
+  }
+
+  /**
+   * Detarmines whether the cashflow transaction is published.
+   * @return {boolean}
+   */
+  get isPublished() {
+    return !!this.publishedAt;
+  }
+
+  /**
+   * Transaction type formatted.
+   */
+  get transactionTypeFormatted() {
+    return AccountTransaction.getReferenceTypeFormatted(this.transactionType);
+  }
+
+  get typeMeta() {
+    return getCashflowTransactionType(this.transactionType);
+  }
+
+  /**
+   * Detarmines whether the cashflow transaction cash credit type.
+   * @returns {boolean}
+   */
+  get isCashCredit() {
+    return this.typeMeta?.direction === CASHFLOW_DIRECTION.OUT;
+  }
+
+  /**
+   * Detarmines whether the cashflow transaction cash debit type.
+   * @returns {boolean}
+   */
+  get isCashDebit() {
+    return this.typeMeta?.direction === CASHFLOW_DIRECTION.IN;
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const CashflowTransactionLine = require('models/CashflowTransactionLine');
+    const AccountTransaction = require('models/AccountTransaction');
+    const Account = require('models/Account');
+
+    return {
+      /**
+       * Cashflow transaction entries.
+       */
+      entries: {
+        relation: Model.HasManyRelation,
+        modelClass: CashflowTransactionLine.default,
+        join: {
+          from: 'cashflow_transactions.id',
+          to: 'cashflow_transaction_lines.cashflowTransactionId',
+        },
+        filter: (query) => {
+          query.orderBy('index', 'ASC');
+        },
+      },
+
+      /**
+       * Cashflow transaction has associated account transactions.
+       */
+      transactions: {
+        relation: Model.HasManyRelation,
+        modelClass: AccountTransaction.default,
+        join: {
+          from: 'cashflow_transactions.id',
+          to: 'accounts_transactions.referenceId',
+        },
+        filter(builder) {
+          const referenceTypes = getCashflowAccountTransactionsTypes();
+          builder.whereIn('reference_type', referenceTypes);
+        },
+      },
+
+      /**
+       * Cashflow transaction may has assocaited cashflow account.
+       */
+      cashflowAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'cashflow_transactions.cashflowAccountId',
+          to: 'accounts.id',
+        },
+      },
+
+      /**
+       * Cashflow transcation may has associated to credit account.
+       */
+      creditAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'cashflow_transactions.creditAccountId',
+          to: 'accounts.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/CashflowTransactionLine.ts b/packages/server/src/models/CashflowTransactionLine.ts
new file mode 100644
index 000000000..4be809cc8
--- /dev/null
+++ b/packages/server/src/models/CashflowTransactionLine.ts
@@ -0,0 +1,45 @@
+/* eslint-disable global-require */
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class CashflowTransactionLine extends TenantModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'cashflow_transaction_lines';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  static get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Account = require('models/Account');
+
+    return {
+      cashflowAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'cashflow_transaction_lines.cashflowAccountId',
+          to: 'accounts.id',
+        },
+      },
+      creditAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'cashflow_transaction_lines.creditAccountId',
+          to: 'accounts.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/Contact.ts b/packages/server/src/models/Contact.ts
new file mode 100644
index 000000000..d63a2ea60
--- /dev/null
+++ b/packages/server/src/models/Contact.ts
@@ -0,0 +1,201 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class Contact extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'contacts';
+  }
+
+  /**
+   * Model timestamps.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Defined virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['contactNormal', 'closingBalance', 'formattedContactService'];
+  }
+
+  /**
+   * Retrieve the contact normal by the given contact type.
+   */
+  static getContactNormalByType(contactType) {
+    const types = {
+      vendor: 'credit',
+      customer: 'debit',
+    };
+    return types[contactType];
+  }
+
+  /**
+   * Retrieve the contact normal by the given contact service.
+   * @param {string} contactService
+   */
+  static getFormattedContactService(contactService) {
+    const types = {
+      customer: 'Customer',
+      vendor: 'Vendor',
+    };
+    return types[contactService];
+  }
+
+  /**
+   * Retrieve the contact normal.
+   */
+  get contactNormal() {
+    return Contact.getContactNormalByType(this.contactService);
+  }
+
+  /**
+   * Retrieve formatted contact service.
+   */
+  get formattedContactService() {
+    return Contact.getFormattedContactService(this.contactService);
+  }
+
+  /**
+   * Closing balance attribute.
+   */
+  get closingBalance() {
+    return this.balance;
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      filterContactIds(query, customerIds) {
+        query.whereIn('id', customerIds);
+      },
+
+      customer(query) {
+        query.where('contact_service', 'customer');
+      },
+
+      vendor(query) {
+        query.where('contact_service', 'vendor');
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const SaleEstimate = require('models/SaleEstimate');
+    const SaleReceipt = require('models/SaleReceipt');
+    const SaleInvoice = require('models/SaleInvoice');
+    const PaymentReceive = require('models/PaymentReceive');
+    const Bill = require('models/Bill');
+    const BillPayment = require('models/BillPayment');
+    const AccountTransaction = require('models/AccountTransaction');
+
+    return {
+      /**
+       * Contact may has many sales invoices.
+       */
+      salesInvoices: {
+        relation: Model.HasManyRelation,
+        modelClass: SaleInvoice.default,
+        join: {
+          from: 'contacts.id',
+          to: 'sales_invoices.customerId',
+        },
+      },
+
+      /**
+       * Contact may has many sales estimates.
+       */
+      salesEstimates: {
+        relation: Model.HasManyRelation,
+        modelClass: SaleEstimate.default,
+        join: {
+          from: 'contacts.id',
+          to: 'sales_estimates.customerId',
+        },
+      },
+
+      /**
+       * Contact may has many sales receipts.
+       */
+      salesReceipts: {
+        relation: Model.HasManyRelation,
+        modelClass: SaleReceipt.default,
+        join: {
+          from: 'contacts.id',
+          to: 'sales_receipts.customerId',
+        },
+      },
+
+      /**
+       * Contact may has many payments receives.
+       */
+      paymentReceives: {
+        relation: Model.HasManyRelation,
+        modelClass: PaymentReceive.default,
+        join: {
+          from: 'contacts.id',
+          to: 'payment_receives.customerId',
+        },
+      },
+
+      /**
+       * Contact may has many bills.
+       */
+      bills: {
+        relation: Model.HasManyRelation,
+        modelClass: Bill.default,
+        join: {
+          from: 'contacts.id',
+          to: 'bills.vendorId',
+        },
+      },
+
+      /**
+       * Contact may has many bills payments.
+       */
+      billPayments: {
+        relation: Model.HasManyRelation,
+        modelClass: BillPayment.default,
+        join: {
+          from: 'contacts.id',
+          to: 'bills_payments.vendorId',
+        },
+      },
+
+      /**
+       * Contact may has many accounts transactions.
+       */
+      accountsTransactions: {
+        relation: Model.HasManyRelation,
+        modelClass: AccountTransaction.default,
+        join: {
+          from: 'contacts.id',
+          to: 'accounts_transactions.contactId',
+        },
+      },
+    };
+  }
+
+  static get fields() {
+    return {
+      contact_service: {
+        column: 'contact_service',
+      },
+      display_name: {
+        column: 'display_name',
+      },
+      created_at: {
+        column: 'created_at',
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/CreditNote.Meta.ts b/packages/server/src/models/CreditNote.Meta.ts
new file mode 100644
index 000000000..1cfc2bed9
--- /dev/null
+++ b/packages/server/src/models/CreditNote.Meta.ts
@@ -0,0 +1,80 @@
+function StatusFieldFilterQuery(query, role) {
+  query.modify('filterByStatus', role.value);
+}
+
+function StatusFieldSortQuery(query, role) {
+  query.modify('sortByStatus', role.order);
+}
+
+export default {
+  defaultFilterField: 'name',
+  defaultSort: {
+    sortOrder: 'DESC',
+    sortField: 'name',
+  },
+  fields: {
+    customer: {
+      name: 'credit_note.field.customer',
+      column: 'customer_id',
+      fieldType: 'relation',
+
+      relationType: 'enumeration',
+      relationKey: 'customer',
+
+      relationEntityLabel: 'display_name',
+      relationEntityKey: 'id',
+    },
+    credit_date: {
+      name: 'credit_note.field.credit_note_date',
+      column: 'credit_note_date',
+      fieldType: 'date',
+    },
+    credit_number: {
+      name: 'credit_note.field.credit_note_number',
+      column: 'credit_note_number',
+      fieldType: 'text',
+    },
+    reference_no: {
+      name: 'credit_note.field.reference_no',
+      column: 'reference_no',
+      fieldType: 'text',
+    },
+    amount: {
+      name: 'credit_note.field.amount',
+      column: 'amount',
+      fieldType: 'number',
+    },
+    currency_code: {
+      name: 'credit_note.field.currency_code',
+      column: 'currency_code',
+      fieldType: 'number',
+    },
+    note: {
+      name: 'credit_note.field.note',
+      column: 'note',
+      fieldType: 'text',
+    },
+    terms_conditions: {
+      name: 'credit_note.field.terms_conditions',
+      column: 'terms_conditions',
+      fieldType: 'text',
+    },
+    status: {
+      name: 'credit_note.field.status',
+      fieldType: 'enumeration',
+      options: [
+        { key: 'draft', label: 'credit_note.field.status.draft' },
+        { key: 'published', label: 'credit_note.field.status.published' },
+        { key: 'open', label: 'credit_note.field.status.open' },
+        { key: 'closed', label: 'credit_note.field.status.closed' },
+      ],
+      filterCustomQuery: StatusFieldFilterQuery,
+      sortCustomQuery: StatusFieldSortQuery,
+    },
+    created_at: {
+      name: 'credit_note.field.created_at',
+      column: 'created_at',
+      fieldType: 'date',
+    },
+  },
+};
diff --git a/packages/server/src/models/CreditNote.ts b/packages/server/src/models/CreditNote.ts
new file mode 100644
index 000000000..f9b901397
--- /dev/null
+++ b/packages/server/src/models/CreditNote.ts
@@ -0,0 +1,278 @@
+import { mixin, Model, raw } from 'objection';
+import TenantModel from 'models/TenantModel';
+import ModelSetting from './ModelSetting';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import { DEFAULT_VIEWS } from '@/services/CreditNotes/constants';
+import ModelSearchable from './ModelSearchable';
+import CreditNoteMeta from './CreditNote.Meta';
+
+export default class CreditNote extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'credit_notes';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return [
+      'localAmount',
+      'isDraft',
+      'isPublished',
+      'isOpen',
+      'isClosed',
+      'creditsRemaining',
+      'creditsUsed',
+    ];
+  }
+
+  /**
+   * Credit note amount in local currency.
+   * @returns {number}
+   */
+  get localAmount() {
+    return this.amount * this.exchangeRate;
+  }
+
+  /**
+   * Detarmines whether the credit note is draft.
+   * @returns {boolean}
+   */
+  get isDraft() {
+    return !this.openedAt;
+  }
+
+  /**
+   * Detarmines whether vendor credit is published.
+   * @returns {boolean}
+   */
+  get isPublished() {
+    return !!this.openedAt;
+  }
+
+  /**
+   * Detarmines whether the credit note is open.
+   * @return {boolean}
+   */
+  get isOpen() {
+    return !!this.openedAt && this.creditsRemaining > 0;
+  }
+
+  /**
+   * Detarmines whether the credit note is closed.
+   * @return {boolean}
+   */
+  get isClosed() {
+    return this.openedAt && this.creditsRemaining === 0;
+  }
+
+  /**
+   * Retrieve the credits remaining.
+   */
+  get creditsRemaining() {
+    return Math.max(this.amount - this.refundedAmount - this.invoicesAmount, 0);
+  }
+
+  get creditsUsed() {
+    return this.refundedAmount + this.invoicesAmount;
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Filters the credit notes in draft status.
+       */
+      draft(query) {
+        query.where('opened_at', null);
+      },
+
+      /**
+       * Filters the.
+       */
+      published(query) {
+        query.whereNot('opened_at', null);
+      },
+
+      /**
+       * Filters the open credit notes.
+       */
+      open(query) {
+        query
+          .where(
+            raw(`COALESCE(REFUNDED_AMOUNT) + COALESCE(INVOICES_AMOUNT) <
+            COALESCE(AMOUNT)`)
+          )
+          .modify('published');
+      },
+
+      /**
+       * Filters the closed credit notes.
+       */
+      closed(query) {
+        query
+          .where(
+            raw(`COALESCE(REFUNDED_AMOUNT) + COALESCE(INVOICES_AMOUNT) =
+            COALESCE(AMOUNT)`)
+          )
+          .modify('published');
+      },
+
+      /**
+       * Status filter.
+       */
+      filterByStatus(query, filterType) {
+        switch (filterType) {
+          case 'draft':
+            query.modify('draft');
+            break;
+          case 'published':
+            query.modify('published');
+            break;
+          case 'open':
+          default:
+            query.modify('open');
+            break;
+          case 'closed':
+            query.modify('closed');
+            break;
+        }
+      },
+
+      /**
+       *
+       */
+      sortByStatus(query, order) {
+        query.orderByRaw(
+          `COALESCE(REFUNDED_AMOUNT) + COALESCE(INVOICES_AMOUNT) = COALESCE(AMOUNT) ${order}`
+        );
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const AccountTransaction = require('models/AccountTransaction');
+    const ItemEntry = require('models/ItemEntry');
+    const Customer = require('models/Customer');
+    const Branch = require('models/Branch');
+
+    return {
+      /**
+       * Credit note associated entries.
+       */
+      entries: {
+        relation: Model.HasManyRelation,
+        modelClass: ItemEntry.default,
+        join: {
+          from: 'credit_notes.id',
+          to: 'items_entries.referenceId',
+        },
+        filter(builder) {
+          builder.where('reference_type', 'CreditNote');
+          builder.orderBy('index', 'ASC');
+        },
+      },
+
+      /**
+       * Belongs to customer model.
+       */
+      customer: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Customer.default,
+        join: {
+          from: 'credit_notes.customerId',
+          to: 'contacts.id',
+        },
+        filter(query) {
+          query.where('contact_service', 'Customer');
+        },
+      },
+
+      /**
+       * Credit note associated GL entries.
+       */
+      transactions: {
+        relation: Model.HasManyRelation,
+        modelClass: AccountTransaction.default,
+        join: {
+          from: 'credit_notes.id',
+          to: 'accounts_transactions.referenceId',
+        },
+        filter(builder) {
+          builder.where('reference_type', 'CreditNote');
+        },
+      },
+
+      /**
+       * Credit note may belongs to branch.
+       */
+      branch: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Branch.default,
+        join: {
+          from: 'credit_notes.branchId',
+          to: 'branches.id',
+        },
+      },
+    };
+  }
+
+  /**
+   * Sale invoice meta.
+   */
+  static get meta() {
+    return CreditNoteMeta;
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model searchable.
+   */
+  static get searchable() {
+    return true;
+  }
+
+  /**
+   * Model search attributes.
+   */
+  static get searchRoles() {
+    return [
+      { fieldKey: 'credit_number', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'reference_no', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'amount', comparator: 'equals' },
+    ];
+  }
+
+  /**
+   * Prevents mutate base currency since the model is not empty.
+   * @returns {boolean}
+   */
+  static get preventMutateBaseCurrency() {
+    return true;
+  }
+}
diff --git a/packages/server/src/models/CreditNoteAppliedInvoice.ts b/packages/server/src/models/CreditNoteAppliedInvoice.ts
new file mode 100644
index 000000000..1f88de105
--- /dev/null
+++ b/packages/server/src/models/CreditNoteAppliedInvoice.ts
@@ -0,0 +1,53 @@
+import { mixin, Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+import ModelSetting from './ModelSetting';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import ModelSearchable from './ModelSearchable';
+
+export default class CreditNoteAppliedInvoice extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'credit_note_applied_invoice';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const SaleInvoice = require('models/SaleInvoice');
+    const CreditNote = require('models/CreditNote');
+
+    return {
+      saleInvoice: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: SaleInvoice.default,
+        join: {
+          from: 'credit_note_applied_invoice.invoiceId',
+          to: 'sales_invoices.id',
+        },
+      },
+
+      creditNote: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: CreditNote.default,
+        join: {
+          from: 'credit_note_applied_invoice.creditNoteId',
+          to: 'credit_notes.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/CreditNoteAppliedInvoiceEntry.ts b/packages/server/src/models/CreditNoteAppliedInvoiceEntry.ts
new file mode 100644
index 000000000..7f3fee75f
--- /dev/null
+++ b/packages/server/src/models/CreditNoteAppliedInvoiceEntry.ts
@@ -0,0 +1,25 @@
+import { mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import ModelSetting from './ModelSetting';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import ModelSearchable from './ModelSearchable';
+
+export default class CreditNoteAppliedInvoiceEntry extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'credit_associated_transaction_entry';
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    return {};
+  }
+}
diff --git a/packages/server/src/models/Currency.ts b/packages/server/src/models/Currency.ts
new file mode 100644
index 000000000..fe091dd67
--- /dev/null
+++ b/packages/server/src/models/Currency.ts
@@ -0,0 +1,21 @@
+import TenantModel from 'models/TenantModel';
+
+export default class Currency extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'currencies';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  static get resourceable() {
+    return true;
+  }
+}
diff --git a/packages/server/src/models/CustomViewBaseModel.ts b/packages/server/src/models/CustomViewBaseModel.ts
new file mode 100644
index 000000000..a54520023
--- /dev/null
+++ b/packages/server/src/models/CustomViewBaseModel.ts
@@ -0,0 +1,20 @@
+export default (Model) =>
+  class CustomViewBaseModel extends Model {
+    /**
+     * Retrieve the default custom views, roles and columns.
+     */
+    static get defaultViews() {
+      return [];
+    }
+
+    /**
+     * Retrieve the default view by the given slug.
+     */
+    static getDefaultViewBySlug(viewSlug) {
+      return this.defaultViews.find((view) => view.slug === viewSlug) || null;
+    }
+
+    static getDefaultViews() {
+      return this.defaultViews;
+    }
+  };
diff --git a/packages/server/src/models/Customer.Settings.ts b/packages/server/src/models/Customer.Settings.ts
new file mode 100644
index 000000000..1d22941cf
--- /dev/null
+++ b/packages/server/src/models/Customer.Settings.ts
@@ -0,0 +1,92 @@
+export default {
+  fields: {
+    first_name: {
+      name: 'customer.field.first_name',
+      column: 'first_name',
+      fieldType: 'text',
+    },
+    last_name: {
+      name: 'customer.field.last_name',
+      column: 'last_name',
+      fieldType: 'text',
+    },
+    display_name: {
+      name: 'customer.field.display_name',
+      column: 'display_name',
+      fieldType: 'text',
+    },
+    email: {
+      name: 'customer.field.email',
+      column: 'email',
+      fieldType: 'text',
+    },
+    work_phone: {
+      name: 'customer.field.work_phone',
+      column: 'work_phone',
+      fieldType: 'text',
+    },
+    personal_phone: {
+      name: 'customer.field.personal_phone',
+      column: 'personal_phone',
+      fieldType: 'text',
+    },
+    company_name: {
+      name: 'customer.field.company_name',
+      column: 'company_name',
+      fieldType: 'text',
+    },
+    website: {
+      name: 'customer.field.website',
+      column: 'website',
+      fieldType: 'text',
+    },
+    created_at: {
+      name: 'customer.field.created_at',
+      column: 'created_at',
+      fieldType: 'date',
+    },
+    balance: {
+      name: 'customer.field.balance',
+      column: 'balance',
+      fieldType: 'number',
+    },
+    opening_balance: {
+      name: 'customer.field.opening_balance',
+      column: 'opening_balance',
+      fieldType: 'number',
+    },
+    opening_balance_at: {
+      name: 'customer.field.opening_balance_at',
+      column: 'opening_balance_at',
+      filterable: false,
+      fieldType: 'date',
+    },
+    currency_code: {
+      name: 'customer.field.currency',
+      column: 'currency_code',
+      fieldType: 'text',
+    },
+    status: {
+      name: 'customer.field.status',
+      fieldType: 'enumeration',
+      options: [
+        { key: 'active', label: 'customer.field.status.active' },
+        { key: 'inactive', label: 'customer.field.status.inactive' },
+        { key: 'overdue', label: 'customer.field.status.overdue' },
+        { key: 'unpaid', label: 'customer.field.status.unpaid' },
+      ],
+      filterCustomQuery: statusFieldFilterQuery,
+    },
+  },
+};
+
+function statusFieldFilterQuery(query, role) {
+  switch (role.value) {
+    case 'overdue':
+      query.modify('overdue');
+      break;
+    case 'unpaid':
+      query.modify('unpaid');
+      break;
+  }
+}
diff --git a/packages/server/src/models/Customer.ts b/packages/server/src/models/Customer.ts
new file mode 100644
index 000000000..690b77d55
--- /dev/null
+++ b/packages/server/src/models/Customer.ts
@@ -0,0 +1,180 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import PaginationQueryBuilder from './Pagination';
+import ModelSetting from './ModelSetting';
+import CustomerSettings from './Customer.Settings';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import { DEFAULT_VIEWS } from '@/services/Contacts/Customers/constants';
+import ModelSearchable from './ModelSearchable';
+
+class CustomerQueryBuilder extends PaginationQueryBuilder {
+  constructor(...args) {
+    super(...args);
+
+    this.onBuild((builder) => {
+      if (builder.isFind() || builder.isDelete() || builder.isUpdate()) {
+        builder.where('contact_service', 'customer');
+      }
+    });
+  }
+}
+
+export default class Customer extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Query builder.
+   */
+  static get QueryBuilder() {
+    return CustomerQueryBuilder;
+  }
+
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'contacts';
+  }
+
+  /**
+   * Model timestamps.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Defined virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['localOpeningBalance', 'closingBalance', 'contactNormal'];
+  }
+
+  /**
+   * Closing balance attribute.
+   */
+  get closingBalance() {
+    return this.balance;
+  }
+
+  /**
+   * Retrieves the local opening balance.
+   * @returns {number}
+   */
+  get localOpeningBalance() {
+    return this.openingBalance
+      ? this.openingBalance * this.openingBalanceExchangeRate
+      : 0;
+  }
+
+  /**
+   * Retrieve the contact noraml;
+   */
+  get contactNormal() {
+    return 'debit';
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Inactive/Active mode.
+       */
+      inactiveMode(query, active = false) {
+        query.where('active', !active);
+      },
+
+      /**
+       * Filters the active customers.
+       */
+      active(query) {
+        query.where('active', 1);
+      },
+      /**
+       * Filters the inactive customers.
+       */
+      inactive(query) {
+        query.where('active', 0);
+      },
+      /**
+       * Filters the customers that have overdue invoices.
+       */
+      overdue(query) {
+        query.select(
+          '*',
+          Customer.relatedQuery('overDueInvoices', query.knex())
+            .count()
+            .as('countOverdue')
+        );
+        query.having('countOverdue', '>', 0);
+      },
+      /**
+       * Filters the unpaid customers.
+       */
+      unpaid(query) {
+        query.whereRaw('`BALANCE` + `OPENING_BALANCE` <> 0');
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const SaleInvoice = require('models/SaleInvoice');
+
+    return {
+      salesInvoices: {
+        relation: Model.HasManyRelation,
+        modelClass: SaleInvoice.default,
+        join: {
+          from: 'contacts.id',
+          to: 'sales_invoices.customerId',
+        },
+      },
+
+      overDueInvoices: {
+        relation: Model.HasManyRelation,
+        modelClass: SaleInvoice.default,
+        join: {
+          from: 'contacts.id',
+          to: 'sales_invoices.customerId',
+        },
+        filter: (query) => {
+          query.modify('overdue');
+        },
+      },
+    };
+  }
+
+  static get meta() {
+    return CustomerSettings;
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model search attributes.
+   */
+  static get searchRoles() {
+    return [
+      { fieldKey: 'display_name', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'first_name', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'last_name', comparator: 'equals' },
+      { condition: 'or', fieldKey: 'company_name', comparator: 'equals' },
+      { condition: 'or', fieldKey: 'email', comparator: 'equals' },
+      { condition: 'or', fieldKey: 'work_phone', comparator: 'equals' },
+      { condition: 'or', fieldKey: 'personal_phone', comparator: 'equals' },
+      { condition: 'or', fieldKey: 'website', comparator: 'equals' },
+    ];
+  }
+}
diff --git a/packages/server/src/models/DateSession.ts b/packages/server/src/models/DateSession.ts
new file mode 100644
index 000000000..14f981ee7
--- /dev/null
+++ b/packages/server/src/models/DateSession.ts
@@ -0,0 +1,34 @@
+import moment from 'moment';
+
+export default (Model) => {
+  return class DateSession extends Model {
+
+    get timestamps() {
+      return ['createdAt', 'updatedAt'];
+    }
+
+    $beforeUpdate(opt, context) {
+      const maybePromise = super.$beforeUpdate(opt, context);
+
+      return Promise.resolve(maybePromise).then(() => {
+        const key = this.timestamps[1];
+
+        if (key && !this[key]) {
+          this[key] = moment().format('YYYY/MM/DD HH:mm:ss');
+        }
+      });
+    }
+
+    $beforeInsert(context) {
+      const maybePromise = super.$beforeInsert(context);
+
+      return Promise.resolve(maybePromise).then(() => {
+        const key = this.timestamps[0];
+
+        if (key && !this[key]) {
+          this[key] = moment().format('YYYY/MM/DD HH:mm:ss');
+        }
+      });
+    }
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/models/ExchangeRate.ts b/packages/server/src/models/ExchangeRate.ts
new file mode 100644
index 000000000..c0e4c2939
--- /dev/null
+++ b/packages/server/src/models/ExchangeRate.ts
@@ -0,0 +1,44 @@
+import bcrypt from 'bcryptjs';
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class ExchangeRate extends TenantModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'exchange_rates';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Model defined fields.
+   */
+  static get fields(){
+    return {
+      currency_code: {
+        label: 'Currency',
+        column: 'currency_code'
+      },
+      exchange_rate: {
+        label: 'Exchange rate',
+        column: 'exchange_rate',
+      },
+      date: {
+        label: 'Date',
+        column: 'date',
+      },
+      created_at: {
+        label: "Created at",
+        column: "created_at",
+        columnType: "date",
+      },
+    }
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/models/Expense.Settings.ts b/packages/server/src/models/Expense.Settings.ts
new file mode 100644
index 000000000..0d8ea8712
--- /dev/null
+++ b/packages/server/src/models/Expense.Settings.ts
@@ -0,0 +1,71 @@
+/**
+ * Expense - Settings.
+ */
+export default {
+  defaultFilterField: 'description',
+  defaultSort: {
+    sortOrder: 'DESC',
+    sortField: 'name',
+  },
+  fields: {
+    'payment_date': {
+      name: 'expense.field.payment_date',
+      column: 'payment_date',
+      fieldType: 'date',
+    },
+    'payment_account': {
+      name: 'expense.field.payment_account',
+      column: 'payment_account_id',
+      fieldType: 'relation',
+
+      relationType: 'enumeration',
+      relationKey: 'paymentAccount',
+
+      relationEntityLabel: 'name',
+      relationEntityKey: 'slug',
+    },
+    'amount': {
+      name: 'expense.field.amount',
+      column: 'total_amount',
+      fieldType: 'number',
+    },
+    'reference_no': {
+      name: 'expense.field.reference_no',
+      column: 'reference_no',
+      fieldType: 'text',
+    },
+    'description': {
+      name: 'expense.field.description',
+      column: 'description',
+      fieldType: 'text',
+    },
+    'published': {
+      name: 'expense.field.published',
+      column: 'published_at',
+      fieldType: 'date',
+    },
+    'status': {
+      name: 'expense.field.status',
+      fieldType: 'enumeration',
+      options: [
+        { label: 'expense.field.status.draft', key: 'draft' },
+        { label: 'expense.field.status.published', key: 'published' },
+      ],
+      filterCustomQuery: StatusFieldFilterQuery,
+      sortCustomQuery: StatusFieldSortQuery,
+    },
+    'created_at': {
+      name: 'expense.field.created_at',
+      column: 'created_at',
+      fieldType: 'date',
+    },
+  },
+};
+
+function StatusFieldFilterQuery(query, role) {
+  query.modify('filterByStatus', role.value);
+}
+
+function StatusFieldSortQuery(query, role) {
+  query.modify('sortByStatus', role.order);
+}
diff --git a/packages/server/src/models/Expense.ts b/packages/server/src/models/Expense.ts
new file mode 100644
index 000000000..ed756e2bb
--- /dev/null
+++ b/packages/server/src/models/Expense.ts
@@ -0,0 +1,263 @@
+import { Model, mixin, raw } from 'objection';
+import TenantModel from 'models/TenantModel';
+import { viewRolesBuilder } from '@/lib/ViewRolesBuilder';
+import ModelSetting from './ModelSetting';
+import ExpenseSettings from './Expense.Settings';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import { DEFAULT_VIEWS } from '@/services/Expenses/constants';
+import ModelSearchable from './ModelSearchable';
+import moment from 'moment';
+
+export default class Expense extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'expenses_transactions';
+  }
+
+  /**
+   * Account transaction reference type.
+   */
+  static get referenceType() {
+    return 'Expense';
+  }
+
+  /**
+   * Model timestamps.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return [
+      'isPublished',
+      'unallocatedCostAmount',
+      'localAmount',
+      'localLandedCostAmount',
+      'localUnallocatedCostAmount',
+      'localAllocatedCostAmount',
+      'billableAmount',
+    ];
+  }
+
+  /**
+   * Retrieves the local amount of expense.
+   * @returns {number}
+   */
+  get localAmount() {
+    return this.totalAmount * this.exchangeRate;
+  }
+
+  /**
+   * Rertieves the local landed cost amount of expense.
+   * @returns {number}
+   */
+  get localLandedCostAmount() {
+    return this.landedCostAmount * this.exchangeRate;
+  }
+
+  /**
+   * Retrieves the local allocated cost amount.
+   * @returns {number}
+   */
+  get localAllocatedCostAmount() {
+    return this.allocatedCostAmount * this.exchangeRate;
+  }
+
+  /**
+   * Retrieve the unallocated cost amount.
+   * @return {number}
+   */
+  get unallocatedCostAmount() {
+    return Math.max(this.totalAmount - this.allocatedCostAmount, 0);
+  }
+
+  /**
+   * Retrieves the local unallocated cost amount.
+   * @returns {number}
+   */
+  get localUnallocatedCostAmount() {
+    return this.unallocatedCostAmount * this.exchangeRate;
+  }
+
+  /**
+   * Detarmines whether the expense is published.
+   * @returns {boolean}
+   */
+  get isPublished() {
+    return Boolean(this.publishedAt);
+  }
+
+  /**
+   * Retrieves the calculated amount which have not been invoiced.
+   */
+  get billableAmount() {
+    return Math.max(this.totalAmount - this.invoicedAmount, 0);
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      filterByDateRange(query, startDate, endDate) {
+        if (startDate) {
+          query.where('date', '>=', startDate);
+        }
+        if (endDate) {
+          query.where('date', '<=', endDate);
+        }
+      },
+      filterByAmountRange(query, from, to) {
+        if (from) {
+          query.where('amount', '>=', from);
+        }
+        if (to) {
+          query.where('amount', '<=', to);
+        }
+      },
+      filterByExpenseAccount(query, accountId) {
+        if (accountId) {
+          query.where('expense_account_id', accountId);
+        }
+      },
+      filterByPaymentAccount(query, accountId) {
+        if (accountId) {
+          query.where('payment_account_id', accountId);
+        }
+      },
+      viewRolesBuilder(query, conditionals, expression) {
+        viewRolesBuilder(conditionals, expression)(query);
+      },
+
+      filterByDraft(query) {
+        query.where('published_at', null);
+      },
+
+      filterByPublished(query) {
+        query.whereNot('published_at', null);
+      },
+
+      filterByStatus(query, status) {
+        switch (status) {
+          case 'draft':
+            query.modify('filterByDraft');
+            break;
+          case 'published':
+          default:
+            query.modify('filterByPublished');
+            break;
+        }
+      },
+
+      publish(query) {
+        query.update({
+          publishedAt: moment().toMySqlDateTime(),
+        });
+      },
+
+      /**
+       * Filters the expenses have billable amount.
+       */
+      billable(query) {
+        query.where(raw('AMOUNT > INVOICED_AMOUNT'));
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Account = require('models/Account');
+    const ExpenseCategory = require('models/ExpenseCategory');
+    const Media = require('models/Media');
+    const Branch = require('models/Branch');
+
+    return {
+      paymentAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'expenses_transactions.paymentAccountId',
+          to: 'accounts.id',
+        },
+      },
+      categories: {
+        relation: Model.HasManyRelation,
+        modelClass: ExpenseCategory.default,
+        join: {
+          from: 'expenses_transactions.id',
+          to: 'expense_transaction_categories.expenseId',
+        },
+        filter: (query) => {
+          query.orderBy('index', 'ASC');
+        },
+      },
+
+      /**
+       * Expense transction may belongs to a branch.
+       */
+      branch: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Branch.default,
+        join: {
+          from: 'expenses_transactions.branchId',
+          to: 'branches.id',
+        },
+      },
+      media: {
+        relation: Model.ManyToManyRelation,
+        modelClass: Media.default,
+        join: {
+          from: 'expenses_transactions.id',
+          through: {
+            from: 'media_links.model_id',
+            to: 'media_links.media_id',
+          },
+          to: 'media.id',
+        },
+        filter(query) {
+          query.where('model_name', 'Expense');
+        },
+      },
+    };
+  }
+
+  static get meta() {
+    return ExpenseSettings;
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model search attributes.
+   */
+  static get searchRoles() {
+    return [
+      { fieldKey: 'reference_no', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'amount', comparator: 'equals' },
+    ];
+  }
+
+  /**
+   * Prevents mutate base currency since the model is not empty.
+   */
+  static get preventMutateBaseCurrency() {
+    return true;
+  }
+}
diff --git a/packages/server/src/models/ExpenseCategory.ts b/packages/server/src/models/ExpenseCategory.ts
new file mode 100644
index 000000000..50416805e
--- /dev/null
+++ b/packages/server/src/models/ExpenseCategory.ts
@@ -0,0 +1,44 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class ExpenseCategory extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'expense_transaction_categories';
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['unallocatedCostAmount'];
+  }
+
+  /**
+   * Remain unallocated landed cost.
+   * @return {number}
+   */
+  get unallocatedCostAmount() {
+    return Math.max(this.amount - this.allocatedCostAmount, 0);
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Account = require('models/Account');
+    
+    return {
+      expenseAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'expense_transaction_categories.expenseAccountId',
+          to: 'accounts.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/InventoryAdjustment.Settings.ts b/packages/server/src/models/InventoryAdjustment.Settings.ts
new file mode 100644
index 000000000..9ef90cbc5
--- /dev/null
+++ b/packages/server/src/models/InventoryAdjustment.Settings.ts
@@ -0,0 +1,59 @@
+export default {
+  defaultFilterField: 'date',
+  defaultSort: {
+    sortOrder: 'DESC',
+    sortField: 'date',
+  },
+  fields: {
+    date: {
+      name: 'inventory_adjustment.field.date',
+      column: 'date',
+      fieldType: 'date',
+    },
+    type: {
+      name: 'inventory_adjustment.field.type',
+      column: 'type',
+      fieldType: 'enumeration',
+      options: [
+        { key: 'increment', name: 'inventory_adjustment.field.type.increment' },
+        { key: 'decrement', name: 'inventory_adjustment.field.type.decrement' },
+      ],
+    },
+    adjustment_account: {
+      name: 'inventory_adjustment.field.adjustment_account',
+      column: 'adjustment_account_id',
+      fieldType: 'relation',
+
+      relationType: 'enumeration',
+      relationKey: 'adjustmentAccount',
+
+      relationEntityLabel: 'name',
+      relationEntityKey: 'slug',
+    },
+    reason: {
+      name: 'inventory_adjustment.field.reason',
+      column: 'reason',
+      fieldType: 'text',
+    },
+    reference_no: {
+      name: 'inventory_adjustment.field.reference_no',
+      column: 'reference_no',
+      fieldType: 'text',
+    },
+    description: {
+      name: 'inventory_adjustment.field.description',
+      column: 'description',
+      fieldType: 'text',
+    },
+    published_at: {
+      name: 'inventory_adjustment.field.published_at',
+      column: 'published_at',
+      fieldType: 'date',
+    },
+    created_at: {
+      name: 'inventory_adjustment.field.created_at',
+      column: 'created_at',
+      fieldType: 'date',
+    },
+  },
+};
diff --git a/packages/server/src/models/InventoryAdjustment.ts b/packages/server/src/models/InventoryAdjustment.ts
new file mode 100644
index 000000000..5e55b4c06
--- /dev/null
+++ b/packages/server/src/models/InventoryAdjustment.ts
@@ -0,0 +1,113 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import InventoryAdjustmentSettings from './InventoryAdjustment.Settings';
+import ModelSetting from './ModelSetting';
+
+export default class InventoryAdjustment extends mixin(TenantModel, [
+  ModelSetting,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'inventory_adjustments';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['formattedType', 'inventoryDirection', 'isPublished'];
+  }
+
+  /**
+   * Retrieve formatted adjustment type. 
+   */
+  get formattedType() {
+    return InventoryAdjustment.getFormattedType(this.type);
+  }
+
+  /**
+   * Retrieve formatted reference type.
+   */
+  get inventoryDirection() {
+    return InventoryAdjustment.getInventoryDirection(this.type);
+  }
+
+  /**
+   * Detarmines whether the adjustment is published.
+   * @return {boolean}
+   */
+  get isPublished() {
+    return !!this.publishedAt;
+  }
+
+  static getInventoryDirection(type) {
+    const directions = {
+      increment: 'IN',
+      decrement: 'OUT',
+    };
+    return directions[type] || '';
+  }
+
+  /**
+   * Retrieve the formatted adjustment type of the given type.
+   * @param {string} type
+   * @returns {string}
+   */
+  static getFormattedType(type) {
+    const types = {
+      increment: 'inventory_adjustment.type.increment',
+      decrement: 'inventory_adjustment.type.decrement',
+    };
+    return types[type];
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const InventoryAdjustmentEntry = require('models/InventoryAdjustmentEntry');
+    const Account = require('models/Account');
+
+    return {
+      /**
+       * Adjustment entries.
+       */
+      entries: {
+        relation: Model.HasManyRelation,
+        modelClass: InventoryAdjustmentEntry.default,
+        join: {
+          from: 'inventory_adjustments.id',
+          to: 'inventory_adjustments_entries.adjustmentId',
+        },
+      },
+
+      /**
+       * Inventory adjustment account.
+       */
+      adjustmentAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'inventory_adjustments.adjustmentAccountId',
+          to: 'accounts.id',
+        },
+      },
+    };
+  }
+
+  /**
+   * Model settings.
+   */
+  static get meta() {
+    return InventoryAdjustmentSettings;
+  }
+}
diff --git a/packages/server/src/models/InventoryAdjustmentEntry.ts b/packages/server/src/models/InventoryAdjustmentEntry.ts
new file mode 100644
index 000000000..2e7159fcd
--- /dev/null
+++ b/packages/server/src/models/InventoryAdjustmentEntry.ts
@@ -0,0 +1,42 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class InventoryAdjustmentEntry extends TenantModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'inventory_adjustments_entries';
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const InventoryAdjustment = require('models/InventoryAdjustment');
+    const Item = require('models/Item');
+
+    return {
+      inventoryAdjustment: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: InventoryAdjustment.default,
+        join: {
+          from: 'inventory_adjustments_entries.adjustmentId',
+          to: 'inventory_adjustments.id',
+        },
+      },
+
+      /**
+       * Entry item.
+       */
+      item: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Item.default,
+        join: {
+          from: 'inventory_adjustments_entries.itemId',
+          to: 'items.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/InventoryCostLotTracker.ts b/packages/server/src/models/InventoryCostLotTracker.ts
new file mode 100644
index 000000000..fd9b13475
--- /dev/null
+++ b/packages/server/src/models/InventoryCostLotTracker.ts
@@ -0,0 +1,112 @@
+import { Model } from 'objection';
+import { castArray, isEmpty } from 'lodash';
+import moment from 'moment';
+import TenantModel from 'models/TenantModel';
+
+export default class InventoryCostLotTracker extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'inventory_cost_lot_tracker';
+  }
+
+  /**
+   * Model timestamps.
+   */
+  static get timestamps() {
+    return [];
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      groupedEntriesCost(query) {
+        query.select(['date', 'item_id', 'transaction_id', 'transaction_type']);
+        query.sum('cost as cost');
+
+        query.groupBy('transaction_id');
+        query.groupBy('transaction_type');
+        query.groupBy('date');
+        query.groupBy('item_id');
+      },
+      filterDateRange(query, startDate, endDate, type = 'day') {
+        const dateFormat = 'YYYY-MM-DD HH:mm:ss';
+        const fromDate = moment(startDate).startOf(type).format(dateFormat);
+        const toDate = moment(endDate).endOf(type).format(dateFormat);
+
+        if (startDate) {
+          query.where('date', '>=', fromDate);
+        }
+        if (endDate) {
+          query.where('date', '<=', toDate);
+        }
+      },
+
+      /**
+       * Filters transactions by the given branches.
+       */
+      filterByBranches(query, branchesIds) {
+        const formattedBranchesIds = castArray(branchesIds);
+
+        query.whereIn('branchId', formattedBranchesIds);
+      },
+
+      /**
+       * Filters transactions by the given warehosues.
+       */
+      filterByWarehouses(query, branchesIds) {
+        const formattedWarehousesIds = castArray(branchesIds);
+
+        query.whereIn('warehouseId', formattedWarehousesIds);
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Item = require('models/Item');
+    const SaleInvoice = require('models/SaleInvoice');
+    const ItemEntry = require('models/ItemEntry');
+    const SaleReceipt = require('models/SaleReceipt');
+
+    return {
+      item: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Item.default,
+        join: {
+          from: 'inventory_cost_lot_tracker.itemId',
+          to: 'items.id',
+        },
+      },
+      invoice: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: SaleInvoice.default,
+        join: {
+          from: 'inventory_cost_lot_tracker.transactionId',
+          to: 'sales_invoices.id',
+        },
+      },
+      itemEntry: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: ItemEntry.default,
+        join: {
+          from: 'inventory_cost_lot_tracker.entryId',
+          to: 'items_entries.id',
+        },
+      },
+      receipt: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: SaleReceipt.default,
+        join: {
+          from: 'inventory_cost_lot_tracker.transactionId',
+          to: 'sales_receipts.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/InventoryTransaction.ts b/packages/server/src/models/InventoryTransaction.ts
new file mode 100644
index 000000000..16db33993
--- /dev/null
+++ b/packages/server/src/models/InventoryTransaction.ts
@@ -0,0 +1,168 @@
+import { Model, raw } from 'objection';
+import { castArray, isEmpty } from 'lodash';
+import moment from 'moment';
+import TenantModel from 'models/TenantModel';
+
+export default class InventoryTransaction extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'inventory_transactions';
+  }
+
+  /**
+   * Model timestamps.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Retrieve formatted reference type.
+   * @return {string}
+   */
+  get transcationTypeFormatted() {
+    return InventoryTransaction.getReferenceTypeFormatted(this.transactionType);
+  }
+
+  /**
+   * Reference type formatted.
+   */
+  static getReferenceTypeFormatted(referenceType) {
+    const mapped = {
+      SaleInvoice: 'Sale invoice',
+      SaleReceipt: 'Sale receipt',
+      PaymentReceive: 'Payment receive',
+      Bill: 'Bill',
+      BillPayment: 'Payment made',
+      VendorOpeningBalance: 'Vendor opening balance',
+      CustomerOpeningBalance: 'Customer opening balance',
+      InventoryAdjustment: 'Inventory adjustment',
+      ManualJournal: 'Manual journal',
+      Journal: 'Manual journal',
+      LandedCost: 'transaction_type.landed_cost',
+    };
+    return mapped[referenceType] || '';
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      filterDateRange(query, startDate, endDate, type = 'day') {
+        const dateFormat = 'YYYY-MM-DD HH:mm:ss';
+        const fromDate = moment(startDate).startOf(type).format(dateFormat);
+        const toDate = moment(endDate).endOf(type).format(dateFormat);
+
+        if (startDate) {
+          query.where('date', '>=', fromDate);
+        }
+        if (endDate) {
+          query.where('date', '<=', toDate);
+        }
+      },
+
+      itemsTotals(builder) {
+        builder.select('itemId');
+        builder.sum('rate as rate');
+        builder.sum('quantity as quantity');
+        builder.select(raw('SUM(`QUANTITY` * `RATE`) as COST'));
+        builder.groupBy('itemId');
+      },
+
+      INDirection(builder) {
+        builder.where('direction', 'IN');
+      },
+
+      OUTDirection(builder) {
+        builder.where('direction', 'OUT');
+      },
+
+      /**
+       * Filters transactions by the given branches.
+       */
+      filterByBranches(query, branchesIds) {
+        const formattedBranchesIds = castArray(branchesIds);
+
+        query.whereIn('branch_id', formattedBranchesIds);
+      },
+
+      /**
+       * Filters transactions by the given warehosues.
+       */
+      filterByWarehouses(query, warehousesIds) {
+        const formattedWarehousesIds = castArray(warehousesIds);
+
+        query.whereIn('warehouse_id', formattedWarehousesIds);
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Item = require('models/Item');
+    const ItemEntry = require('models/ItemEntry');
+    const InventoryTransactionMeta = require('models/InventoryTransactionMeta');
+    const InventoryCostLots = require('models/InventoryCostLotTracker');
+
+    return {
+      // Transaction meta.
+      meta: {
+        relation: Model.HasOneRelation,
+        modelClass: InventoryTransactionMeta.default,
+        join: {
+          from: 'inventory_transactions.id',
+          to: 'inventory_transaction_meta.inventoryTransactionId',
+        },
+      },
+      // Item cost aggregated.
+      itemCostAggregated: {
+        relation: Model.HasOneRelation,
+        modelClass: InventoryCostLots.default,
+        join: {
+          from: 'inventory_transactions.itemId',
+          to: 'inventory_cost_lot_tracker.itemId',
+        },
+        filter(query) {
+          query.select('itemId');
+          query.sum('cost as cost');
+          query.sum('quantity as quantity');
+          query.groupBy('itemId');
+        },
+      },
+      costLotAggregated: {
+        relation: Model.HasOneRelation,
+        modelClass: InventoryCostLots.default,
+        join: {
+          from: 'inventory_transactions.id',
+          to: 'inventory_cost_lot_tracker.inventoryTransactionId',
+        },
+        filter(query) {
+          query.sum('cost as cost');
+          query.sum('quantity as quantity');
+          query.groupBy('inventoryTransactionId');
+        },
+      },
+      item: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Item.default,
+        join: {
+          from: 'inventory_transactions.itemId',
+          to: 'items.id',
+        },
+      },
+      itemEntry: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: ItemEntry.default,
+        join: {
+          from: 'inventory_transactions.entryId',
+          to: 'items_entries.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/InventoryTransactionMeta.ts b/packages/server/src/models/InventoryTransactionMeta.ts
new file mode 100644
index 000000000..62a232b64
--- /dev/null
+++ b/packages/server/src/models/InventoryTransactionMeta.ts
@@ -0,0 +1,29 @@
+import { Model, raw } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class InventoryTransactionMeta extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'inventory_transaction_meta';
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const InventoryTransactions = require('models/InventoryTransaction');
+
+    return {
+      inventoryTransaction: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: InventoryTransactions.default,
+        join: {
+          from: 'inventory_transaction_meta.inventoryTransactionId',
+          to: 'inventory_transactions.inventoryTransactionId'
+        }
+      }
+    };
+  }
+}
diff --git a/packages/server/src/models/Item.Settings.ts b/packages/server/src/models/Item.Settings.ts
new file mode 100644
index 000000000..b5509a0a4
--- /dev/null
+++ b/packages/server/src/models/Item.Settings.ts
@@ -0,0 +1,123 @@
+export default {
+  defaultFilterField: 'name',
+  defaultSort: {
+    sortField: 'name',
+    sortOrder: 'DESC',
+  },
+  fields: {
+    'type': {
+      name: 'item.field.type',
+      column: 'type',
+      fieldType: 'enumeration',
+      options: [
+        { key: 'inventory', label: 'item.field.type.inventory', },
+        { key: 'service', label: 'item.field.type.service' },
+        { key: 'non-inventory', label: 'item.field.type.non-inventory', },
+      ],
+    },
+    'name': {
+      name: 'item.field.name',
+      column: 'name',
+      fieldType: 'text',
+    },
+    'code': {
+      name: 'item.field.code',
+      column: 'code',
+      fieldType: 'text',
+    },
+    'sellable': {
+      name: 'item.field.sellable',
+      column: 'sellable',
+      fieldType: 'boolean',
+    },
+    'purchasable': {
+      name: 'item.field.purchasable',
+      column: 'purchasable',
+      fieldType: 'boolean',
+    },
+    'sell_price': {
+      name: 'item.field.cost_price',
+      column: 'sell_price',
+      fieldType: 'number',
+    },
+    'cost_price': {
+      name: 'item.field.cost_account',
+      column: 'cost_price',
+      fieldType: 'number',
+    },
+    'cost_account': {
+      name: 'item.field.sell_account',
+      column: 'cost_account_id',
+      fieldType: 'relation',
+
+      relationType: 'enumeration',
+      relationKey: 'costAccount',
+
+      relationEntityLabel: 'name',
+      relationEntityKey: 'slug',
+    },
+    'sell_account': {
+      name: 'item.field.sell_description',
+      column: 'sell_account_id',
+      fieldType: 'relation',
+
+      relationType: 'enumeration',
+      relationKey: 'sellAccount',
+
+      relationEntityLabel: 'name',
+      relationEntityKey: 'slug',
+    },
+    'inventory_account': {
+      name: 'item.field.inventory_account',
+      column: 'inventory_account_id',
+
+      relationType: 'enumeration',
+      relationKey: 'inventoryAccount',
+
+      relationEntityLabel: 'name',
+      relationEntityKey: 'slug',
+    },
+    'sell_description': {
+      name: 'Sell description',
+      column: 'sell_description',
+      fieldType: 'text',
+    },
+    'purchase_description': {
+      name: 'Purchase description',
+      column: 'purchase_description',
+      fieldType: 'text',
+    },
+    'quantity_on_hand': {
+      name: 'item.field.quantity_on_hand',
+      column: 'quantity_on_hand',
+      fieldType: 'number',
+    },
+    'note': {
+      name: 'item.field.note',
+      column: 'note',
+      fieldType: 'text',
+    },
+    'category': {
+      name: 'item.field.category',
+      column: 'category_id',
+
+      relationType: 'enumeration',
+      relationKey: 'category',
+
+      relationEntityLabel: 'name',
+      relationEntityKey: 'id',
+    },
+    'active': {
+      name: 'item.field.active',
+      column: 'active',
+      fieldType: 'boolean',
+      filterable: false,
+    },
+    'created_at': {
+      name: 'item.field.created_at',
+      column: 'created_at',
+      columnType: 'date',
+      fieldType: 'date',
+    },
+  },
+};
diff --git a/packages/server/src/models/Item.ts b/packages/server/src/models/Item.ts
new file mode 100644
index 000000000..4f2fe1fd5
--- /dev/null
+++ b/packages/server/src/models/Item.ts
@@ -0,0 +1,218 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import { buildFilterQuery } from '@/lib/ViewRolesBuilder';
+import ItemSettings from './Item.Settings';
+import ModelSetting from './ModelSetting';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import { DEFAULT_VIEWS } from '@/services/Items/constants';
+import ModelSearchable from './ModelSearchable';
+
+export default class Item extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'items';
+  }
+
+  /**
+   * Model timestamps.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Allows to mark model as resourceable to viewable and filterable.
+   */
+  static get resourceable() {
+    return true;
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      sortBy(query, columnSort, sortDirection) {
+        query.orderBy(columnSort, sortDirection);
+      },
+      viewRolesBuilder(query, conditions, logicExpression) {
+        buildFilterQuery(Item.tableName, conditions, logicExpression)(query);
+      },
+
+      /**
+       * Inactive/Active mode.
+       */
+      inactiveMode(query, active = false) {
+        query.where('items.active', !active);
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Media = require('models/Media');
+    const Account = require('models/Account');
+    const ItemCategory = require('models/ItemCategory');
+    const ItemWarehouseQuantity = require('models/ItemWarehouseQuantity');
+    const ItemEntry = require('models/ItemEntry');
+    const WarehouseTransferEntry = require('models/WarehouseTransferEntry');
+    const InventoryAdjustmentEntry = require('models/InventoryAdjustmentEntry');
+
+    return {
+      /**
+       * Item may belongs to cateogory model.
+       */
+      category: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: ItemCategory.default,
+        join: {
+          from: 'items.categoryId',
+          to: 'items_categories.id',
+        },
+      },
+
+      /**
+       * Item may belongs to cost account.
+       */
+      costAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'items.costAccountId',
+          to: 'accounts.id',
+        },
+      },
+
+      /**
+       * Item may belongs to sell account.
+       */
+      sellAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'items.sellAccountId',
+          to: 'accounts.id',
+        },
+      },
+
+      /**
+       * Item may belongs to inventory account.
+       */
+      inventoryAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'items.inventoryAccountId',
+          to: 'accounts.id',
+        },
+      },
+
+      /**
+       * Item has many warehouses quantities.
+       */
+      itemWarehouses: {
+        relation: Model.HasManyRelation,
+        modelClass: ItemWarehouseQuantity.default,
+        join: {
+          from: 'items.id',
+          to: 'items_warehouses_quantity.itemId',
+        },
+      },
+
+      /**
+       * Item may has many item entries.
+       */
+      itemEntries: {
+        relation: Model.HasManyRelation,
+        modelClass: ItemEntry.default,
+        join: {
+          from: 'items.id',
+          to: 'items_entries.itemId',
+        },
+      },
+
+      /**
+       * Item may has many warehouses transfers entries.
+       */
+      warehousesTransfersEntries: {
+        relation: Model.HasManyRelation,
+        modelClass: WarehouseTransferEntry.default,
+        join: {
+          from: 'items.id',
+          to: 'warehouses_transfers_entries.itemId',
+        },
+      },
+
+      /**
+       * Item has many inventory adjustment entries.
+       */
+      inventoryAdjustmentsEntries: {
+        relation: Model.HasManyRelation,
+        modelClass: InventoryAdjustmentEntry.default,
+        join: {
+          from: 'items.id',
+          to: 'inventory_adjustments_entries.itemId',
+        },
+      },
+
+      /**
+       *
+       */
+      media: {
+        relation: Model.ManyToManyRelation,
+        modelClass: Media.default,
+        join: {
+          from: 'items.id',
+          through: {
+            from: 'media_links.model_id',
+            to: 'media_links.media_id',
+          },
+          to: 'media.id',
+        },
+      },
+    };
+  }
+
+  /**
+   * 
+   */
+  static get secureDeleteRelations() {
+    return [
+      'itemEntries',
+      'inventoryAdjustmentsEntries',
+      'warehousesTransfersEntries',
+    ];
+  }
+
+  /**
+   * Model settings.
+   */
+  static get meta() {
+    return ItemSettings;
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model search roles.
+   */
+  static get searchRoles() {
+    return [
+      { fieldKey: 'name', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'code', comparator: 'like' },
+    ];
+  }
+}
diff --git a/packages/server/src/models/ItemCategory.Settings.ts b/packages/server/src/models/ItemCategory.Settings.ts
new file mode 100644
index 000000000..1ce8d9190
--- /dev/null
+++ b/packages/server/src/models/ItemCategory.Settings.ts
@@ -0,0 +1,30 @@
+export default {
+  defaultFilterField: 'name',
+  defaultSort: {
+    sortField: 'name',
+    sortOrder: 'DESC',
+  },
+  fields: {
+    name: {
+      name: 'item_category.field.name',
+      column: 'name',
+      fieldType: 'text',
+    },
+    description: {
+      name: 'item_category.field.description',
+      column: 'description',
+      fieldType: 'text',
+    },
+    count: {
+      name: 'item_category.field.count',
+      column: 'count',
+      fieldType: 'number',
+      virtualColumn: true,
+    },
+    created_at: {
+      name: 'item_category.field.created_at',
+      column: 'created_at',
+      columnType: 'date',
+    },
+  },
+};
diff --git a/packages/server/src/models/ItemCategory.ts b/packages/server/src/models/ItemCategory.ts
new file mode 100644
index 000000000..ef11ada3f
--- /dev/null
+++ b/packages/server/src/models/ItemCategory.ts
@@ -0,0 +1,62 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import ModelSetting from './ModelSetting';
+import ItemCategorySettings from './ItemCategory.Settings';
+
+export default class ItemCategory extends mixin(TenantModel, [ModelSetting]) {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'items_categories';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Item = require('models/Item');
+
+    return {
+      /**
+       * Item category may has many items.
+       */
+      items: {
+        relation: Model.HasManyRelation,
+        modelClass: Item.default,
+        join: {
+          from: 'items_categories.id',
+          to: 'items.categoryId',
+        },
+      },
+    };
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Inactive/Active mode.
+       */
+      sortByCount(query, order = 'asc') {
+        query.orderBy('count', order);
+      },
+    };
+  }
+
+  /**
+   * Model meta.
+   */
+  static get meta() {
+    return ItemCategorySettings;
+  }
+}
diff --git a/packages/server/src/models/ItemEntry.ts b/packages/server/src/models/ItemEntry.ts
new file mode 100644
index 000000000..cae1c9cf2
--- /dev/null
+++ b/packages/server/src/models/ItemEntry.ts
@@ -0,0 +1,135 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class ItemEntry extends TenantModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'items_entries';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  static get virtualAttributes() {
+    return ['amount'];
+  }
+
+  get amount() {
+    return ItemEntry.calcAmount(this);
+  }
+
+  static calcAmount(itemEntry) {
+    const { discount, quantity, rate } = itemEntry;
+    const total = quantity * rate;
+
+    return discount ? total - total * discount * 0.01 : total;
+  }
+
+  static get relationMappings() {
+    const Item = require('models/Item');
+    const BillLandedCostEntry = require('models/BillLandedCostEntry');
+    const SaleInvoice = require('models/SaleInvoice');
+    const Bill = require('models/Bill');
+    const SaleReceipt = require('models/SaleReceipt');
+    const SaleEstimate = require('models/SaleEstimate');
+    const ProjectTask = require('models/Task');
+    const Expense = require('models/Expense');
+
+    return {
+      item: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Item.default,
+        join: {
+          from: 'items_entries.itemId',
+          to: 'items.id',
+        },
+      },
+      allocatedCostEntries: {
+        relation: Model.HasManyRelation,
+        modelClass: BillLandedCostEntry.default,
+        join: {
+          from: 'items_entries.referenceId',
+          to: 'bill_located_cost_entries.entryId',
+        },
+      },
+
+      invoice: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: SaleInvoice.default,
+        join: {
+          from: 'items_entries.referenceId',
+          to: 'sales_invoices.id',
+        },
+      },
+
+      bill: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Bill.default,
+        join: {
+          from: 'items_entries.referenceId',
+          to: 'bills.id',
+        },
+      },
+
+      estimate: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: SaleEstimate.default,
+        join: {
+          from: 'items_entries.referenceId',
+          to: 'sales_estimates.id',
+        },
+      },
+
+      receipt: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: SaleReceipt.default,
+        join: {
+          from: 'items_entries.referenceId',
+          to: 'sales_receipts.id',
+        },
+      },
+
+      /**
+       *
+       */
+      projectTaskRef: {
+        relation: Model.HasManyRelation,
+        modelClass: ProjectTask.default,
+        join: {
+          from: 'items_entries.projectRefId',
+          to: 'tasks.id',
+        },
+      },
+
+      /**
+       *
+       */
+      projectExpenseRef: {
+        relation: Model.HasManyRelation,
+        modelClass: Expense.default,
+        join: {
+          from: 'items_entries.projectRefId',
+          to: 'expenses_transactions.id',
+        },
+      },
+
+      /**
+       *
+       */
+      projectBillRef: {
+        relation: Model.HasManyRelation,
+        modelClass: Bill.default,
+        join: {
+          from: 'items_entries.projectRefId',
+          to: 'bills.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/ItemWarehouseQuantity.ts b/packages/server/src/models/ItemWarehouseQuantity.ts
new file mode 100644
index 000000000..f90989c94
--- /dev/null
+++ b/packages/server/src/models/ItemWarehouseQuantity.ts
@@ -0,0 +1,35 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class ItemWarehouseQuantity extends TenantModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'items_warehouses_quantity';
+  }
+
+  static get relationMappings() {
+    const Item = require('models/Item');
+    const Warehouse = require('models/Warehouse');
+
+    return {
+      item: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Item.default,
+        join: {
+          from: 'items_warehouses_quantity.itemId',
+          to: 'items.id',
+        },
+      },
+      warehouse: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Warehouse.default,
+        join: {
+          from: 'items_warehouses_quantity.warehouseId',
+          to: 'warehouses.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/ManualJournal.Settings.ts b/packages/server/src/models/ManualJournal.Settings.ts
new file mode 100644
index 000000000..bc6ae8d64
--- /dev/null
+++ b/packages/server/src/models/ManualJournal.Settings.ts
@@ -0,0 +1,69 @@
+export default {
+  defaultFilterField: 'date',
+  defaultSort: {
+    sortOrder: 'DESC',
+    sortField: 'name',
+  },
+  fields: {
+    'date': {
+      name: 'manual_journal.field.date',
+      column: 'date',
+      fieldType: 'date',
+    },
+    'journal_number': {
+      name: 'manual_journal.field.journal_number',
+      column: 'journal_number',
+      fieldType: 'text',
+    },
+    'reference': {
+      name: 'manual_journal.field.reference',
+      column: 'reference',
+      fieldType: 'text',
+    },
+    'journal_type': {
+      name: 'manual_journal.field.journal_type',
+      column: 'journal_type',
+      fieldType: 'text',
+    },
+    'amount': {
+      name: 'manual_journal.field.amount',
+      column: 'amount',
+      fieldType: 'number',
+    },
+    'description': {
+      name: 'manual_journal.field.description',
+      column: 'description',
+      fieldType: 'text',
+    },
+    'status': {
+      name: 'manual_journal.field.status',
+      column: 'status',
+      fieldType: 'enumeration',
+      options: [
+        { key: 'draft', label: 'Draft' },
+        { key: 'published', label: 'published' }
+      ],
+      filterCustomQuery: StatusFieldFilterQuery,
+      sortCustomQuery: StatusFieldSortQuery,
+    },
+    'created_at': {
+      name: 'manual_journal.field.created_at',
+      column: 'created_at',
+      fieldType: 'date',
+    },
+  },
+};
+
+/**
+ * Status field sorting custom query.
+ */
+function StatusFieldSortQuery(query, role) {
+  return query.modify('sortByStatus', role.order);
+}
+
+/**
+ * Status field filter custom query.
+ */
+ function StatusFieldFilterQuery(query, role) {
+  query.modify('filterByStatus', role.value);
+}
diff --git a/packages/server/src/models/ManualJournal.ts b/packages/server/src/models/ManualJournal.ts
new file mode 100644
index 000000000..ab605b51e
--- /dev/null
+++ b/packages/server/src/models/ManualJournal.ts
@@ -0,0 +1,170 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import { formatNumber } from 'utils';
+import ModelSetting from './ModelSetting';
+import ManualJournalSettings from './ManualJournal.Settings';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import { DEFAULT_VIEWS } from '@/services/ManualJournals/constants';
+import ModelSearchable from './ModelSearchable';
+export default class ManualJournal extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'manual_journals';
+  }
+
+  /**
+   * Model timestamps.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['isPublished', 'amountFormatted'];
+  }
+
+  /**
+   * Retrieve the amount formatted value.
+   */
+  get amountFormatted() {
+    return formatNumber(this.amount, { currencyCode: this.currencyCode });
+  }
+
+  /**
+   * Detarmines whether the invoice is published.
+   * @return {boolean}
+   */
+  get isPublished() {
+    return !!this.publishedAt;
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Sort by status query.
+       */
+      sortByStatus(query, order) {
+        query.orderByRaw(`PUBLISHED_AT IS NULL ${order}`);
+      },
+
+      /**
+       * Filter by draft status.
+       */
+      filterByDraft(query) {
+        query.whereNull('publishedAt');
+      },
+
+      /**
+       * Filter by published status.
+       */
+      filterByPublished(query) {
+        query.whereNotNull('publishedAt');
+      },
+
+      /**
+       * Filter by the given status.
+       */
+      filterByStatus(query, filterType) {
+        switch (filterType) {
+          case 'draft':
+            query.modify('filterByDraft');
+            break;
+          case 'published':
+          default:
+            query.modify('filterByPublished');
+            break;
+        }
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Media = require('models/Media');
+    const AccountTransaction = require('models/AccountTransaction');
+    const ManualJournalEntry = require('models/ManualJournalEntry');
+
+    return {
+      entries: {
+        relation: Model.HasManyRelation,
+        modelClass: ManualJournalEntry.default,
+        join: {
+          from: 'manual_journals.id',
+          to: 'manual_journals_entries.manualJournalId',
+        },
+        filter(query) {
+          query.orderBy('index', 'ASC');
+        },
+      },
+      transactions: {
+        relation: Model.HasManyRelation,
+        modelClass: AccountTransaction.default,
+        join: {
+          from: 'manual_journals.id',
+          to: 'accounts_transactions.referenceId',
+        },
+        filter: (query) => {
+          query.where('referenceType', 'Journal');
+        },
+      },
+      media: {
+        relation: Model.ManyToManyRelation,
+        modelClass: Media.default,
+        join: {
+          from: 'manual_journals.id',
+          through: {
+            from: 'media_links.model_id',
+            to: 'media_links.media_id',
+          },
+          to: 'media.id',
+        },
+        filter(query) {
+          query.where('model_name', 'ManualJournal');
+        },
+      },
+    };
+  }
+
+  static get meta() {
+    return ManualJournalSettings;
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model search attributes.
+   */
+  static get searchRoles() {
+    return [
+      { fieldKey: 'journal_number', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'reference', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'amount', comparator: 'equals' },
+    ];
+  }
+
+  /**
+   * Prevents mutate base currency since the model is not empty.
+   */
+  static get preventMutateBaseCurrency() {
+    return true;
+  }
+}
diff --git a/packages/server/src/models/ManualJournalEntry.ts b/packages/server/src/models/ManualJournalEntry.ts
new file mode 100644
index 000000000..15d1ce79a
--- /dev/null
+++ b/packages/server/src/models/ManualJournalEntry.ts
@@ -0,0 +1,54 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class ManualJournalEntry extends TenantModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'manual_journals_entries';
+  }
+
+  /**
+   * Model timestamps.
+   */
+  get timestamps() {
+    return [];
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Account = require('models/Account');
+    const Contact = require('models/Contact');
+    const Branch = require('models/Branch');
+
+    return {
+      account: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'manual_journals_entries.accountId',
+          to: 'accounts.id',
+        },
+      },
+      contact: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Contact.default,
+        join: {
+          from: 'manual_journals_entries.contactId',
+          to: 'contacts.id',
+        },
+      },
+      branch: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Branch.default,
+        join: {
+          from: 'manual_journals_entries.branchId',
+          to: 'branches.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/Media.ts b/packages/server/src/models/Media.ts
new file mode 100644
index 000000000..aab3aa227
--- /dev/null
+++ b/packages/server/src/models/Media.ts
@@ -0,0 +1,36 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class Media extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'media';
+  }
+
+  /**
+   * Model timestamps.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const MediaLink = require('models/MediaLink');
+
+    return {
+      links: {
+        relation: Model.HasManyRelation,
+        modelClass: MediaLink.default,
+        join: {
+          from: 'media.id',
+          to: 'media_links.media_id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/MediaLink.ts b/packages/server/src/models/MediaLink.ts
new file mode 100644
index 000000000..78f9d4888
--- /dev/null
+++ b/packages/server/src/models/MediaLink.ts
@@ -0,0 +1,10 @@
+import TenantModel from 'models/TenantModel';
+
+export default class MediaLink extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'media_links';
+  }
+}
diff --git a/packages/server/src/models/Metable.ts b/packages/server/src/models/Metable.ts
new file mode 100644
index 000000000..8522120fe
--- /dev/null
+++ b/packages/server/src/models/Metable.ts
@@ -0,0 +1,281 @@
+import knex from '@/database/knex';
+// import cache from 'memory-cache';
+
+// Metadata
+export default {
+  METADATA_GROUP: 'default',
+  KEY_COLUMN: 'key',
+  VALUE_COLUMN: 'value',
+  TYPE_COLUMN: 'type',
+
+  extraColumns: [],
+  metadata: [],
+  shouldReload: true,
+  extraMetadataQuery: () => {},
+
+  /**
+   * Set the value column key to query from.
+   * @param {String} name -
+   */
+  setKeyColumnName(name) {
+    this.KEY_COLUMN = name;
+  },
+
+  /**
+   * Set the key column name to query from.
+   * @param {String} name -
+   */
+  setValueColumnName(name) {
+    this.VALUE_COLUMN = name;
+  },
+
+  /**
+   * Set extra columns to be added to the rows.
+   * @param {Array} columns -
+   */
+  setExtraColumns(columns) {
+    this.extraColumns = columns;
+  },
+
+  /**
+   * Metadata database query.
+   * @param {Object} query -
+   * @param {String} groupName -
+   */
+  whereQuery(query, key) {
+    const groupName = this.METADATA_GROUP;
+
+    if (groupName) {
+      query.where('group', groupName);
+    }
+    if (key) {
+      if (Array.isArray(key)) {
+        query.whereIn('key', key);
+      } else {
+        query.where('key', key);
+      }
+    }
+  },
+
+  /**
+   * Loads the metadata from the storage.
+   * @param {String|Array} key -
+   * @param {Boolean} force -
+   */
+  async load(force = false) {
+    if (this.shouldReload || force) {
+      const metadataCollection = await this.query((query) => {
+        this.whereQuery(query);
+        this.extraMetadataQuery(query);
+      }).fetchAll();
+
+      this.shouldReload = false;
+      this.metadata = [];
+
+      const metadataArray = this.mapMetadataCollection(metadataCollection);
+      metadataArray.forEach((metadata) => { this.metadata.push(metadata); });
+    }
+  },
+
+  /**
+   * Fetches all the metadata that associate with the current group.
+   */
+  async allMeta(force = false) {
+    await this.load(force);
+    return this.metadata;
+  },
+
+  /**
+   * Find the given metadata key.
+   * @param {String} key -
+   * @return {object} - Metadata object.
+   */
+  findMeta(key) {
+    return this.metadata.find((meta) => meta.key === key);
+  },
+
+  /**
+   * Fetch the metadata of the current group.
+   * @param {*} key -
+   */
+  async getMeta(key, defaultValue, force = false) {
+    await this.load(force);
+
+    const metadata = this.findMeta(key);
+    return metadata ? metadata.value : defaultValue || false;
+  },
+
+  /**
+   * Markes the metadata to should be deleted.
+   * @param {String} key -
+   */
+  async removeMeta(key) {
+    await this.load();
+    const metadata = this.findMeta(key);
+
+    if (metadata) {
+      metadata.markAsDeleted = true;
+    }
+    this.shouldReload = true;
+  },
+
+  /**
+   * Remove all meta data of the given group.
+   * @param {*} group
+   */
+  removeAllMeta(group = 'default') {
+    this.metdata.map((meta) => ({
+      ...(meta.group !== group) ? { markAsDeleted: true } : {},
+      ...meta,
+    }));
+    this.shouldReload = true;
+  },
+
+  /**
+   * Set the meta data to the stack.
+   * @param {String} key -
+   * @param {String} value -
+   */
+  async setMeta(key, value, payload) {
+    if (Array.isArray(key)) {
+      const metadata = key;
+      metadata.forEach((meta) => {
+        this.setMeta(meta.key, meta.value);
+      });
+      return;
+    }
+
+    await this.load();
+    const metadata = this.findMeta(key);
+
+    if (metadata) {
+      metadata.value = value;
+      metadata.markAsUpdated = true;
+    } else {
+      this.metadata.push({
+        value, key, ...payload, markAsInserted: true,
+      });
+    }
+  },
+
+  /**
+   * Saved the modified metadata.
+   */
+  async saveMeta() {
+    const inserted = this.metadata.filter((m) => (m.markAsInserted === true));
+    const updated = this.metadata.filter((m) => (m.markAsUpdated === true));
+    const deleted = this.metadata.filter((m) => (m.markAsDeleted === true));
+
+    const metadataDeletedKeys = deleted.map((m) => m.key);
+    const metadataInserted = inserted.map((m) => this.mapMetadata(m, 'format'));
+    const metadataUpdated = updated.map((m) => this.mapMetadata(m, 'format'));
+
+    const batchUpdate = (collection) => knex.transaction((trx) => {
+      const queries = collection.map((tuple) => {
+        const query = knex(this.tableName);
+        this.whereQuery(query, tuple.key);
+        this.extraMetadataQuery(query);
+        return query.update(tuple).transacting(trx);
+      });
+      return Promise.all(queries).then(trx.commit).catch(trx.rollback);
+    });
+
+    await Promise.all([
+      knex.insert(metadataInserted).into(this.tableName),
+      batchUpdate(metadataUpdated),
+      metadataDeletedKeys.length > 0
+        ? this.query('whereIn', this.KEY_COLUMN, metadataDeletedKeys).destroy({
+          require: true,
+        }) : null,
+    ]);
+    this.shouldReload = true;
+  },
+
+  /**
+   * Purge all the cached metadata in the memory.
+   */
+  purgeMetadata() {
+    this.metadata = [];
+    this.shouldReload = true;
+  },
+
+  /**
+   * Parses the metadata value.
+   * @param {String} value -
+   * @param {String} valueType -
+   */
+  parseMetaValue(value, valueType) {
+    let parsedValue;
+
+    switch (valueType) {
+      case 'integer':
+        parsedValue = parseInt(value, 10);
+        break;
+      case 'float':
+        parsedValue = parseFloat(value);
+        break;
+      case 'boolean':
+        parsedValue = Boolean(value);
+        break;
+      case 'json':
+        parsedValue = JSON.parse(parsedValue);
+        break;
+      default:
+        parsedValue = value;
+        break;
+    }
+    return parsedValue;
+  },
+
+  /**
+   * Format the metadata before saving to the database.
+   * @param {String|Number|Boolean} value -
+   * @param {String} valueType -
+   * @return {String|Number|Boolean} -
+   */
+  formatMetaValue(value, valueType) {
+    let parsedValue;
+
+    switch (valueType) {
+      case 'number':
+        parsedValue = `${value}`;
+        break;
+      case 'boolean':
+        parsedValue = value ? '1' : '0';
+        break;
+      case 'json':
+        parsedValue = JSON.stringify(parsedValue);
+        break;
+      default:
+        parsedValue = value;
+        break;
+    }
+    return parsedValue;
+  },
+
+  mapMetadata(attr, parseType = 'parse') {
+    return {
+      key: attr[this.KEY_COLUMN],
+      value: (parseType === 'parse')
+        ? this.parseMetaValue(
+          attr[this.VALUE_COLUMN],
+          this.TYPE_COLUMN ? attr[this.TYPE_COLUMN] : false,
+        )
+        : this.formatMetaValue(
+          attr[this.VALUE_COLUMN],
+          this.TYPE_COLUMN ? attr[this.TYPE_COLUMN] : false,
+        ),
+      ...this.extraColumns.map((extraCol) => ({
+        [extraCol]: attr[extraCol] || null,
+      })),
+    };
+  },
+
+  /**
+   * Parse the metadata collection.
+   * @param {Array} collection -
+   */
+  mapMetadataCollection(collection, parseType = 'parse') {
+    return collection.map((model) => this.mapMetadata(model.attributes, parseType));
+  },
+};
diff --git a/packages/server/src/models/Model.ts b/packages/server/src/models/Model.ts
new file mode 100644
index 000000000..b31c329b5
--- /dev/null
+++ b/packages/server/src/models/Model.ts
@@ -0,0 +1,48 @@
+import { Model, mixin } from 'objection';
+import { snakeCase, transform } from 'lodash';
+import { mapKeysDeep } from 'utils';
+import PaginationQueryBuilder from 'models/Pagination';
+import DateSession from 'models/DateSession';
+
+export default class ModelBase extends mixin(Model, [DateSession]) {
+  get timestamps() {
+    return [];
+  }
+
+  static get knexBinded() {
+    return this.knexBindInstance;
+  }
+
+  static set knexBinded(knex) {
+    this.knexBindInstance = knex;
+  }
+
+  static get collection() {
+    return Array;
+  }
+
+  static query(...args) {
+    return super.query(...args).runAfter((result) => {
+      if (Array.isArray(result)) {
+        return this.collection.from(result);
+      }
+      return result;
+    });
+  }
+
+  static get QueryBuilder() {
+    return PaginationQueryBuilder;
+  }
+
+  static relationBindKnex(model) {
+    return this.knexBinded ? model.bindKnex(this.knexBinded) : model;
+  }
+
+  static changeAmount(whereAttributes, attribute, amount, trx) {
+    const changeMethod = amount > 0 ? 'increment' : 'decrement';
+
+    return this.query(trx)
+      .where(whereAttributes)
+      [changeMethod](attribute, Math.abs(amount));
+  }
+}
diff --git a/packages/server/src/models/ModelSearchable.ts b/packages/server/src/models/ModelSearchable.ts
new file mode 100644
index 000000000..511a9f4d7
--- /dev/null
+++ b/packages/server/src/models/ModelSearchable.ts
@@ -0,0 +1,18 @@
+import { IModelMeta, ISearchRole } from '@/interfaces';
+
+export default (Model) =>
+  class ModelSearchable extends Model {
+    /**
+     * Searchable model.
+     */
+    static get searchable(): IModelMeta {
+      throw true;
+    }
+
+    /**
+     * Search roles.
+     */
+    static get searchRoles(): ISearchRole[] {
+      return [];
+    }
+  };
diff --git a/packages/server/src/models/ModelSetting.ts b/packages/server/src/models/ModelSetting.ts
new file mode 100644
index 000000000..e3c76bde7
--- /dev/null
+++ b/packages/server/src/models/ModelSetting.ts
@@ -0,0 +1,56 @@
+import { get } from 'lodash';
+import { IModelMeta, IModelMetaField, IModelMetaDefaultSort } from '@/interfaces';
+
+export default (Model) =>
+  class ModelSettings extends Model {
+    /**
+     *
+     */
+    static get meta(): IModelMeta {
+      throw new Error('');
+    }
+
+    /**
+     * Retrieve specific model field meta of the given field key.
+     * @param {string} key
+     * @returns {IModelMetaField}
+     */
+    public static getField(key: string, attribute?:string): IModelMetaField {
+      const field = get(this.meta.fields, key);
+
+      return attribute ? get(field, attribute) : field;
+    }
+
+    /**
+     * Retrieve  the specific model meta.
+     * @param {string} key
+     * @returns
+     */
+    public static getMeta(key?: string) {
+      return key ? get(this.meta, key): this.meta; 
+    }
+
+    /**
+     * Retrieve the model meta fields.
+     * @return {{ [key: string]: IModelMetaField }}
+     */
+    public static get fields(): { [key: string]: IModelMetaField } {
+      return this.getMeta('fields');
+    }
+
+    /**
+     * Retrieve the model default sort settings.
+     * @return {IModelMetaDefaultSort}
+     */
+    public static get defaultSort(): IModelMetaDefaultSort {
+      return this.getMeta('defaultSort');
+    }
+
+    /**
+     * Retrieve the default filter field key.
+     * @return {string}
+     */
+    public static get defaultFilterField(): string {
+      return this.getMeta('defaultFilterField');
+    }
+  };
diff --git a/packages/server/src/models/Option.ts b/packages/server/src/models/Option.ts
new file mode 100644
index 000000000..07fa6fb2d
--- /dev/null
+++ b/packages/server/src/models/Option.ts
@@ -0,0 +1,30 @@
+import TenantModel from 'models/TenantModel';
+import definedOptions from '@/data/options';
+
+
+export default class Option extends TenantModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'options';
+  }
+
+  /**
+   * Validates the given options is defined or either not.
+   * @param {Array} options 
+   * @return {Boolean}
+   */
+  static validateDefined(options) {
+    const notDefined = [];
+
+    options.forEach((option) => {
+      if (!definedOptions[option.group]) {
+        notDefined.push(option);
+      } else if (!definedOptions[option.group].some((o) => o.key === option.key)) {
+        notDefined.push(option);
+      }
+    });
+    return notDefined;
+  }
+}
diff --git a/packages/server/src/models/Pagination.ts b/packages/server/src/models/Pagination.ts
new file mode 100644
index 000000000..7d1b89921
--- /dev/null
+++ b/packages/server/src/models/Pagination.ts
@@ -0,0 +1,48 @@
+import { Model } from 'objection';
+import { isEmpty } from 'lodash';
+import { ServiceError } from '@/exceptions';
+
+export default class PaginationQueryBuilder extends Model.QueryBuilder {
+  pagination(page, pageSize) {
+    return super.page(page, pageSize).runAfter(({ results, total }) => {
+      return {
+        results,
+        pagination: {
+          total,
+          page: page + 1,
+          pageSize,
+        },
+      };
+    });
+  }
+
+  queryAndThrowIfHasRelations = ({ type, message }) => {
+    const model = this.modelClass();
+    const modelRelations = Object.keys(model.relationMappings).filter(
+      (relation) =>
+        [Model.HasManyRelation, Model.HasOneRelation].indexOf(
+          model.relationMappings[relation]?.relation
+        ) !== -1
+    );
+    const relations = model.secureDeleteRelations || modelRelations;
+
+    this.runAfter((model, query) => {
+      const nonEmptyRelations = relations.filter(
+        (relation) => !isEmpty(model[relation])
+      );
+      if (nonEmptyRelations.length > 0) {
+        throw new ServiceError(type || 'MODEL_HAS_RELATIONS', { message });
+      }
+      return model;
+    });
+    return this.onBuild((query) => {
+      relations.forEach((relation) => {
+        query.withGraphFetched(`${relation}(selectId)`).modifiers({
+          selectId(builder) {
+            builder.select('id');
+          },
+        });
+      });
+    });
+  };
+}
diff --git a/packages/server/src/models/PaymentReceive.Settings.ts b/packages/server/src/models/PaymentReceive.Settings.ts
new file mode 100644
index 000000000..0e9012806
--- /dev/null
+++ b/packages/server/src/models/PaymentReceive.Settings.ts
@@ -0,0 +1,57 @@
+
+export default {
+  fields: {
+    customer: {
+      name: 'payment_receive.field.customer',
+      column: 'customer_id',
+      fieldType: 'relation',
+
+      relationType: 'enumeration',
+      relationKey: 'customer',
+
+      relationEntityLabel: 'display_name',
+      relationEntityKey: 'id',
+    },
+    payment_date: {
+      name: 'payment_receive.field.payment_date',
+      column: 'payment_date',
+      fieldType: 'date',
+    },
+    amount: {
+      name: 'payment_receive.field.amount',
+      column: 'amount',
+      fieldType: 'number',
+    },
+    reference_no: {
+      name: 'payment_receive.field.reference_no',
+      column: 'reference_no',
+      fieldType: 'text',
+    },
+    deposit_account: {
+      name: 'payment_receive.field.deposit_account',
+      column: 'deposit_account_id',
+      fieldType: 'relation',
+
+      relationType: 'enumeration',
+      relationKey: 'depositAccount',
+
+      relationEntityLabel: 'name',
+      relationEntityKey: 'slug',
+    },
+    payment_receive_no: {
+      name: 'payment_receive.field.payment_receive_no',
+      column: 'payment_receive_no',
+      fieldType: 'text',
+    },
+    statement: {
+      name: 'payment_receive.field.statement',
+      column: 'statement',
+      fieldType: 'text',
+    },
+    created_at: {
+      name: 'payment_receive.field.created_at',
+      column: 'created_at',
+      fieldDate: 'date',
+    },
+  },
+};
diff --git a/packages/server/src/models/PaymentReceive.ts b/packages/server/src/models/PaymentReceive.ts
new file mode 100644
index 000000000..e27559dbd
--- /dev/null
+++ b/packages/server/src/models/PaymentReceive.ts
@@ -0,0 +1,148 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import ModelSetting from './ModelSetting';
+import PaymentReceiveSettings from './PaymentReceive.Settings';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import { DEFAULT_VIEWS } from '@/services/Sales/PaymentReceives/constants';
+import ModelSearchable from './ModelSearchable';
+
+export default class PaymentReceive extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'payment_receives';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['localAmount'];
+  }
+
+  /**
+   * Payment receive amount in local currency.
+   * @returns {number}
+   */
+  get localAmount() {
+    return this.amount * this.exchangeRate;
+  }
+
+  /**
+   * Resourcable model.
+   */
+  static get resourceable() {
+    return true;
+  }
+
+  /*
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const PaymentReceiveEntry = require('models/PaymentReceiveEntry');
+    const AccountTransaction = require('models/AccountTransaction');
+    const Customer = require('models/Customer');
+    const Account = require('models/Account');
+    const Branch = require('models/Branch');
+
+    return {
+      customer: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Customer.default,
+        join: {
+          from: 'payment_receives.customerId',
+          to: 'contacts.id',
+        },
+        filter: (query) => {
+          query.where('contact_service', 'customer');
+        },
+      },
+      depositAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'payment_receives.depositAccountId',
+          to: 'accounts.id',
+        },
+      },
+      entries: {
+        relation: Model.HasManyRelation,
+        modelClass: PaymentReceiveEntry.default,
+        join: {
+          from: 'payment_receives.id',
+          to: 'payment_receives_entries.paymentReceiveId',
+        },
+        filter: (query) => {
+          query.orderBy('index', 'ASC');
+        },
+      },
+      transactions: {
+        relation: Model.HasManyRelation,
+        modelClass: AccountTransaction.default,
+        join: {
+          from: 'payment_receives.id',
+          to: 'accounts_transactions.referenceId',
+        },
+        filter: (builder) => {
+          builder.where('reference_type', 'PaymentReceive');
+        },
+      },
+
+      /**
+       * Payment receive may belongs to branch.
+       */
+      branch: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Branch.default,
+        join: {
+          from: 'payment_receives.branchId',
+          to: 'branches.id',
+        },
+      },
+    };
+  }
+
+  /**
+   *
+   */
+  static get meta() {
+    return PaymentReceiveSettings;
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model search attributes.
+   */
+  static get searchRoles() {
+    return [
+      { fieldKey: 'payment_receive_no', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'reference_no', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'amount', comparator: 'equals' },
+    ];
+  }
+
+  /**
+   * Prevents mutate base currency since the model is not empty.
+   */
+  static get preventMutateBaseCurrency() {
+    return true;
+  }
+}
diff --git a/packages/server/src/models/PaymentReceiveEntry.ts b/packages/server/src/models/PaymentReceiveEntry.ts
new file mode 100644
index 000000000..7fcc6b2b0
--- /dev/null
+++ b/packages/server/src/models/PaymentReceiveEntry.ts
@@ -0,0 +1,51 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class PaymentReceiveEntry extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'payment_receives_entries';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return [];
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const PaymentReceive = require('models/PaymentReceive');
+    const SaleInvoice = require('models/SaleInvoice');
+
+    return {
+      /**
+       */
+      payment: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: PaymentReceive.default,
+        join: {
+          from: 'payment_receives_entries.paymentReceiveId',
+          to: 'payment_receives.id',
+        },
+      },
+
+      /**
+       * The payment receive entry have have sale invoice.
+       */
+      invoice: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: SaleInvoice.default,
+        join: {
+          from: 'payment_receives_entries.invoiceId',
+          to: 'sales_invoices.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/Project.ts b/packages/server/src/models/Project.ts
new file mode 100644
index 000000000..1d5560722
--- /dev/null
+++ b/packages/server/src/models/Project.ts
@@ -0,0 +1,157 @@
+import { mixin, Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import ModelSetting from './ModelSetting';
+import ModelSearchable from './ModelSearchable';
+
+export default class Project extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  costEstimate!: number;
+  deadline!: Date;
+
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'projects';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return [];
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      totalExpensesDetails(builder) {
+        builder
+          .withGraphFetched('expenses')
+          .modifyGraph('expenses', (builder) => {
+            builder.select(['projectId']);
+            builder.groupBy('projectId');
+
+            builder.sum('totalAmount as totalExpenses');
+            builder.sum('invoicedAmount as totalInvoicedExpenses');
+          });
+      },
+
+      totalBillsDetails(builder) {
+        builder.withGraphFetched('tasks').modifyGraph('tasks', (builder) => {
+          builder.select(['projectId']);
+          builder.groupBy('projectId');
+
+          builder.modify('sumTotalActualHours');
+          builder.modify('sumTotalEstimateHours');
+          builder.modify('sumTotalInvoicedHours');
+
+          builder.modify('sumTotalActualAmount');
+          builder.modify('sumTotalInvoicedAmount');
+          builder.modify('sumTotalEstimateAmount');
+        });
+      },
+
+      totalTasksDetails(builder) {
+        builder.withGraphFetched('tasks').modifyGraph('tasks', (builder) => {
+          builder.select(['projectId']);
+          builder.groupBy('projectId');
+
+          builder.modify('sumTotalActualHours');
+          builder.modify('sumTotalEstimateHours');
+          builder.modify('sumTotalInvoicedHours');
+
+          builder.modify('sumTotalActualAmount');
+          builder.modify('sumTotalInvoicedAmount');
+          builder.modify('sumTotalEstimateAmount');
+        });
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Contact = require('models/Contact');
+    const Task = require('models/Task');
+    const Time = require('models/Time');
+    const Expense = require('models/Expense');
+    const Bill = require('models/Bill');
+
+    return {
+      /**
+       * Belongs to customer model.
+       */
+      contact: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Contact.default,
+        join: {
+          from: 'projects.contactId',
+          to: 'contacts.id',
+        },
+      },
+
+      /**
+       * Project may has many associated tasks.
+       */
+      tasks: {
+        relation: Model.HasManyRelation,
+        modelClass: Task.default,
+        join: {
+          from: 'projects.id',
+          to: 'tasks.projectId',
+        },
+      },
+
+      /**
+       * Project may has many associated times.
+       */
+      times: {
+        relation: Model.HasManyRelation,
+        modelClass: Time.default,
+        join: {
+          from: 'projects.id',
+          to: 'times.projectId',
+        },
+      },
+
+      /**
+       * Project may has many associated expenses.
+       */
+      expenses: {
+        relation: Model.HasManyRelation,
+        modelClass: Expense.default,
+        join: {
+          from: 'projects.id',
+          to: 'expenses_transactions.projectId',
+        },
+      },
+
+      /**
+       * Project may has many associated bills.
+       */
+      bills: {
+        relation: Model.HasManyRelation,
+        modelClass: Bill.default,
+        join: {
+          from: 'projects.id',
+          to: 'bills.projectId',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/ProjectItemEntryRef.ts b/packages/server/src/models/ProjectItemEntryRef.ts
new file mode 100644
index 000000000..797bc67c9
--- /dev/null
+++ b/packages/server/src/models/ProjectItemEntryRef.ts
@@ -0,0 +1,47 @@
+import { mixin, Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import ModelSetting from './ModelSetting';
+import ModelSearchable from './ModelSearchable';
+
+export default class ProjectItemEntryRef extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'projects_item_entries_links';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return [];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return [];
+  }
+
+  static get relationMappings() {
+    const ItemEntry = require('models/ItemEntry');
+
+    return {
+      itemEntry: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: ItemEntry.default,
+        join: {
+          from: 'projects_item_entries_links.itemEntryId',
+          to: 'items_entries.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/RefundCreditNote.ts b/packages/server/src/models/RefundCreditNote.ts
new file mode 100644
index 000000000..c0c85ba6d
--- /dev/null
+++ b/packages/server/src/models/RefundCreditNote.ts
@@ -0,0 +1,52 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import ModelSetting from './ModelSetting';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import ModelSearchable from './ModelSearchable';
+
+export default class RefundCreditNote extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'refund_credit_note_transactions';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  /*
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Account = require('models/Account');
+    const CreditNote = require('models/CreditNote');
+
+    return {
+      fromAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'refund_credit_note_transactions.fromAccountId',
+          to: 'accounts.id',
+        },
+      },
+      creditNote: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: CreditNote.default,
+        join: {
+          from: 'refund_credit_note_transactions.creditNoteId',
+          to: 'credit_notes.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/RefundVendorCredit.ts b/packages/server/src/models/RefundVendorCredit.ts
new file mode 100644
index 000000000..f81ae4713
--- /dev/null
+++ b/packages/server/src/models/RefundVendorCredit.ts
@@ -0,0 +1,52 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import ModelSetting from './ModelSetting';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import ModelSearchable from './ModelSearchable';
+
+export default class RefundVendorCredit extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'refund_vendor_credit_transactions';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  /*
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const VendorCredit = require('models/VendorCredit');
+    const Account = require('models/Account');
+
+    return {
+      depositAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'refund_vendor_credit_transactions.depositAccountId',
+          to: 'accounts.id',
+        },
+      },
+      vendorCredit: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: VendorCredit.default,
+        join: {
+          from: 'refund_vendor_credit_transactions.vendorCreditId',
+          to: 'vendor_credits.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/ResourcableModel.ts b/packages/server/src/models/ResourcableModel.ts
new file mode 100644
index 000000000..289c2dfa3
--- /dev/null
+++ b/packages/server/src/models/ResourcableModel.ts
@@ -0,0 +1,8 @@
+
+
+export default class ResourceableModel {
+
+  static get resourceable() {
+    return true;
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/models/Role.ts b/packages/server/src/models/Role.ts
new file mode 100644
index 000000000..3bad745ba
--- /dev/null
+++ b/packages/server/src/models/Role.ts
@@ -0,0 +1,33 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+
+export default class Role extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'roles';
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const RolePermission = require('models/RolePermission');
+
+    return {
+      /**
+       *
+       */
+      permissions: {
+        relation: Model.HasManyRelation,
+        modelClass: RolePermission.default,
+        join: {
+          from: 'roles.id',
+          to: 'role_permissions.roleId',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/RolePermission.ts b/packages/server/src/models/RolePermission.ts
new file mode 100644
index 000000000..29d5bcf35
--- /dev/null
+++ b/packages/server/src/models/RolePermission.ts
@@ -0,0 +1,39 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import ModelSetting from './ModelSetting';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import ModelSearchable from './ModelSearchable';
+
+export default class RolePermission extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'role_permissions';
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Role = require('models/Role');
+
+    return {
+      /**
+       * 
+       */
+      role: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Role.default,
+        join: {
+          from: 'role_permissions.roleId',
+          to: 'roles.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/SaleEstimate.Settings.ts b/packages/server/src/models/SaleEstimate.Settings.ts
new file mode 100644
index 000000000..9d1ea90a4
--- /dev/null
+++ b/packages/server/src/models/SaleEstimate.Settings.ts
@@ -0,0 +1,80 @@
+export default {
+  defaultFilterField: 'estimate_date',
+  defaultSort: {
+    sortOrder: 'DESC',
+    sortField: 'estimate_date',
+  },
+  fields: {
+    'amount': {
+      name: 'estimate.field.amount',
+      column: 'amount',
+      fieldType: 'number',
+    },
+    'estimate_number': {
+      name: 'estimate.field.estimate_number',
+      column: 'estimate_number',
+      fieldType: 'text',
+    },
+    'customer': {
+      name: 'estimate.field.customer',
+      column: 'customer_id',
+      fieldType: 'relation',
+
+      relationType: 'enumeration',
+      relationKey: 'customer',
+
+      relationEntityLabel: 'display_name',
+      relationEntityKey: 'id',
+    },
+    'estimate_date': {
+      name: 'estimate.field.estimate_date',
+      column: 'estimate_date',
+      fieldType: 'date',
+    },
+    'expiration_date': {
+      name: 'estimate.field.expiration_date',
+      column: 'expiration_date',
+      fieldType: 'date',
+    },
+    'reference_no': {
+      name: 'estimate.field.reference_no',
+      column: 'reference',
+      fieldType: 'text',
+    },
+    'note': {
+      name: 'estimate.field.note',
+      column: 'note',
+      fieldType: 'text',
+    },
+    'terms_conditions': {
+      name: 'estimate.field.terms_conditions',
+      column: 'terms_conditions',
+      fieldType: 'text',
+    },
+    'status': {
+      name: 'estimate.field.status',
+      fieldType: 'enumeration',
+      options: [
+        { label: 'estimate.field.status.delivered', key: 'delivered' },
+        { label: 'estimate.field.status.rejected', key: 'rejected' },
+        { label: 'estimate.field.status.approved', key: 'approved' },
+        { label: 'estimate.field.status.draft', key: 'draft' },
+      ],
+      filterCustomQuery: StatusFieldFilterQuery,
+      sortCustomQuery: StatusFieldSortQuery,
+    },
+    'created_at': {
+      name: 'estimate.field.created_at',
+      column: 'created_at',
+      columnType: 'date',
+    },
+  },
+};
+
+function StatusFieldSortQuery(query, role) {
+  query.modify('orderByStatus', role.order);
+}
+
+function StatusFieldFilterQuery(query, role) {
+  query.modify('filterByStatus', role.value);
+}
diff --git a/packages/server/src/models/SaleEstimate.ts b/packages/server/src/models/SaleEstimate.ts
new file mode 100644
index 000000000..31d40eb82
--- /dev/null
+++ b/packages/server/src/models/SaleEstimate.ts
@@ -0,0 +1,256 @@
+import moment from 'moment';
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import { defaultToTransform } from 'utils';
+import SaleEstimateSettings from './SaleEstimate.Settings';
+import ModelSetting from './ModelSetting';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import { DEFAULT_VIEWS } from '@/services/Sales/Estimates/constants';
+import ModelSearchable from './ModelSearchable';
+
+export default class SaleEstimate extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'sales_estimates';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return [
+      'localAmount',
+      'isDelivered',
+      'isExpired',
+      'isConvertedToInvoice',
+      'isApproved',
+      'isRejected',
+    ];
+  }
+
+  /**
+   * Estimate amount in local currency.
+   * @returns {number}
+   */
+  get localAmount() {
+    return this.amount * this.exchangeRate;
+  }
+
+  /**
+   * Detarmines whether the sale estimate converted to sale invoice.
+   * @return {boolean}
+   */
+  get isConvertedToInvoice() {
+    return !!(this.convertedToInvoiceId && this.convertedToInvoiceAt);
+  }
+
+  /**
+   * Detarmines whether the estimate is delivered.
+   * @return {boolean}
+   */
+  get isDelivered() {
+    return !!this.deliveredAt;
+  }
+
+  /**
+   * Detarmines whether the estimate is expired.
+   * @return {boolean}
+   */
+  get isExpired() {
+    return defaultToTransform(
+      this.expirationDate,
+      moment().isAfter(this.expirationDate, 'day'),
+      false
+    );
+  }
+
+  /**
+   * Detarmines whether the estimate is approved.
+   * @return {boolean}
+   */
+  get isApproved() {
+    return !!this.approvedAt;
+  }
+
+  /**
+   * Detarmines whether the estimate is reject.
+   * @return {boolean}
+   */
+  get isRejected() {
+    return !!this.rejectedAt;
+  }
+
+  /**
+   * Allows to mark model as resourceable to viewable and filterable.
+   */
+  static get resourceable() {
+    return true;
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Filters the drafted estimates transactions.
+       */
+      draft(query) {
+        query.where('delivered_at', null);
+      },
+      /**
+       * Filters the delivered estimates transactions.
+       */
+      delivered(query) {
+        query.whereNot('delivered_at', null);
+      },
+      /**
+       * Filters the expired estimates transactions.
+       */
+      expired(query) {
+        query.where('expiration_date', '<', moment().format('YYYY-MM-DD'));
+      },
+      /**
+       * Filters the rejected estimates transactions.
+       */
+      rejected(query) {
+        query.whereNot('rejected_at', null);
+      },
+      /**
+       * Filters the invoiced estimates transactions.
+       */
+      invoiced(query) {
+        query.whereNot('converted_to_invoice_at', null);
+      },
+      /**
+       * Filters the approved estimates transactions.
+       */
+      approved(query) {
+        query.whereNot('approved_at', null);
+      },
+      /**
+       * Sorting the estimates orders by delivery status.
+       */
+      orderByStatus(query, order) {
+        query.orderByRaw(`delivered_at is null ${order}`);
+      },
+      /**
+       * Filtering the estimates oreders by status field.
+       */
+      filterByStatus(query, filterType) {
+        switch (filterType) {
+          case 'draft':
+            query.modify('draft');
+            break;
+          case 'delivered':
+            query.modify('delivered');
+            break;
+          case 'approved':
+            query.modify('approved');
+            break;
+          case 'rejected':
+            query.modify('rejected');
+            break;
+          case 'invoiced':
+            query.modify('invoiced');
+            break;
+          case 'expired':
+            query.modify('expired');
+            break;
+        }
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const ItemEntry = require('models/ItemEntry');
+    const Customer = require('models/Customer');
+    const Branch = require('models/Branch');
+
+    return {
+      customer: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Customer.default,
+        join: {
+          from: 'sales_estimates.customerId',
+          to: 'contacts.id',
+        },
+        filter(query) {
+          query.where('contact_service', 'customer');
+        },
+      },
+      entries: {
+        relation: Model.HasManyRelation,
+        modelClass: ItemEntry.default,
+        join: {
+          from: 'sales_estimates.id',
+          to: 'items_entries.referenceId',
+        },
+        filter(builder) {
+          builder.where('reference_type', 'SaleEstimate');
+          builder.orderBy('index', 'ASC');
+        },
+      },
+
+      /**
+       * Sale estimate may belongs to branch.
+       */
+      branch: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Branch.default,
+        join: {
+          from: 'sales_estimates.branchId',
+          to: 'branches.id',
+        },
+      },
+    };
+  }
+
+  /**
+   * Model settings.
+   */
+  static get meta() {
+    return SaleEstimateSettings;
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model search roles.
+   */
+  static get searchRoles() {
+    return [
+      { fieldKey: 'amount', comparator: 'equals' },
+      { condition: 'or', fieldKey: 'estimate_number', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'reference_no', comparator: 'contains' },
+    ];
+  }
+
+  /**
+   * Prevents mutate base currency since the model is not empty.
+   */
+  static get preventMutateBaseCurrency() {
+    return true;
+  }
+}
diff --git a/packages/server/src/models/SaleEstimateEntry.ts b/packages/server/src/models/SaleEstimateEntry.ts
new file mode 100644
index 000000000..35c3b5106
--- /dev/null
+++ b/packages/server/src/models/SaleEstimateEntry.ts
@@ -0,0 +1,30 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+
+export default class SaleEstimateEntry extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'sales_estimate_entries';
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const SaleEstimate = require('models/SaleEstimate');
+
+    return {
+      estimate: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: SaleEstimate.default,
+        join: {
+          from: 'sales_estimates.id',
+          to: 'sales_estimate_entries.estimate_id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/SaleInvoice.Settings.ts b/packages/server/src/models/SaleInvoice.Settings.ts
new file mode 100644
index 000000000..842c5618b
--- /dev/null
+++ b/packages/server/src/models/SaleInvoice.Settings.ts
@@ -0,0 +1,100 @@
+export default {
+  defaultFilterField: 'customer',
+  defaultSort: {
+    sortOrder: 'DESC',
+    sortField: 'created_at',
+  },
+  fields: {
+    customer: {
+      name: 'invoice.field.customer',
+      column: 'customer_id',
+      fieldType: 'relation',
+
+      relationType: 'enumeration',
+      relationKey: 'customer',
+
+      relationEntityLabel: 'display_name',
+      relationEntityKey: 'id',
+    },
+    invoice_date: {
+      name: 'invoice.field.invoice_date',
+      column: 'invoice_date',
+      fieldType: 'date',
+    },
+    due_date: {
+      name: 'invoice.field.due_date',
+      column: 'due_date',
+      fieldType: 'date',
+    },
+    invoice_no: {
+      name: 'invoice.field.invoice_no',
+      column: 'invoice_no',
+      fieldType: 'text',
+    },
+    reference_no: {
+      name: 'invoice.field.reference_no',
+      column: 'reference_no',
+      fieldType: 'text',
+    },
+    invoice_message: {
+      name: 'invoice.field.invoice_message',
+      column: 'invoice_message',
+      fieldType: 'text',
+    },
+    terms_conditions: {
+      name: 'invoice.field.terms_conditions',
+      column: 'terms_conditions',
+      fieldType: 'text',
+    },
+    amount: {
+      name: 'invoice.field.amount',
+      column: 'balance',
+      fieldType: 'number',
+    },
+    payment_amount: {
+      name: 'invoice.field.payment_amount',
+      column: 'payment_amount',
+      fieldType: 'number',
+    },
+    due_amount: {
+      // calculated.
+      name: 'invoice.field.due_amount',
+      column: 'due_amount',
+      fieldType: 'number',
+      virtualColumn: true,
+    },
+    status: {
+      name: 'invoice.field.status',
+      fieldType: 'enumeration',
+      options: [
+        { key: 'draft', label: 'invoice.field.status.draft' },
+        { key: 'delivered', label: 'invoice.field.status.delivered' },
+        { key: 'unpaid', label: 'invoice.field.status.unpaid' },
+        { key: 'overdue', label: 'invoice.field.status.overdue' },
+        { key: 'partially-paid', label: 'invoice.field.status.partially-paid' },
+        { key: 'paid', label: 'invoice.field.status.paid' },
+      ],
+      filterCustomQuery: StatusFieldFilterQuery,
+      sortCustomQuery: StatusFieldSortQuery,
+    },
+    created_at: {
+      name: 'invoice.field.created_at',
+      column: 'created_at',
+      fieldType: 'date',
+    },
+  },
+};
+
+/**
+ * Status field filter custom query.
+ */
+function StatusFieldFilterQuery(query, role) {
+  query.modify('statusFilter', role.value);
+}
+
+/**
+ * Status field sort custom query.
+ */
+function StatusFieldSortQuery(query, role) {
+  query.modify('sortByStatus', role.order);
+}
diff --git a/packages/server/src/models/SaleInvoice.ts b/packages/server/src/models/SaleInvoice.ts
new file mode 100644
index 000000000..9c7fdfbfe
--- /dev/null
+++ b/packages/server/src/models/SaleInvoice.ts
@@ -0,0 +1,489 @@
+import { mixin, Model, raw } from 'objection';
+import { castArray } from 'lodash';
+import moment from 'moment';
+import TenantModel from 'models/TenantModel';
+import ModelSetting from './ModelSetting';
+import SaleInvoiceMeta from './SaleInvoice.Settings';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import { DEFAULT_VIEWS } from '@/services/Sales/constants';
+import ModelSearchable from './ModelSearchable';
+
+export default class SaleInvoice extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'sales_invoices';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  get pluralName() {
+    return 'asdfsdf';
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return [
+      'localAmount',
+      'dueAmount',
+      'balanceAmount',
+      'isDelivered',
+      'isOverdue',
+      'isPartiallyPaid',
+      'isFullyPaid',
+      'isPaid',
+      'isWrittenoff',
+      'remainingDays',
+      'overdueDays',
+      'filterByBranches',
+    ];
+  }
+
+  /**
+   * Invoice amount in local currency.
+   * @returns {number}
+   */
+  get localAmount() {
+    return this.balance * this.exchangeRate;
+  }
+
+  /**
+   * Invoice local written-off amount.
+   * @returns {number}
+   */
+  get localWrittenoffAmount() {
+    return this.writtenoffAmount * this.exchangeRate;
+  }
+
+  /**
+   * Detarmines whether the invoice is delivered.
+   * @return {boolean}
+   */
+  get isDelivered() {
+    return !!this.deliveredAt;
+  }
+
+  /**
+   * Detarmines the due date is over.
+   * @return {boolean}
+   */
+  get isOverdue() {
+    return this.overdueDays > 0;
+  }
+
+  /**
+   * Retrieve the sale invoice balance.
+   * @return {number}
+   */
+  get balanceAmount() {
+    return this.paymentAmount + this.writtenoffAmount + this.creditedAmount;
+  }
+
+  /**
+   * Retrieve the invoice due amount.
+   * Equation (Invoice amount - payment amount = Due amount)
+   * @return {boolean}
+   */
+  get dueAmount() {
+    return Math.max(this.balance - this.balanceAmount, 0);
+  }
+
+  /**
+   * Detarmine whether the invoice paid partially.
+   * @return {boolean}
+   */
+  get isPartiallyPaid() {
+    return this.dueAmount !== this.balance && this.dueAmount > 0;
+  }
+
+  /**
+   * Deetarmine whether the invoice paid fully.
+   * @return {boolean}
+   */
+  get isFullyPaid() {
+    return this.dueAmount === 0;
+  }
+
+  /**
+   * Detarmines whether the invoice paid fully or partially.
+   * @return {boolean}
+   */
+  get isPaid() {
+    return this.isPartiallyPaid || this.isFullyPaid;
+  }
+
+  /**
+   * Detarmines whether the sale invoice is written-off.
+   * @return {boolean}
+   */
+  get isWrittenoff() {
+    return Boolean(this.writtenoffAt);
+  }
+
+  /**
+   * Retrieve the remaining days in number
+   * @return {number|null}
+   */
+  get remainingDays() {
+    const dateMoment = moment();
+    const dueDateMoment = moment(this.dueDate);
+
+    return Math.max(dueDateMoment.diff(dateMoment, 'days'), 0);
+  }
+
+  /**
+   * Retrieve the overdue days in number.
+   * @return {number|null}
+   */
+  get overdueDays() {
+    const dateMoment = moment();
+    const dueDateMoment = moment(this.dueDate);
+
+    return Math.max(dateMoment.diff(dueDateMoment, 'days'), 0);
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Filters the due invoices.
+       */
+      dueInvoices(query) {
+        query.where(
+          raw(`
+            COALESCE(BALANCE, 0) -
+            COALESCE(PAYMENT_AMOUNT, 0) -
+            COALESCE(WRITTENOFF_AMOUNT, 0) -
+            COALESCE(CREDITED_AMOUNT, 0) > 0
+        `)
+        );
+      },
+      /**
+       * Filters the invoices between the given date range.
+       */
+      filterDateRange(query, startDate, endDate, type = 'day') {
+        const dateFormat = 'YYYY-MM-DD HH:mm:ss';
+        const fromDate = moment(startDate).startOf(type).format(dateFormat);
+        const toDate = moment(endDate).endOf(type).format(dateFormat);
+
+        if (startDate) {
+          query.where('invoice_date', '>=', fromDate);
+        }
+        if (endDate) {
+          query.where('invoice_date', '<=', toDate);
+        }
+      },
+      /**
+       * Filters the invoices in draft status.
+       */
+      draft(query) {
+        query.where('delivered_at', null);
+      },
+      /**
+       * Filters the published invoices.
+       */
+      published(query) {
+        query.whereNot('delivered_at', null);
+      },
+      /**
+       * Filters the delivered invoices.
+       */
+      delivered(query) {
+        query.whereNot('delivered_at', null);
+      },
+      /**
+       * Filters the unpaid invoices.
+       */
+      unpaid(query) {
+        query.where(raw('PAYMENT_AMOUNT = 0'));
+      },
+      /**
+       * Filters the overdue invoices.
+       */
+      overdue(query, asDate = moment().format('YYYY-MM-DD')) {
+        query.where('due_date', '<', asDate);
+      },
+      /**
+       * Filters the not overdue invoices.
+       */
+      notOverdue(query, asDate = moment().format('YYYY-MM-DD')) {
+        query.where('due_date', '>=', asDate);
+      },
+      /**
+       * Filters the partially invoices.
+       */
+      partiallyPaid(query) {
+        query.whereNot('payment_amount', 0);
+        query.whereNot(raw('`PAYMENT_AMOUNT` = `BALANCE`'));
+      },
+      /**
+       * Filters the paid invoices.
+       */
+      paid(query) {
+        query.where(raw('PAYMENT_AMOUNT = BALANCE'));
+      },
+      /**
+       * Filters the sale invoices from the given date.
+       */
+      fromDate(query, fromDate) {
+        query.where('invoice_date', '<=', fromDate);
+      },
+      /**
+       * Sort the sale invoices by full-payment invoices.
+       */
+      sortByStatus(query, order) {
+        query.orderByRaw(`PAYMENT_AMOUNT = BALANCE ${order}`);
+      },
+
+      /**
+       * Sort the sale invoices by the due amount.
+       */
+      sortByDueAmount(query, order) {
+        query.orderByRaw(`BALANCE - PAYMENT_AMOUNT ${order}`);
+      },
+
+      /**
+       * Retrieve the max invoice
+       */
+      maxInvoiceNo(query, prefix, number) {
+        query
+          .select(raw(`REPLACE(INVOICE_NO, "${prefix}", "") AS INV_NUMBER`))
+          .havingRaw('CHAR_LENGTH(INV_NUMBER) = ??', [number.length])
+          .orderBy('invNumber', 'DESC')
+          .limit(1)
+          .first();
+      },
+
+      byPrefixAndNumber(query, prefix, number) {
+        query.where('invoice_no', `${prefix}${number}`);
+      },
+
+      /**
+       * Status filter.
+       */
+      statusFilter(query, filterType) {
+        switch (filterType) {
+          case 'draft':
+            query.modify('draft');
+            break;
+          case 'delivered':
+            query.modify('delivered');
+            break;
+          case 'unpaid':
+            query.modify('unpaid');
+            break;
+          case 'overdue':
+          default:
+            query.modify('overdue');
+            break;
+          case 'partially-paid':
+            query.modify('partiallyPaid');
+            break;
+          case 'paid':
+            query.modify('paid');
+            break;
+        }
+      },
+
+      /**
+       * Filters by branches.
+       */
+      filterByBranches(query, branchesIds) {
+        const formattedBranchesIds = castArray(branchesIds);
+
+        query.whereIn('branchId', formattedBranchesIds);
+      },
+
+      dueInvoicesFromDate(query, asDate = moment().format('YYYY-MM-DD')) {
+        query.modify('dueInvoices');
+        query.modify('notOverdue', asDate);
+        query.modify('fromDate', asDate);
+      },
+
+      overdueInvoicesFromDate(query, asDate = moment().format('YYYY-MM-DD')) {
+        query.modify('dueInvoices');
+        query.modify('overdue', asDate);
+        query.modify('fromDate', asDate);
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const AccountTransaction = require('models/AccountTransaction');
+    const ItemEntry = require('models/ItemEntry');
+    const Customer = require('models/Customer');
+    const InventoryCostLotTracker = require('models/InventoryCostLotTracker');
+    const PaymentReceiveEntry = require('models/PaymentReceiveEntry');
+    const Branch = require('models/Branch');
+    const Account = require('models/Account');
+
+    return {
+      /**
+       * Sale invoice associated entries.
+       */
+      entries: {
+        relation: Model.HasManyRelation,
+        modelClass: ItemEntry.default,
+        join: {
+          from: 'sales_invoices.id',
+          to: 'items_entries.referenceId',
+        },
+        filter(builder) {
+          builder.where('reference_type', 'SaleInvoice');
+          builder.orderBy('index', 'ASC');
+        },
+      },
+
+      /**
+       * Belongs to customer model.
+       */
+      customer: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Customer.default,
+        join: {
+          from: 'sales_invoices.customerId',
+          to: 'contacts.id',
+        },
+        filter(query) {
+          query.where('contact_service', 'Customer');
+        },
+      },
+
+      /**
+       * Invoice has associated account transactions.
+       */
+      transactions: {
+        relation: Model.HasManyRelation,
+        modelClass: AccountTransaction.default,
+        join: {
+          from: 'sales_invoices.id',
+          to: 'accounts_transactions.referenceId',
+        },
+        filter(builder) {
+          builder.where('reference_type', 'SaleInvoice');
+        },
+      },
+
+      /**
+       *
+       */
+      costTransactions: {
+        relation: Model.HasManyRelation,
+        modelClass: InventoryCostLotTracker.default,
+        join: {
+          from: 'sales_invoices.id',
+          to: 'inventory_cost_lot_tracker.transactionId',
+        },
+        filter(builder) {
+          builder.where('transaction_type', 'SaleInvoice');
+        },
+      },
+
+      /**
+       *
+       */
+      paymentEntries: {
+        relation: Model.HasManyRelation,
+        modelClass: PaymentReceiveEntry.default,
+        join: {
+          from: 'sales_invoices.id',
+          to: 'payment_receives_entries.invoiceId',
+        },
+      },
+
+      /**
+       * Invoice may has associated branch.
+       */
+      branch: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Branch.default,
+        join: {
+          from: 'sales_invoices.branchId',
+          to: 'branches.id',
+        },
+      },
+
+      writtenoffExpenseAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'sales_invoices.writtenoffExpenseAccountId',
+          to: 'accounts.id',
+        },
+      },
+    };
+  }
+
+  /**
+   * Change payment amount.
+   * @param {Integer} invoiceId
+   * @param {Numeric} amount
+   */
+  static async changePaymentAmount(invoiceId, amount, trx) {
+    const changeMethod = amount > 0 ? 'increment' : 'decrement';
+
+    await this.query(trx)
+      .where('id', invoiceId)
+      [changeMethod]('payment_amount', Math.abs(amount));
+  }
+
+  /**
+   * Sale invoice meta.
+   */
+  static get meta() {
+    return SaleInvoiceMeta;
+  }
+
+  static dueAmountFieldSortQuery(query, role) {
+    query.modify('sortByDueAmount', role.order);
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model searchable.
+   */
+  static get searchable() {
+    return true;
+  }
+
+  /**
+   * Model search attributes.
+   */
+  static get searchRoles() {
+    return [
+      { fieldKey: 'invoice_no', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'reference_no', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'amount', comparator: 'equals' },
+    ];
+  }
+
+  /**
+   * Prevents mutate base currency since the model is not empty.
+   */
+  static get preventMutateBaseCurrency() {
+    return true;
+  }
+}
diff --git a/packages/server/src/models/SaleInvoiceEntry.ts b/packages/server/src/models/SaleInvoiceEntry.ts
new file mode 100644
index 000000000..0d081bdb2
--- /dev/null
+++ b/packages/server/src/models/SaleInvoiceEntry.ts
@@ -0,0 +1,29 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class SaleInvoiceEntry extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'sales_invoices_entries';
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const SaleInvoice = require('models/SaleInvoice');
+
+    return {
+      saleInvoice: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: SaleInvoice.default,
+        join: {
+          from: 'sales_invoices_entries.sale_invoice_id',
+          to: 'sales_invoices.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/SaleReceipt.Settings.ts b/packages/server/src/models/SaleReceipt.Settings.ts
new file mode 100644
index 000000000..a844661ed
--- /dev/null
+++ b/packages/server/src/models/SaleReceipt.Settings.ts
@@ -0,0 +1,85 @@
+export default {
+  defaultFilterField: 'receipt_date',
+  defaultSort: {
+    sortOrder: 'DESC',
+    sortField: 'created_at',
+  },
+  fields: {
+    'amount': {
+      name: 'receipt.field.amount',
+      column: 'amount',
+      fieldType: 'number',
+    },
+    'deposit_account': {
+      column: 'deposit_account_id',
+      name: 'receipt.field.deposit_account',
+      fieldType: 'relation',
+
+      relationType: 'enumeration',
+      relationKey: 'depositAccount',
+
+      relationEntityLabel: 'name',
+      relationEntityKey: 'slug',
+    },
+    'customer': {
+      name: 'receipt.field.customer',
+      column: 'customer_id',
+      fieldType: 'relation',
+
+      relationType: 'enumeration',
+      relationKey: 'customer',
+
+      relationEntityLabel: 'display_name',
+      relationEntityKey: 'id',
+    },
+    'receipt_date': {
+      name: 'receipt.field.receipt_date',
+      column: 'receipt_date',
+      fieldType: 'date',
+      
+    },
+    'receipt_number': {
+      name: 'receipt.field.receipt_number',
+      column: 'receipt_number',
+      fieldType: 'text',
+    },
+    'reference_no': {
+      name: 'receipt.field.reference_no',
+      column: 'reference_no',
+      fieldType: 'text',
+    },
+    'receipt_message': {
+      name: 'receipt.field.receipt_message',
+      column: 'receipt_message',
+      fieldType: 'text',
+    },
+    'statement': {
+      name: 'receipt.field.statement',
+      column: 'statement',
+      fieldType: 'text',
+    },
+    'created_at': {
+      name: 'receipt.field.created_at',
+      column: 'created_at',
+      fieldType: 'date',
+    },
+    'status': {
+      name: 'receipt.field.status',
+      fieldType: 'enumeration',
+      options: [
+        { key: 'draft', label: 'receipt.field.status.draft' },
+        { key: 'closed', label: 'receipt.field.status.closed' },
+      ],
+      filterCustomQuery: StatusFieldFilterQuery,
+      sortCustomQuery: StatusFieldSortQuery,
+    },
+  },
+};
+
+function StatusFieldFilterQuery(query, role) {
+  query.modify('filterByStatus', role.value);
+}
+
+function StatusFieldSortQuery(query, role) {
+  query.modify('sortByStatus', role.order);
+}
diff --git a/packages/server/src/models/SaleReceipt.ts b/packages/server/src/models/SaleReceipt.ts
new file mode 100644
index 000000000..4b20ce78f
--- /dev/null
+++ b/packages/server/src/models/SaleReceipt.ts
@@ -0,0 +1,204 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import ModelSetting from './ModelSetting';
+import SaleReceiptSettings from './SaleReceipt.Settings';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import { DEFAULT_VIEWS } from '@/services/Sales/Receipts/constants';
+import ModelSearchable from './ModelSearchable';
+
+export default class SaleReceipt extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'sales_receipts';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['localAmount', 'isClosed', 'isDraft'];
+  }
+
+  /**
+   * Estimate amount in local currency.
+   * @returns {number}
+   */
+  get localAmount() {
+    return this.amount * this.exchangeRate;
+  }
+
+  /**
+   * Detarmine whether the sale receipt closed.
+   * @return {boolean}
+   */
+  get isClosed() {
+    return !!this.closedAt;
+  }
+
+  /**
+   * Detarmines whether the sale receipt drafted.
+   * @return {boolean}
+   */
+  get isDraft() {
+    return !this.closedAt;
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Filters the closed receipts.
+       */
+      closed(query) {
+        query.whereNot('closed_at', null);
+      },
+
+      /**
+       * Filters the invoices in draft status.
+       */
+      draft(query) {
+        query.where('closed_at', null);
+      },
+
+      /**
+       * Sorting the receipts order by status.
+       */
+      sortByStatus(query, order) {
+        query.orderByRaw(`CLOSED_AT IS NULL ${order}`);
+      },
+
+      /**
+       * Filtering the receipts orders by status.
+       */
+      filterByStatus(query, status) {
+        switch (status) {
+          case 'draft':
+            query.modify('draft');
+            break;
+          case 'closed':
+          default:
+            query.modify('closed');
+            break;
+        }
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Customer = require('models/Customer');
+    const Account = require('models/Account');
+    const AccountTransaction = require('models/AccountTransaction');
+    const ItemEntry = require('models/ItemEntry');
+    const Branch = require('models/Branch');
+
+    return {
+      customer: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Customer.default,
+        join: {
+          from: 'sales_receipts.customerId',
+          to: 'contacts.id',
+        },
+        filter(query) {
+          query.where('contact_service', 'customer');
+        },
+      },
+
+      depositAccount: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'sales_receipts.depositAccountId',
+          to: 'accounts.id',
+        },
+      },
+
+      entries: {
+        relation: Model.HasManyRelation,
+        modelClass: ItemEntry.default,
+        join: {
+          from: 'sales_receipts.id',
+          to: 'items_entries.referenceId',
+        },
+        filter(builder) {
+          builder.where('reference_type', 'SaleReceipt');
+          builder.orderBy('index', 'ASC');
+        },
+      },
+
+      transactions: {
+        relation: Model.HasManyRelation,
+        modelClass: AccountTransaction.default,
+        join: {
+          from: 'sales_receipts.id',
+          to: 'accounts_transactions.referenceId',
+        },
+        filter(builder) {
+          builder.where('reference_type', 'SaleReceipt');
+        },
+      },
+
+      /**
+       * Sale receipt may belongs to branch.
+       */
+      branch: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Branch.default,
+        join: {
+          from: 'sales_receipts.branchId',
+          to: 'branches.id',
+        },
+      },
+    };
+  }
+
+  /**
+   * Sale invoice meta.
+   */
+  static get meta() {
+    return SaleReceiptSettings;
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model search attributes.
+   */
+  static get searchRoles() {
+    return [
+      { fieldKey: 'receipt_number', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'reference_no', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'amount', comparator: 'equals' },
+    ];
+  }
+
+  /**
+   * Prevents mutate base currency since the model is not empty.
+   */
+  static get preventMutateBaseCurrency() {
+    return true;
+  }
+}
diff --git a/packages/server/src/models/SaleReceiptEntry.ts b/packages/server/src/models/SaleReceiptEntry.ts
new file mode 100644
index 000000000..1d0f55b5f
--- /dev/null
+++ b/packages/server/src/models/SaleReceiptEntry.ts
@@ -0,0 +1,29 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class SaleReceiptEntry extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'sales_receipt_entries';
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const SaleReceipt = require('models/SaleReceipt');
+
+    return {
+      saleReceipt: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: SaleReceipt.default,
+        join: {
+          from: 'sales_receipt_entries.sale_receipt_id',
+          to: 'sales_receipts.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/Setting.ts b/packages/server/src/models/Setting.ts
new file mode 100644
index 000000000..471fccb66
--- /dev/null
+++ b/packages/server/src/models/Setting.ts
@@ -0,0 +1,21 @@
+import TenantModel from 'models/TenantModel';
+import Auth from './Auth';
+
+export default class Setting extends TenantModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'settings';
+  }
+
+  /**
+   * Extra metadata query to query with the current authenticate user.
+   * @param {Object} query
+   */
+  static extraMetadataQuery(query) {
+    if (Auth.isLogged()) {
+      query.where('user_id', Auth.userId());
+    }
+  }
+}
diff --git a/packages/server/src/models/Task.ts b/packages/server/src/models/Task.ts
new file mode 100644
index 000000000..9843d3a6b
--- /dev/null
+++ b/packages/server/src/models/Task.ts
@@ -0,0 +1,173 @@
+import { mixin, Model, raw } from 'objection';
+import TenantModel from 'models/TenantModel';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import ModelSetting from './ModelSetting';
+import ModelSearchable from './ModelSearchable';
+import { ProjectTaskChargeType } from '@/services/Projects/Tasks/constants';
+import { number } from 'mathjs';
+
+export default class Task extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  type!: string;
+  rate!: number;
+  actualHours!: number;
+  invoicedHours!: number;
+  estimateHours!: number;
+
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'tasks';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return [
+      'actualAmount',
+      'invoicedAmount',
+      'estimateAmount',
+      'billableAmount',
+      'billableHours',
+    ];
+  }
+
+  /**
+   * Retrieves the actual amount.
+   */
+  get actualAmount(): number {
+    return this.rate * this.actualHours;
+  }
+
+  /**
+   * Retrieves the invoiced amount.
+   */
+  get invoicedAmount(): number {
+    return this.rate * this.invoicedHours;
+  }
+
+  /**
+   * Retrieves the estimate amount.
+   */
+  get estimateAmount(): number {
+    return this.rate * this.estimateHours;
+  }
+
+  /**
+   * Retrieves the billable amount.
+   */
+  get billableAmount() {
+    return this.actualAmount - this.invoicedAmount;
+  }
+
+  /**
+   * Retrieves the billable hours.
+   */
+  get billableHours() {
+    return this.actualHours - this.invoicedHours;
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Sumation of total actual hours.
+       * @param builder
+       */
+      sumTotalActualHours(builder) {
+        builder.sum('actualHours as totalActualHours');
+      },
+
+      /**
+       * Sumation total estimate hours.
+       * @param builder
+       */
+      sumTotalEstimateHours(builder) {
+        builder.sum('estimateHours as totalEstimateHours');
+      },
+
+      /**
+       * Sumation of total invoiced hours.
+       * @param builder
+       */
+      sumTotalInvoicedHours(builder) {
+        builder.sum('invoicedHours as totalInvoicedHours');
+      },
+
+      /**
+       * Sumation of total actual amount.
+       * @param builder
+       */
+      sumTotalActualAmount(builder) {
+        builder.groupBy('totalActualAmount');
+        builder.select(raw('ACTUAL_HOURS * RATE').as('totalActualAmount'));
+      },
+
+      /**
+       * Sumation of total invoiced amount.
+       * @param builder
+       */
+      sumTotalInvoicedAmount(builder) {
+        this.groupBy('totalInvoicedAmount');
+        builder.select(raw('INVOICED_HOURS * RATE').as('totalInvoicedAmount'));
+      },
+
+      /**
+       * Sumation of total estimate amount.
+       * @param builder
+       */
+      sumTotalEstimateAmount(builder) {
+        builder.groupBy('totalEstimateAmount');
+        builder.select(raw('ESTIMATE_HOURS * RATE').as('totalEstimateAmount'));
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Time = require('models/Time');
+    const Project = require('models/Project');
+
+    return {
+      /**
+       * Project may has many associated tasks.
+       */
+      times: {
+        relation: Model.HasManyRelation,
+        modelClass: Time.default,
+        join: {
+          from: 'tasks.id',
+          to: 'times.taskId',
+        },
+      },
+
+      /**
+       * Project may has many associated times.
+       */
+      project: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Project.default,
+        join: {
+          from: 'tasks.projectId',
+          to: 'projects.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/TenantModel.ts b/packages/server/src/models/TenantModel.ts
new file mode 100644
index 000000000..9fbc9739e
--- /dev/null
+++ b/packages/server/src/models/TenantModel.ts
@@ -0,0 +1,22 @@
+import { Container } from 'typedi';
+import BaseModel from 'models/Model';
+
+export default class TenantModel extends BaseModel {
+  /**
+   * Logging all tenant databases queries.
+   * @param  {...any} args 
+   */
+  static query(...args) {
+    const Logger = Container.get('logger');
+
+    return super.query(...args).onBuildKnex((knexQueryBuilder) => {
+      const { userParams: { tenantId } } = knexQueryBuilder.client.config;
+
+      knexQueryBuilder.on('query', queryData => {
+        Logger.info(`[query][tenant] ${queryData.sql}`, {
+          bindings: queryData.bindings, tenantId
+        });
+      });
+    });
+  }
+}
diff --git a/packages/server/src/models/Time.ts b/packages/server/src/models/Time.ts
new file mode 100644
index 000000000..7977edf5d
--- /dev/null
+++ b/packages/server/src/models/Time.ts
@@ -0,0 +1,66 @@
+import { mixin, Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import ModelSetting from './ModelSetting';
+import ModelSearchable from './ModelSearchable';
+
+export default class Time extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'times';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return [];
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Task = require('models/Task');
+    const Project = require('models/Project');
+
+    return {
+      /**
+       * Project may has many associated tasks.
+       */
+      task: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Task.default,
+        join: {
+          from: 'times.taskId',
+          to: 'tasks.id',
+        },
+      },
+
+      /**
+       * Project may has many associated times.
+       */
+      project: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Project.default,
+        join: {
+          from: 'times.projectId',
+          to: 'projects.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/User.ts b/packages/server/src/models/User.ts
new file mode 100644
index 000000000..81144edad
--- /dev/null
+++ b/packages/server/src/models/User.ts
@@ -0,0 +1,60 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class User extends TenantModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'users';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['isInviteAccepted', 'fullName'];
+  }
+
+  /**
+   * Detarmines whether the user ivnite is accept.
+   */
+  get isInviteAccepted() {
+    return !!this.inviteAcceptedAt;
+  }
+
+  /**
+   * Full name attribute.
+   */
+  get fullName() {
+    return `${this.firstName} ${this.lastName}`.trim();
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Role = require('models/Role');
+
+    return {
+      /**
+       * User belongs to user.
+       */
+      role: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Role.default,
+        join: {
+          from: 'users.roleId',
+          to: 'roles.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/Vendor.Settings.ts b/packages/server/src/models/Vendor.Settings.ts
new file mode 100644
index 000000000..ba964edab
--- /dev/null
+++ b/packages/server/src/models/Vendor.Settings.ts
@@ -0,0 +1,92 @@
+export default {
+  defaultFilterField: 'display_name',
+  defaultSort: {
+    sortOrder: 'DESC',
+    sortField: 'created_at',
+  },
+  fields: {
+    first_name: {
+      name: 'vendor.field.first_name',
+      column: 'first_name',
+      fieldType: 'text',
+    },
+    last_name: {
+      name: 'vendor.field.last_name',
+      column: 'last_name',
+      fieldType: 'text',
+    },
+    display_name: {
+      name: 'vendor.field.display_name',
+      column: 'display_name',
+      fieldType: 'text',
+    },
+    email: {
+      name: 'vendor.field.email',
+      column: 'email',
+      fieldType: 'text',
+    },
+    work_phone: {
+      name: 'vendor.field.work_phone',
+      column: 'work_phone',
+      fieldType: 'text',
+    },
+    personal_phone: {
+      name: 'vendor.field.personal_pone',
+      column: 'personal_phone',
+      fieldType: 'text',
+    },
+    company_name: {
+      name: 'vendor.field.company_name',
+      column: 'company_name',
+      fieldType: 'text',
+    },
+    website: {
+      name: 'vendor.field.website',
+      column: 'website',
+      fieldType: 'text',
+    },
+    created_at: {
+      name: 'vendor.field.created_at',
+      column: 'created_at',
+      fieldType: 'date',
+    },
+    balance: {
+      name: 'vendor.field.balance',
+      column: 'balance',
+      fieldType: 'number',
+    },
+    opening_balance: {
+      name: 'vendor.field.opening_balance',
+      column: 'opening_balance',
+      fieldType: 'number',
+    },
+    opening_balance_at: {
+      name: 'vendor.field.opening_balance_at',
+      column: 'opening_balance_at',
+      fieldType: 'date',
+    },
+    currency_code: {
+      name: 'vendor.field.currency',
+      column: 'currency_code',
+      fieldType: 'text',
+    },
+    status: {
+      name: 'vendor.field.status',
+      type: 'enumeration',
+      options: [
+        { key: 'overdue', label: 'vendor.field.status.overdue' },
+        { key: 'unpaid', label: 'vendor.field.status.unpaid' },
+      ],
+      filterCustomQuery: (query, role) => {
+        switch (role.value) {
+          case 'overdue':
+            query.modify('overdue');
+            break;
+          case 'unpaid':
+            query.modify('unpaid');
+            break;
+        }
+      },
+    },
+  },
+};
diff --git a/packages/server/src/models/Vendor.ts b/packages/server/src/models/Vendor.ts
new file mode 100644
index 000000000..58cefbdac
--- /dev/null
+++ b/packages/server/src/models/Vendor.ts
@@ -0,0 +1,179 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import PaginationQueryBuilder from './Pagination';
+import ModelSetting from './ModelSetting';
+import VendorSettings from './Vendor.Settings';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import { DEFAULT_VIEWS } from '@/services/Contacts/Vendors/constants';
+import ModelSearchable from './ModelSearchable';
+
+class VendorQueryBuilder extends PaginationQueryBuilder {
+  constructor(...args) {
+    super(...args);
+
+    this.onBuild((builder) => {
+      if (builder.isFind() || builder.isDelete() || builder.isUpdate()) {
+        builder.where('contact_service', 'vendor');
+      }
+    });
+  }
+}
+
+export default class Vendor extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Query builder.
+   */
+  static get QueryBuilder() {
+    return VendorQueryBuilder;
+  }
+
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'contacts';
+  }
+
+  /**
+   * Model timestamps.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Defined virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['closingBalance', 'contactNormal', 'localOpeningBalance'];
+  }
+
+  /**
+   * Closing balance attribute.
+   */
+  get closingBalance() {
+    return this.balance;
+  }
+
+  /**
+   * Retrieves the local opening balance.
+   * @returns {number}
+   */
+  get localOpeningBalance() {
+    return this.openingBalance
+      ? this.openingBalance * this.openingBalanceExchangeRate
+      : 0;
+  }
+
+  /**
+   * Retrieve the contact noraml;
+   */
+  get contactNormal() {
+    return 'debit';
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Inactive/Active mode.
+       */
+      inactiveMode(query, active = false) {
+        query.where('active', !active);
+      },
+
+      /**
+       * Filters the active customers.
+       */
+      active(query) {
+        query.where('active', 1);
+      },
+      /**
+       * Filters the inactive customers.
+       */
+      inactive(query) {
+        query.where('active', 0);
+      },
+      /**
+       * Filters the vendors that have overdue invoices.
+       */
+      overdue(query) {
+        query.select(
+          '*',
+          Vendor.relatedQuery('overdueBills', query.knex())
+            .count()
+            .as('countOverdue')
+        );
+        query.having('countOverdue', '>', 0);
+      },
+      /**
+       * Filters the unpaid customers.
+       */
+      unpaid(query) {
+        query.whereRaw('`BALANCE` + `OPENING_BALANCE` <> 0');
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Bill = require('models/Bill');
+
+    return {
+      bills: {
+        relation: Model.HasManyRelation,
+        modelClass: Bill.default,
+        join: {
+          from: 'contacts.id',
+          to: 'bills.vendorId',
+        },
+      },
+      overdueBills: {
+        relation: Model.HasManyRelation,
+        modelClass: Bill.default,
+        join: {
+          from: 'contacts.id',
+          to: 'bills.vendorId',
+        },
+        filter: (query) => {
+          query.modify('overdue');
+        },
+      },
+    };
+  }
+
+  static get meta() {
+    return VendorSettings;
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model search attributes.
+   */
+  static get searchRoles() {
+    return [
+      { fieldKey: 'display_name', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'first_name', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'last_name', comparator: 'equals' },
+      { condition: 'or', fieldKey: 'company_name', comparator: 'equals' },
+      { condition: 'or', fieldKey: 'email', comparator: 'equals' },
+      { condition: 'or', fieldKey: 'work_phone', comparator: 'equals' },
+      { condition: 'or', fieldKey: 'personal_phone', comparator: 'equals' },
+      { condition: 'or', fieldKey: 'website', comparator: 'equals' },
+    ];
+  }
+}
diff --git a/packages/server/src/models/VendorCredit.Meta.ts b/packages/server/src/models/VendorCredit.Meta.ts
new file mode 100644
index 000000000..27bd16c70
--- /dev/null
+++ b/packages/server/src/models/VendorCredit.Meta.ts
@@ -0,0 +1,75 @@
+function StatusFieldFilterQuery(query, role) {
+  query.modify('filterByStatus', role.value);
+}
+
+function StatusFieldSortQuery(query, role) {
+  query.modify('sortByStatus', role.order);
+}
+
+export default {
+  defaultFilterField: 'name',
+  defaultSort: {
+    sortOrder: 'DESC',
+    sortField: 'name',
+  },
+  fields: {
+    vendor: {
+      name: 'vendor_credit.field.vendor',
+      column: 'vendor_id',
+      fieldType: 'relation',
+
+      relationType: 'enumeration',
+      relationKey: 'vendor',
+
+      relationEntityLabel: 'display_name',
+      relationEntityKey: 'id',
+    },
+    amount: {
+      name: 'vendor_credit.field.amount',
+      column: 'amount',
+      fieldType: 'number',
+    },
+    currency_code: {
+      name: 'vendor_credit.field.currency_code',
+      column: 'currency_code',
+      fieldType: 'string',
+    },
+    credit_date: {
+      name: 'vendor_credit.field.credit_date',
+      column: 'vendor_credit_date',
+      fieldType: 'date',
+    },
+    reference_no: {
+      name: 'vendor_credit.field.reference_no',
+      column: 'reference_no',
+      fieldType: 'text',
+    },
+    credit_number: {
+      name: 'vendor_credit.field.credit_number',
+      column: 'vendor_credit_number',
+      fieldType: 'text',
+    },
+    note: {
+      name: 'vendor_credit.field.note',
+      column: 'note',
+      fieldType: 'text',
+    },
+    status: {
+      name: 'vendor_credit.field.status',
+      fieldType: 'enumeration',
+      options: [
+        { key: 'draft', label: 'vendor_credit.field.status.draft' },
+        { key: 'published', label: 'vendor_credit.field.status.published' },
+        { key: 'open', label: 'vendor_credit.field.status.open' },
+        { key: 'closed', label: 'vendor_credit.field.status.closed' },
+      ],
+      filterCustomQuery: StatusFieldFilterQuery,
+      sortCustomQuery: StatusFieldSortQuery,
+    },
+    created_at: {
+      name: 'vendor_credit.field.created_at',
+      column: 'created_at',
+      fieldType: 'date',
+    },
+  },
+};
diff --git a/packages/server/src/models/VendorCredit.ts b/packages/server/src/models/VendorCredit.ts
new file mode 100644
index 000000000..61f7e8241
--- /dev/null
+++ b/packages/server/src/models/VendorCredit.ts
@@ -0,0 +1,253 @@
+import { Model, raw, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import BillSettings from './Bill.Settings';
+import ModelSetting from './ModelSetting';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import { DEFAULT_VIEWS } from '@/services/Purchases/VendorCredits/constants';
+import ModelSearchable from './ModelSearchable';
+import VendorCreditMeta from './VendorCredit.Meta';
+
+export default class VendorCredit extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'vendor_credits';
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['localAmount'];
+  }
+
+  /**
+   * Vendor credit amount in local currency.
+   * @returns {number}
+   */
+  get localAmount() {
+    return this.amount * this.exchangeRate;
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Filters the credit notes in draft status.
+       */
+      draft(query) {
+        query.where('opened_at', null);
+      },
+
+      /**
+       * Filters the published vendor credits.
+       */
+      published(query) {
+        query.whereNot('opened_at', null);
+      },
+
+      /**
+       * Filters the open vendor credits.
+       */
+      open(query) {
+        query
+          .where(
+            raw(`COALESCE(REFUNDED_AMOUNT) + COALESCE(INVOICED_AMOUNT) <
+            COALESCE(AMOUNT)`)
+          )
+          .modify('published');
+      },
+
+      /**
+       * Filters the closed vendor credits.
+       */
+      closed(query) {
+        query
+          .where(
+            raw(`COALESCE(REFUNDED_AMOUNT) + COALESCE(INVOICED_AMOUNT) =
+            COALESCE(AMOUNT)`)
+          )
+          .modify('published');
+      },
+
+      /**
+       * Status filter.
+       */
+      filterByStatus(query, filterType) {
+        switch (filterType) {
+          case 'draft':
+            query.modify('draft');
+            break;
+          case 'published':
+            query.modify('published');
+            break;
+          case 'open':
+          default:
+            query.modify('open');
+            break;
+          case 'closed':
+            query.modify('closed');
+            break;
+        }
+      },
+
+      /**
+       *
+       */
+      sortByStatus(query, order) {
+        query.orderByRaw(
+          `COALESCE(REFUNDED_AMOUNT) + COALESCE(INVOICED_AMOUNT) = COALESCE(AMOUNT) ${order}`
+        );
+      },
+    };
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['isDraft', 'isPublished', 'isOpen', 'isClosed', 'creditsRemaining'];
+  }
+
+  /**
+   * Detarmines whether the vendor credit is draft.
+   * @returns {boolean}
+   */
+  get isDraft() {
+    return !this.openedAt;
+  }
+
+  /**
+   * Detarmines whether vendor credit is published.
+   * @returns {boolean}
+   */
+  get isPublished() {
+    return !!this.openedAt;
+  }
+
+  /**
+   * Detarmines whether the credit note is open.
+   * @return {boolean}
+   */
+  get isOpen() {
+    return !!this.openedAt && this.creditsRemaining > 0;
+  }
+
+  /**
+   * Detarmines whether the credit note is closed.
+   * @return {boolean}
+   */
+  get isClosed() {
+    return this.openedAt && this.creditsRemaining === 0;
+  }
+
+  /**
+   * Retrieve the credits remaining.
+   * @returns {number}
+   */
+  get creditsRemaining() {
+    return Math.max(this.amount - this.refundedAmount - this.invoicedAmount, 0);
+  }
+
+  /**
+   * Bill model settings.
+   */
+  static get meta() {
+    return BillSettings;
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Vendor = require('models/Vendor');
+    const ItemEntry = require('models/ItemEntry');
+    const Branch = require('models/Branch');
+
+    return {
+      vendor: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Vendor.default,
+        join: {
+          from: 'vendor_credits.vendorId',
+          to: 'contacts.id',
+        },
+        filter(query) {
+          query.where('contact_service', 'vendor');
+        },
+      },
+
+      entries: {
+        relation: Model.HasManyRelation,
+        modelClass: ItemEntry.default,
+        join: {
+          from: 'vendor_credits.id',
+          to: 'items_entries.referenceId',
+        },
+        filter(builder) {
+          builder.where('reference_type', 'VendorCredit');
+          builder.orderBy('index', 'ASC');
+        },
+      },
+
+      /**
+       * Vendor credit may belongs to branch.
+       */
+      branch: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Branch.default,
+        join: {
+          from: 'vendor_credits.branchId',
+          to: 'branches.id',
+        },
+      },
+    };
+  }
+
+  /**
+   *
+   */
+  static get meta() {
+    return VendorCreditMeta;
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model search attributes.
+   */
+  static get searchRoles() {
+    return [
+      { fieldKey: 'credit_number', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'reference_no', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'amount', comparator: 'equals' },
+    ];
+  }
+
+  /**
+   * Prevents mutate base currency since the model is not empty.
+   * @returns {boolean}
+   */
+  static get preventMutateBaseCurrency() {
+    return true;
+  }
+}
diff --git a/packages/server/src/models/VendorCreditAppliedBill.ts b/packages/server/src/models/VendorCreditAppliedBill.ts
new file mode 100644
index 000000000..c67aaaf4c
--- /dev/null
+++ b/packages/server/src/models/VendorCreditAppliedBill.ts
@@ -0,0 +1,53 @@
+import { mixin, Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+import ModelSetting from './ModelSetting';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import ModelSearchable from './ModelSearchable';
+
+export default class VendorCreditAppliedBill extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'vendor_credit_applied_bill';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Bill = require('models/Bill');
+    const VendorCredit = require('models/VendorCredit');
+
+    return {
+      bill: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Bill.default,
+        join: {
+          from: 'vendor_credit_applied_bill.billId',
+          to: 'bills.id',
+        },
+      },
+
+      vendorCredit: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: VendorCredit.default,
+        join: {
+          from: 'vendor_credit_applied_bill.vendorCreditId',
+          to: 'vendor_credits.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/View.ts b/packages/server/src/models/View.ts
new file mode 100644
index 000000000..2745326fd
--- /dev/null
+++ b/packages/server/src/models/View.ts
@@ -0,0 +1,72 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class View extends TenantModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'views';
+  }
+
+  /**
+   * Model timestamps.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  static get modifiers() {
+    const TABLE_NAME = View.tableName;
+
+    return {
+      allMetadata(query) {
+        query.withGraphFetched('roles.field');
+        query.withGraphFetched('columns');
+      },
+
+      specificOrFavourite(query, viewId) {
+        if (viewId) {
+          query.where('id', viewId)
+        } else {
+          query.where('favourite', true);
+        }
+        return query;
+      }
+    }
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const ViewColumn = require('models/ViewColumn');
+    const ViewRole = require('models/ViewRole');
+
+    return {
+      /**
+       * View model may has many columns.
+       */
+      columns: {
+        relation: Model.HasManyRelation,
+        modelClass: ViewColumn.default,
+        join: {
+          from: 'views.id',
+          to: 'view_has_columns.viewId',
+        },
+      },
+
+      /**
+       * View model may has many view roles.
+       */
+      roles: {
+        relation: Model.HasManyRelation,
+        modelClass: ViewRole.default,
+        join: {
+          from: 'views.id',
+          to: 'view_roles.viewId',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/ViewColumn.ts b/packages/server/src/models/ViewColumn.ts
new file mode 100644
index 000000000..d3dc38e49
--- /dev/null
+++ b/packages/server/src/models/ViewColumn.ts
@@ -0,0 +1,21 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class ViewColumn extends TenantModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'view_has_columns';
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+
+    return {
+
+    };
+  }
+}
diff --git a/packages/server/src/models/ViewRole.ts b/packages/server/src/models/ViewRole.ts
new file mode 100644
index 000000000..24fe1f0da
--- /dev/null
+++ b/packages/server/src/models/ViewRole.ts
@@ -0,0 +1,46 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class ViewRole extends TenantModel {
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['comparators'];
+  }
+
+  static get comparators() {
+    return [
+      'equals', 'not_equal', 'contains', 'not_contain',
+    ];
+  }
+
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'view_roles';
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const View = require('models/View');
+
+    return {
+      /**
+       * View role model may belongs to view model.
+       */
+      view: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: View.default,
+        join: {
+          from: 'view_roles.viewId',
+          to: 'views.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/Warehouse.ts b/packages/server/src/models/Warehouse.ts
new file mode 100644
index 000000000..12058d396
--- /dev/null
+++ b/packages/server/src/models/Warehouse.ts
@@ -0,0 +1,162 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class Warehouse extends TenantModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'warehouses';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Filters accounts by the given ids.
+       * @param {Query} query
+       * @param {number[]} accountsIds
+       */
+      isPrimary(query) {
+        query.where('primary', true);
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const SaleInvoice = require('models/SaleInvoice');
+    const SaleEstimate = require('models/SaleEstimate');
+    const SaleReceipt = require('models/SaleReceipt');
+    const Bill = require('models/Bill');
+    const VendorCredit = require('models/VendorCredit');
+    const CreditNote = require('models/CreditNote');
+    const InventoryTransaction = require('models/InventoryTransaction');
+    const WarehouseTransfer = require('models/WarehouseTransfer');
+    const InventoryAdjustment = require('models/InventoryAdjustment');
+
+    return {
+      /**
+       * Warehouse may belongs to associated sale invoices.
+       */
+      invoices: {
+        relation: Model.HasManyRelation,
+        modelClass: SaleInvoice.default,
+        join: {
+          from: 'warehouses.id',
+          to: 'sales_invoices.warehouseId',
+        },
+      },
+
+      /**
+       * Warehouse may belongs to associated sale estimates.
+       */
+      estimates: {
+        relation: Model.HasManyRelation,
+        modelClass: SaleEstimate.default,
+        join: {
+          from: 'warehouses.id',
+          to: 'sales_estimates.warehouseId',
+        },
+      },
+
+      /**
+       * Warehouse may belongs to associated sale receipts.
+       */
+      receipts: {
+        relation: Model.HasManyRelation,
+        modelClass: SaleReceipt.default,
+        join: {
+          from: 'warehouses.id',
+          to: 'sales_receipts.warehouseId',
+        },
+      },
+
+      /**
+       * Warehouse may belongs to assocaited bills.
+       */
+      bills: {
+        relation: Model.HasManyRelation,
+        modelClass: Bill.default,
+        join: {
+          from: 'warehouses.id',
+          to: 'bills.warehouseId',
+        },
+      },
+
+      /**
+       * Warehouse may belongs to associated credit notes.
+       */
+      creditNotes: {
+        relation: Model.HasManyRelation,
+        modelClass: CreditNote.default,
+        join: {
+          from: 'warehouses.id',
+          to: 'credit_notes.warehouseId',
+        },
+      },
+
+      /**
+       * Warehouse may belongs to associated to vendor credits.
+       */
+      vendorCredit: {
+        relation: Model.HasManyRelation,
+        modelClass: VendorCredit.default,
+        join: {
+          from: 'warehouses.id',
+          to: 'vendor_credits.warehouseId',
+        },
+      },
+
+      /**
+       * Warehouse may belongs to associated to inventory transactions.
+       */
+      inventoryTransactions: {
+        relation: Model.HasManyRelation,
+        modelClass: InventoryTransaction.default,
+        join: {
+          from: 'warehouses.id',
+          to: 'inventory_transactions.warehouseId',
+        },
+      },
+
+      warehouseTransferTo: {
+        relation: Model.HasManyRelation,
+        modelClass: WarehouseTransfer.default,
+        join: {
+          from: 'warehouses.id',
+          to: 'warehouses_transfers.toWarehouseId',
+        },
+      },
+
+      warehouseTransferFrom: {
+        relation: Model.HasManyRelation,
+        modelClass: WarehouseTransfer.default,
+        join: {
+          from: 'warehouses.id',
+          to: 'warehouses_transfers.fromWarehouseId',
+        },
+      },
+
+      inventoryAdjustment: {
+        relation: Model.HasManyRelation,
+        modelClass: InventoryAdjustment.default,
+        join: {
+          from: 'warehouses.id',
+          to: 'inventory_adjustments.warehouseId',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/WarehouseTransfer.Settings.ts b/packages/server/src/models/WarehouseTransfer.Settings.ts
new file mode 100644
index 000000000..8d0bc635d
--- /dev/null
+++ b/packages/server/src/models/WarehouseTransfer.Settings.ts
@@ -0,0 +1,41 @@
+function StatusFieldFilterQuery(query, role) {
+  query.modify('filterByStatus', role.value);
+}
+
+export default {
+  defaultFilterField: 'name',
+  defaultSort: {
+    sortField: 'name',
+    sortOrder: 'DESC',
+  },
+  fields: {
+    date: {
+      name: 'warehouse_transfer.field.date',
+      column: 'date',
+      columnType: 'date',
+      fieldType: 'date',
+    },
+    transaction_number: {
+      name: 'warehouse_transfer.field.transaction_number',
+      column: 'transaction_number',
+      fieldType: 'text',
+    },
+    status: {
+      name: 'warehouse_transfer.field.status',
+      fieldType: 'enumeration',
+      options: [
+        { key: 'draft', label: 'Draft' },
+        { key: 'in-transit', label: 'In Transit' },
+        { key: 'transferred', label: 'Transferred' },
+      ],
+      filterCustomQuery: StatusFieldFilterQuery,
+      sortable: false,
+    },
+    created_at: {
+      name: 'warehouse_transfer.field.created_at',
+      column: 'created_at',
+      columnType: 'date',
+      fieldType: 'date',
+    },
+  },
+};
diff --git a/packages/server/src/models/WarehouseTransfer.ts b/packages/server/src/models/WarehouseTransfer.ts
new file mode 100644
index 000000000..82957dfeb
--- /dev/null
+++ b/packages/server/src/models/WarehouseTransfer.ts
@@ -0,0 +1,148 @@
+import { Model, mixin } from 'objection';
+import TenantModel from 'models/TenantModel';
+import WarehouseTransferSettings from './WarehouseTransfer.Settings';
+import ModelSearchable from './ModelSearchable';
+import CustomViewBaseModel from './CustomViewBaseModel';
+import ModelSetting from './ModelSetting';
+import { DEFAULT_VIEWS } from '../services/Warehouses/WarehousesTransfers/constants';
+
+export default class WarehouseTransfer extends mixin(TenantModel, [
+  ModelSetting,
+  CustomViewBaseModel,
+  ModelSearchable,
+]) {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'warehouses_transfers';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['created_at', 'updated_at'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['isInitiated', 'isTransferred'];
+  }
+
+  /**
+   * Detarmines whether the warehouse transfer initiated.
+   * @retruns {boolean}
+   */
+  get isInitiated() {
+    return !!this.transferInitiatedAt;
+  }
+
+  /**
+   * Detarmines whether the warehouse transfer transferred.
+   * @returns {boolean}
+   */
+  get isTransferred() {
+    return !!this.transferDeliveredAt;
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      filterByDraft(query) {
+        query.whereNull('transferInitiatedAt');
+        query.whereNull('transferDeliveredAt');
+      },
+      filterByInTransit(query) {
+        query.whereNotNull('transferInitiatedAt');
+        query.whereNull('transferDeliveredAt');
+      },
+      filterByTransferred(query) {
+        query.whereNotNull('transferInitiatedAt');
+        query.whereNotNull('transferDeliveredAt');
+      },
+      filterByStatus(query, status) {
+        switch (status) {
+          case 'draft':
+          default:
+            return query.modify('filterByDraft');
+          case 'in-transit':
+            return query.modify('filterByInTransit');
+          case 'transferred':
+            return query.modify('filterByTransferred');
+        }
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const WarehouseTransferEntry = require('models/WarehouseTransferEntry');
+    const Warehouse = require('models/Warehouse');
+
+    return {
+      /**
+       * View model may has many columns.
+       */
+      entries: {
+        relation: Model.HasManyRelation,
+        modelClass: WarehouseTransferEntry.default,
+        join: {
+          from: 'warehouses_transfers.id',
+          to: 'warehouses_transfers_entries.warehouseTransferId',
+        },
+      },
+
+      /**
+       *
+       */
+      fromWarehouse: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Warehouse.default,
+        join: {
+          from: 'warehouses_transfers.fromWarehouseId',
+          to: 'warehouses.id',
+        },
+      },
+
+      toWarehouse: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Warehouse.default,
+        join: {
+          from: 'warehouses_transfers.toWarehouseId',
+          to: 'warehouses.id',
+        },
+      },
+    };
+  }
+
+  /**
+   * Model settings.
+   */
+  static get meta() {
+    return WarehouseTransferSettings;
+  }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  static get defaultViews() {
+    return DEFAULT_VIEWS;
+  }
+
+  /**
+   * Model search roles.
+   */
+  static get searchRoles() {
+    return [
+      // { fieldKey: 'name', comparator: 'contains' },
+      // { condition: 'or', fieldKey: 'code', comparator: 'like' },
+    ];
+  }
+}
diff --git a/packages/server/src/models/WarehouseTransferEntry.ts b/packages/server/src/models/WarehouseTransferEntry.ts
new file mode 100644
index 000000000..2fba52495
--- /dev/null
+++ b/packages/server/src/models/WarehouseTransferEntry.ts
@@ -0,0 +1,44 @@
+import { Model } from 'objection';
+import TenantModel from 'models/TenantModel';
+
+export default class Warehouse extends TenantModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'warehouses_transfers_entries';
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['total'];
+  }
+
+  /**
+   * Invoice amount in local currency.
+   * @returns {number}
+   */
+  get total() {
+    return this.cost * this.quantity;
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Item = require('models/Item');
+
+    return {
+      item: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Item.default,
+        join: {
+          from: 'warehouses_transfers_entries.itemId',
+          to: 'items.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/models/index.ts b/packages/server/src/models/index.ts
new file mode 100644
index 000000000..5196acd92
--- /dev/null
+++ b/packages/server/src/models/index.ts
@@ -0,0 +1,55 @@
+import Option from './Option';
+import Setting from './Setting';
+import SaleEstimate from './SaleEstimate';
+import SaleEstimateEntry from './SaleEstimateEntry';
+import SaleReceipt from './SaleReceipt';
+import SaleReceiptEntry from './SaleReceiptEntry';
+import Item from './Item';
+import Account from './Account';
+import AccountTransaction from './AccountTransaction';
+import SaleInvoice from './SaleInvoice';
+import SaleInvoiceEntry from './SaleInvoiceEntry';
+import PaymentReceive from './PaymentReceive';
+import PaymentReceiveEntry from './PaymentReceiveEntry';
+import Bill from './Bill';
+import BillPayment from './BillPayment';
+import BillPaymentEntry from './BillPaymentEntry';
+import View from './View';
+import ItemEntry from './ItemEntry';
+import InventoryTransaction from './InventoryTransaction';
+import InventoryLotCostTracker from './InventoryCostLotTracker';
+import Customer from './Customer';
+import Contact from './Contact';
+import Vendor from './Vendor';
+import ExpenseCategory from './ExpenseCategory';
+import Expense from './Expense';
+import ManualJournal from './ManualJournal';
+
+export {
+  SaleEstimate,
+  SaleEstimateEntry,
+  SaleReceipt,
+  SaleReceiptEntry,
+  SaleInvoice,
+  SaleInvoiceEntry,
+  Item,
+  Account,
+  AccountTransaction,
+  PaymentReceive,
+  PaymentReceiveEntry,
+  Bill,
+  BillPayment,
+  BillPaymentEntry,
+  View,
+  ItemEntry,
+  InventoryTransaction,
+  InventoryLotCostTracker,
+  Option,
+  Contact,
+  ExpenseCategory,
+  Expense,
+  ManualJournal,
+  Customer,
+  Vendor,
+  Setting
+};
\ No newline at end of file
diff --git a/packages/server/src/repositories/AccountRepository.ts b/packages/server/src/repositories/AccountRepository.ts
new file mode 100644
index 000000000..decde91f5
--- /dev/null
+++ b/packages/server/src/repositories/AccountRepository.ts
@@ -0,0 +1,158 @@
+import { Account } from 'models';
+import TenantRepository from '@/repositories/TenantRepository';
+import { IAccount } from '@/interfaces';
+import { Knex } from 'knex';
+
+export default class AccountRepository extends TenantRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return Account.bindKnex(this.knex);
+  }
+
+  /**
+   * Retrieve accounts dependency graph.
+   * @returns {}
+   */
+  async getDependencyGraph(withRelation, trx) {
+    const accounts = await this.all(withRelation, trx);
+
+    return this.model.toDependencyGraph(accounts);
+  }
+
+  /**
+   * Retrieve.
+   * @param {string} slug
+   * @return {Promise<IAccount>}
+   */
+  findBySlug(slug: string) {
+    return this.findOne({ slug });
+  }
+
+  /**
+   * Changes account balance.
+   * @param {number} accountId
+   * @param {number} amount
+   * @return {Promise<void>}
+   */
+  async balanceChange(accountId: number, amount: number): Promise<void> {
+    const method: string = amount < 0 ? 'decrement' : 'increment';
+
+    await this.model.query().where('id', accountId)[method]('amount', amount);
+    this.flushCache();
+  }
+
+  /**
+   * Activate user by the given id.
+   * @param  {number} userId - User id.
+   * @return {Promise<void>}
+   */
+  activateById(userId: number): Promise<IAccount> {
+    return super.update({ active: 1 }, { id: userId });
+  }
+
+  /**
+   * Inactivate user by the given id.
+   * @param  {number} userId - User id.
+   * @return {Promise<void>}
+   */
+  inactivateById(userId: number): Promise<void> {
+    return super.update({ active: 0 }, { id: userId });
+  }
+
+  /**
+   * Activate user by the given id.
+   * @param  {number} userId - User id.
+   * @return {Promise<void>}
+   */
+  async activateByIds(userIds: number[], trx): Promise<IAccount> {
+    const results = await this.model
+      .query(trx)
+      .whereIn('id', userIds)
+      .patch({ active: true });
+
+    this.flushCache();
+    return results;
+  }
+
+  /**
+   * Inactivate user by the given id.
+   * @param  {number} userId - User id.
+   * @return {Promise<void>}
+   */
+  async inactivateByIds(userIds: number[], trx): Promise<IAccount> {
+    const results = await this.model
+      .query(trx)
+      .whereIn('id', userIds)
+      .patch({ active: false });
+
+    this.flushCache();
+    return results;
+  }
+
+  /**
+   *
+   * @param {string} currencyCode
+   * @param extraAttrs
+   * @param trx
+   * @returns
+   */
+  findOrCreateAccountReceivable = async (
+    currencyCode: string = '',
+    extraAttrs = {},
+    trx?: Knex.Transaction
+  ) => {
+    let result = await this.model
+      .query(trx)
+      .onBuild((query) => {
+        if (currencyCode) {
+          query.where('currencyCode', currencyCode);
+        }
+        query.where('accountType', 'accounts-receivable');
+      })
+      .first();
+
+    if (!result) {
+      result = await this.model.query(trx).insertAndFetch({
+        name: this.i18n.__('account.accounts_receivable.currency', {
+          currency: currencyCode
+        }),
+        accountType: 'accounts-receivable',
+        currencyCode,
+        active: 1,
+        ...extraAttrs,
+      });
+    }
+    return result;
+  };
+
+  findOrCreateAccountsPayable = async (
+    currencyCode: string = '',
+    extraAttrs = {},
+    trx?: Knex.Transaction
+  ) => {
+    let result = await this.model
+      .query(trx)
+      .onBuild((query) => {
+        if (currencyCode) {
+          query.where('currencyCode', currencyCode);
+        }
+        query.where('accountType', 'accounts-payable');
+      })
+      .first();
+
+    if (!result) {
+      result = await this.model.query(trx).insertAndFetch({
+        name: this.i18n.__('account.accounts_payable.currency', {
+          currency: currencyCode,
+        }),
+        accountType: 'accounts-payable',
+        currencyCode,
+        active: 1,
+        ...extraAttrs,
+      });
+    }
+    return result;
+  };
+}
diff --git a/packages/server/src/repositories/AccountTransactionRepository.ts b/packages/server/src/repositories/AccountTransactionRepository.ts
new file mode 100644
index 000000000..525b82c78
--- /dev/null
+++ b/packages/server/src/repositories/AccountTransactionRepository.ts
@@ -0,0 +1,99 @@
+import { isEmpty, castArray } from 'lodash';
+import { AccountTransaction } from 'models';
+import TenantRepository from '@/repositories/TenantRepository';
+
+interface IJournalTransactionsFilter {
+  fromDate: string | Date;
+  toDate: string | Date;
+  accountsIds: number[];
+  sumationCreditDebit: boolean;
+  fromAmount: number;
+  toAmount: number;
+  contactsIds?: number[];
+  contactType?: string;
+  referenceType?: string[];
+  referenceId?: number[];
+  index: number | number[];
+  indexGroup: number | number[];
+  branchesIds: number | number[];
+}
+
+export default class AccountTransactionsRepository extends TenantRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return AccountTransaction.bindKnex(this.knex);
+  }
+
+  journal(filter: IJournalTransactionsFilter) {
+    return this.model
+      .query()
+      .modify('filterAccounts', filter.accountsIds)
+      .modify('filterDateRange', filter.fromDate, filter.toDate)
+      .withGraphFetched('account')
+      .onBuild((query) => {
+        if (filter.sumationCreditDebit) {
+          query.modify('sumationCreditDebit');
+        }
+        if (filter.fromAmount || filter.toAmount) {
+          query.modify('filterAmountRange', filter.fromAmount, filter.toAmount);
+        }
+        if (filter.contactsIds) {
+          query.modify('filterContactIds', filter.contactsIds);
+        }
+        if (filter.contactType) {
+          query.where('contact_type', filter.contactType);
+        }
+        if (filter.referenceType && filter.referenceType.length > 0) {
+          query.whereIn('reference_type', filter.referenceType);
+        }
+        if (filter.referenceId && filter.referenceId.length > 0) {
+          query.whereIn('reference_id', filter.referenceId);
+        }
+        if (filter.index) {
+          if (Array.isArray(filter.index)) {
+            query.whereIn('index', filter.index);
+          } else {
+            query.where('index', filter.index);
+          }
+        }
+        if (filter.indexGroup) {
+          if (Array.isArray(filter.indexGroup)) {
+            query.whereIn('index_group', filter.indexGroup);
+          } else {
+            query.where('index_group', filter.indexGroup);
+          }
+        }
+        if (!isEmpty(filter.branchesIds)) {
+          query.modify('filterByBranches', filter.branchesIds);
+        }
+      });
+  }
+
+  openingBalance(fromDate) {
+    return AccountTransaction.query().modify('openingBalance', fromDate);
+  }
+
+  closingOpening(toDate) {
+    return AccountTransaction.query().modify('closingBalance', toDate);
+  }
+
+  /**
+   * Reverts the jouranl entries.
+   * @param {number|number[]} referenceId - Reference id.
+   * @param {string} referenceType - Reference type.
+   */
+  public getTransactionsByReference = async (
+    referenceId: number | number[],
+    referenceType: string | string[]
+  ) => {
+    const transactions = await this.model
+      .query()
+      .whereIn('reference_type', castArray(referenceType))
+      .whereIn('reference_id', castArray(referenceId))
+      .withGraphFetched('account');
+
+    return transactions;
+  };
+}
diff --git a/packages/server/src/repositories/BaseModelRepository.ts b/packages/server/src/repositories/BaseModelRepository.ts
new file mode 100644
index 000000000..09d17a6e9
--- /dev/null
+++ b/packages/server/src/repositories/BaseModelRepository.ts
@@ -0,0 +1,5 @@
+
+
+export default class BaseModelRepository {
+
+}
\ No newline at end of file
diff --git a/packages/server/src/repositories/BillRepository.ts b/packages/server/src/repositories/BillRepository.ts
new file mode 100644
index 000000000..185507ef0
--- /dev/null
+++ b/packages/server/src/repositories/BillRepository.ts
@@ -0,0 +1,30 @@
+import moment from 'moment';
+import { Bill } from 'models';
+import TenantRepository from '@/repositories/TenantRepository';
+
+export default class BillRepository extends TenantRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return Bill.bindKnex(this.knex);
+  }
+
+  dueBills(asDate = moment().format('YYYY-MM-DD'), withRelations) {
+    return this.model
+      .query()
+      .modify('dueBills')
+      .modify('notOverdue')
+      .modify('fromDate', asDate)
+      .withGraphFetched(withRelations);
+  }
+
+  overdueBills(asDate = moment().format('YYYY-MM-DD'), withRelations) {
+    return this.model
+      .query()
+      .modify('dueBills')
+      .modify('overdue', asDate)
+      .modify('fromDate', asDate)
+      .withGraphFetched(withRelations);
+  }
+}
diff --git a/packages/server/src/repositories/CachableRepository.ts b/packages/server/src/repositories/CachableRepository.ts
new file mode 100644
index 000000000..d1e1a08c7
--- /dev/null
+++ b/packages/server/src/repositories/CachableRepository.ts
@@ -0,0 +1,261 @@
+import hashObject from 'object-hash';
+import EntityRepository from './EntityRepository';
+
+export default class CachableRepository extends EntityRepository {
+  repositoryName: string;
+  cache: any;
+  i18n: any;
+
+  /**
+   * Constructor method.
+   * @param {Knex} knex
+   * @param {Cache} cache
+   */
+  constructor(knex, cache, i18n) {
+    super(knex);
+
+    this.cache = cache;
+    this.i18n = i18n;
+    this.repositoryName = this.constructor.name;
+  }
+
+  getByCache(key, callback) {
+    return callback();
+  }
+
+  /**
+   * Retrieve the cache key of the method name and arguments.
+   * @param {string} method
+   * @param {...any} args
+   * @return {string}
+   */
+  getCacheKey(method, ...args) {
+    const hashArgs = hashObject({ ...args });
+    const repositoryName = this.repositoryName;
+
+    return `${repositoryName}-${method}-${hashArgs}`;
+  }
+
+  /**
+   * Retrieve all entries with specified relations.
+   * @param withRelations
+   */
+  all(withRelations?, trx?) {
+    const cacheKey = this.getCacheKey('all', withRelations);
+
+    return this.getByCache(cacheKey, () => {
+      return super.all(withRelations, trx);
+    });
+  }
+
+  /**
+   * Finds list of entities with specified attributes
+   * @param {Object} attributeValues - values to filter retrieved entities by
+   * @param {string || string[]} [withRelations] - name of relation(s) to eagerly retrieve.
+   * @returns {Promise<Object[]>} - query builder. You can chain additional methods to it or call "await" or then() on it to execute
+   */
+  find(attributeValues = {}, withRelations?) {
+    const cacheKey = this.getCacheKey('find', attributeValues, withRelations);
+
+    return this.getByCache(cacheKey, () => {
+      return super.find(attributeValues, withRelations);
+    });
+  }
+
+  /**
+   * Finds list of entities with attribute values that are different from specified ones
+   * @param {Object} attributeValues - values to filter retrieved entities by
+   * @param {string || string[]} [withRelations] - name of relation(s) to eagerly retrieve, as defined in model relationMappings()
+   * @returns {Promise<Object[]>} - query builder. You can chain additional methods to it or call "await" or then() on it to execute
+   */
+  findWhereNot(attributeValues = {}, withRelations?) {
+    const cacheKey = this.getCacheKey(
+      'findWhereNot',
+      attributeValues,
+      withRelations
+    );
+
+    return this.getByCache(cacheKey, () => {
+      return super.findWhereNot(attributeValues, withRelations);
+    });
+  }
+
+  /**
+   * Finds list of entities with specified attributes (any of multiple specified values)
+   * Supports both ('attrName', ['value1', 'value2]) and ({attrName: ['value1', 'value2']} formats)
+   *
+   * @param {string|Object} searchParam - attribute name or search criteria object
+   * @param {*[]} [attributeValues] - attribute values to filter retrieved entities by
+   * @param {string || string[]} [withRelations] - name of relation(s) to eagerly retrieve, as defined in model relationMappings()
+   * @returns {PromiseLike<Object[]>} - query builder. You can chain additional methods to it or call "await" or then() on it to execute
+   */
+  findWhereIn(searchParam, attributeValues, withRelations?) {
+    const cacheKey = this.getCacheKey(
+      'findWhereIn',
+      attributeValues,
+      withRelations
+    );
+
+    return this.getByCache(cacheKey, () => {
+      return super.findWhereIn(searchParam, attributeValues, withRelations);
+    });
+  }
+
+  /**
+   * Finds first entity by given parameters
+   *
+   * @param {Object} attributeValues - values to filter retrieved entities by
+   * @param {string || string[]} [withRelations] - name of relation(s) to eagerly retrieve, as defined in model relationMappings()
+   * @returns {Promise<Object>}
+   */
+  findOne(attributeValues = {}, withRelations?) {
+    const cacheKey = this.getCacheKey(
+      'findOne',
+      attributeValues,
+      withRelations
+    );
+
+    return this.getByCache(cacheKey, () => {
+      return super.findOne(attributeValues, withRelations);
+    });
+  }
+
+  /**
+   * Finds first entity by given parameters
+   *
+   * @param {string || number} id - value of id column of the entity
+   * @param {string || string[]} [withRelations] - name of relation(s) to eagerly retrieve, as defined in model relationMappings()
+   * @returns {Promise<Object>}
+   */
+  findOneById(id, withRelations?) {
+    const cacheKey = this.getCacheKey('findOneById', id, withRelations);
+
+    return this.getByCache(cacheKey, () => {
+      return super.findOneById(id, withRelations);
+    });
+  }
+
+  /**
+   * Persists new entity or an array of entities.
+   * This method does not recursively persist related entities, use createRecursively (to be implemented) for that.
+   * Batch insert only works on PostgreSQL
+   * @param {Object} entity - model instance or parameters for a new entity
+   * @returns {Promise<Object>} - query builder. You can chain additional methods to it or call "await" or then() on it to execute
+   */
+  async create(entity, trx?) {
+    const result = await super.create(entity, trx);
+
+    // Flushes the repository cache after insert operation.
+    this.flushCache();
+
+    return result;
+  }
+
+  /**
+   * Persists updated entity. If previously set fields are not present, performs an incremental update (does not remove fields unless explicitly set to null)
+   *
+   * @param {Object} entity - single entity instance
+   * @param {Object} [trx] - knex transaction instance. If not specified, new implicit transaction will be used.
+   * @returns {Promise<integer>} number of affected rows
+   */
+  async update(entity, whereAttributes?, trx?) {
+    const result = await super.update(entity, whereAttributes, trx);
+
+    // Flushes the repository cache after update operation.
+    this.flushCache();
+
+    return result;
+  }
+
+  /**
+   * @param {Object} attributeValues - values to filter deleted entities by
+   * @param {Object} [trx]
+   * @returns {Promise<integer>} Query builder. After promise is resolved, returns count of deleted rows
+   */
+  async deleteBy(attributeValues, trx?) {
+    const result = await super.deleteBy(attributeValues, trx);
+    this.flushCache();
+
+    return result;
+  }
+
+  /**
+   * @param {string || number} id - value of id column of the entity
+   * @returns {Promise<integer>} Query builder. After promise is resolved, returns count of deleted rows
+   */
+  deleteById(id: number | string, trx?) {
+    const result = super.deleteById(id, trx);
+
+    // Flushes the repository cache after insert operation.
+    this.flushCache();
+
+    return result;
+  }
+
+  /**
+   *
+   * @param {string|number[]} values -
+   */
+  async deleteWhereIn(field: string, values: string | number[]) {
+    const result = await super.deleteWhereIn(field, values);
+
+    // Flushes the repository cache after delete operation.
+    this.flushCache();
+
+    return result;
+  }
+
+  /**
+   *
+   * @param {string|number[]} values
+   */
+  async deleteWhereIdIn(values: string | number[], trx?) {
+    const result = await super.deleteWhereIdIn(values, trx);
+
+    // Flushes the repository cache after delete operation.
+    this.flushCache();
+
+    return result;
+  }
+
+  /**
+   *
+   * @param graph
+   * @param options
+   */
+  async upsertGraph(graph, options) {
+    const result = await super.upsertGraph(graph, options);
+
+    // Flushes the repository cache after insert operation.
+    this.flushCache();
+
+    return result;
+  }
+
+  /**
+   *
+   * @param {} whereAttributes
+   * @param {string} field
+   * @param {number} amount
+   */
+  async changeNumber(whereAttributes, field: string, amount: number, trx?) {
+    const result = await super.changeNumber(
+      whereAttributes,
+      field,
+      amount,
+      trx
+    );
+
+    // Flushes the repository cache after update operation.
+    this.flushCache();
+
+    return result;
+  }
+
+  /**
+   * Flush repository cache.
+   */
+  flushCache(): void {
+    this.cache.delStartWith(this.repositoryName);
+  }
+}
diff --git a/packages/server/src/repositories/ContactRepository.ts b/packages/server/src/repositories/ContactRepository.ts
new file mode 100644
index 000000000..fc5c0f27e
--- /dev/null
+++ b/packages/server/src/repositories/ContactRepository.ts
@@ -0,0 +1,12 @@
+import TenantRepository from '@/repositories/TenantRepository';
+import { Contact } from 'models'
+
+
+export default class ContactRepository extends TenantRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return Contact.bindKnex(this.knex);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/repositories/CustomerRepository.ts b/packages/server/src/repositories/CustomerRepository.ts
new file mode 100644
index 000000000..267e14d1f
--- /dev/null
+++ b/packages/server/src/repositories/CustomerRepository.ts
@@ -0,0 +1,46 @@
+import TenantRepository from "./TenantRepository";
+import { Customer } from 'models';
+
+export default class CustomerRepository extends TenantRepository {
+  /**
+   * Contact repository. 
+   */
+  constructor(knex, cache, i18n) {
+    super(knex, cache, i18n);
+    this.repositoryName = 'CustomerRepository';
+  }
+
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return Customer.bindKnex(this.knex);
+  }
+
+  changeBalance(vendorId: number, amount: number) {
+    return super.changeNumber({ id: vendorId }, 'balance', amount);
+  }
+
+  async changeDiffBalance(
+    vendorId: number,
+    amount: number,
+    oldAmount: number,
+    oldVendorId?: number,
+  ) {
+    const diffAmount = amount - oldAmount;
+    const asyncOpers = [];
+    const _oldVendorId = oldVendorId || vendorId;
+
+    if (vendorId != _oldVendorId) {
+      const oldCustomerOper = this.changeBalance(_oldVendorId, (oldAmount * -1));
+      const customerOper = this.changeBalance(vendorId, amount);
+
+      asyncOpers.push(customerOper);
+      asyncOpers.push(oldCustomerOper);
+    } else {
+      const balanceChangeOper = this.changeBalance(vendorId, diffAmount);
+      asyncOpers.push(balanceChangeOper);
+    }
+    await Promise.all(asyncOpers);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/repositories/EntityRepository.ts b/packages/server/src/repositories/EntityRepository.ts
new file mode 100644
index 000000000..cc6ddf49c
--- /dev/null
+++ b/packages/server/src/repositories/EntityRepository.ts
@@ -0,0 +1,241 @@
+import { cloneDeep, forOwn, isString } from 'lodash';
+import ModelEntityNotFound from 'exceptions/ModelEntityNotFound';
+
+function applyGraphFetched(withRelations, builder) {
+  const relations = Array.isArray(withRelations)
+    ? withRelations
+    : typeof withRelations === 'string'
+    ? withRelations.split(',').map((relation) => relation.trim())
+    : [];
+
+  relations.forEach((relation) => {
+    builder.withGraphFetched(relation);
+  });
+}
+
+export default class EntityRepository {
+  idColumn: string;
+  knex: any;
+
+  /**
+   * Constructor method.
+   * @param {Knex} knex
+   */
+  constructor(knex) {
+    this.knex = knex;
+    this.idColumn = 'id';
+  }
+
+  /**
+   * Retrieve the repository model binded it to knex instance.
+   */
+  get model() {
+    throw new Error("The repository's model is not defined.");
+  }
+
+  /**
+   * Retrieve all entries with specified relations.
+   *
+   * @param withRelations
+   */
+  all(withRelations?, trx?) {
+    const builder = this.model.query(trx);
+    applyGraphFetched(withRelations, builder);
+
+    return builder;
+  }
+
+  /**
+   * Finds list of entities with specified attributes
+   *
+   * @param {Object} attributeValues - values to filter retrieved entities by
+   * @param {string || string[]} [withRelations] - name of relation(s) to eagerly retrieve.
+   * @returns {Promise<Object[]>} - query builder. You can chain additional methods to it or call "await" or then() on it to execute
+   */
+  find(attributeValues = {}, withRelations?) {
+    const builder = this.model.query().where(attributeValues);
+
+    applyGraphFetched(withRelations, builder);
+    return builder;
+  }
+
+  /**
+   * Finds list of entities with attribute values that are different from specified ones
+   *
+   * @param {Object} attributeValues - values to filter retrieved entities by
+   * @param {string || string[]} [withRelations] - name of relation(s) to eagerly retrieve, as defined in model relationMappings()
+   * @returns {PromiseLike<Object[]>} - query builder. You can chain additional methods to it or call "await" or then() on it to execute
+   */
+  findWhereNot(attributeValues = {}, withRelations?) {
+    const builder = this.model.query().whereNot(attributeValues);
+
+    applyGraphFetched(withRelations, builder);
+    return builder;
+  }
+
+  /**
+   * Finds list of entities with specified attributes (any of multiple specified values)
+   * Supports both ('attrName', ['value1', 'value2]) and ({attrName: ['value1', 'value2']} formats)
+   *
+   * @param {string|Object} searchParam - attribute name or search criteria object
+   * @param {*[]} [attributeValues] - attribute values to filter retrieved entities by
+   * @param {string || string[]} [withRelations] - name of relation(s) to eagerly retrieve, as defined in model relationMappings()
+   * @returns {PromiseLike<Object[]>} - query builder. You can chain additional methods to it or call "await" or then() on it to execute
+   */
+  findWhereIn(searchParam, attributeValues, withRelations?) {
+    const commonBuilder = (builder) => {
+      applyGraphFetched(withRelations, builder);
+    };
+    if (isString(searchParam)) {
+      return this.model
+        .query()
+        .whereIn(searchParam, attributeValues)
+        .onBuild(commonBuilder);
+    } else {
+      const builder = this.model.query(this.knex).onBuild(commonBuilder);
+
+      forOwn(searchParam, (value, key) => {
+        if (Array.isArray(value)) {
+          builder.whereIn(key, value);
+        } else {
+          builder.where(key, value);
+        }
+      });
+      return builder;
+    }
+  }
+
+  /**
+   * Finds first entity by given parameters
+   *
+   * @param {Object} attributeValues - values to filter retrieved entities by
+   * @param {string || string[]} [withRelations] - name of relation(s) to eagerly retrieve, as defined in model relationMappings()
+   * @returns {Promise<Object>}
+   */
+  async findOne(attributeValues = {}, withRelations?) {
+    const results = await this.find(attributeValues, withRelations);
+    return results[0] || null;
+  }
+
+  /**
+   * Finds first entity by given parameters
+   *
+   * @param {string || number} id - value of id column of the entity
+   * @param {string || string[]} [withRelations] - name of relation(s) to eagerly retrieve, as defined in model relationMappings()
+   * @returns {Promise<Object>}
+   */
+  findOneById(id, withRelations?) {
+    return this.findOne({ [this.idColumn]: id }, withRelations);
+  }
+
+  /**
+   * Persists new entity or an array of entities.
+   * This method does not recursively persist related entities, use createRecursively (to be implemented) for that.
+   * Batch insert only works on PostgreSQL
+   *
+   * @param {Object} entity - model instance or parameters for a new entity
+   * @returns {Promise<Object>} - query builder. You can chain additional methods to it or call "await" or then() on it to execute
+   */
+  create(entity, trx?) {
+    // Keep the input parameter immutable
+    const instanceDTO = cloneDeep(entity);
+
+    return this.model.query(trx).insert(instanceDTO);
+  }
+
+  /**
+   * Persists updated entity. If previously set fields are not present, performs an incremental update (does not remove fields unless explicitly set to null)
+   *
+   * @param   {Object} entity - single entity instance
+   * @returns {Promise<integer>} number of affected rows
+   */
+  async update(entity, whereAttributes?, trx?) {
+    const entityDto = cloneDeep(entity);
+    const identityClause = {};
+
+    if (Array.isArray(this.idColumn)) {
+      this.idColumn.forEach(
+        (idColumn) => (identityClause[idColumn] = entityDto[idColumn])
+      );
+    } else {
+      identityClause[this.idColumn] = entityDto[this.idColumn];
+    }
+    const whereConditions = whereAttributes || identityClause;
+    const modifiedEntitiesCount = await this.model
+      .query(trx)
+      .where(whereConditions)
+      .update(entityDto);
+
+    if (modifiedEntitiesCount === 0) {
+      throw new ModelEntityNotFound(entityDto[this.idColumn]);
+    }
+    return modifiedEntitiesCount;
+  }
+
+  /**
+   *
+   * @param {Object} attributeValues - values to filter deleted entities by
+   * @param {Object} [trx]
+   * @returns {Promise<integer>} Query builder. After promise is resolved, returns count of deleted rows
+   */
+  deleteBy(attributeValues, trx?) {
+    return this.model.query(trx).delete().where(attributeValues);
+  }
+
+  /**
+   * @param {string || number} id - value of id column of the entity
+   * @returns {Promise<integer>} Query builder. After promise is resolved, returns count of deleted rows
+   */
+  deleteById(id: number | string, trx?) {
+    return this.deleteBy(
+      {
+        [this.idColumn]: id,
+      },
+      trx
+    );
+  }
+
+  /**
+   * Deletes the given entries in the array on the specific field.
+   * @param {string} field -
+   * @param {number|string} values -
+   */
+  deleteWhereIn(field: string, values: string | number[], trx) {
+    return this.model.query(trx).whereIn(field, values).delete();
+  }
+
+  /**
+   *
+   * @param {string|number[]} values
+   */
+  deleteWhereIdIn(values: string | number[], trx?) {
+    return this.deleteWhereIn(this.idColumn, values, trx);
+  }
+
+  /**
+   * Arbitrary relation graphs can be upserted (insert + update + delete)
+   * using the upsertGraph method.
+   * @param graph
+   * @param options
+   */
+  upsertGraph(graph, options) {
+    // Keep the input grpah immutable
+    const graphCloned = cloneDeep(graph);
+    return this.model.query().upsertGraph(graphCloned, options);
+  }
+
+  /**
+   *
+   * @param {object} whereAttributes
+   * @param {string} field
+   * @param amount
+   */
+  changeNumber(whereAttributes, field: string, amount: number, trx) {
+    const changeMethod = amount > 0 ? 'increment' : 'decrement';
+
+    return this.model
+      .query(trx)
+      .where(whereAttributes)
+      [changeMethod](field, Math.abs(amount));
+  }
+}
diff --git a/packages/server/src/repositories/ExpenseEntryRepository.ts b/packages/server/src/repositories/ExpenseEntryRepository.ts
new file mode 100644
index 000000000..4f84e81a3
--- /dev/null
+++ b/packages/server/src/repositories/ExpenseEntryRepository.ts
@@ -0,0 +1,11 @@
+import TenantRepository from "./TenantRepository";
+import { ExpenseCategory } from 'models';
+
+export default class ExpenseEntryRepository extends TenantRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return ExpenseCategory.bindKnex(this.knex);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/repositories/ExpenseRepository.ts b/packages/server/src/repositories/ExpenseRepository.ts
new file mode 100644
index 000000000..2f9df91f6
--- /dev/null
+++ b/packages/server/src/repositories/ExpenseRepository.ts
@@ -0,0 +1,35 @@
+import TenantRepository from "./TenantRepository";
+import moment from "moment";
+import { Expense } from 'models';
+
+export default class ExpenseRepository extends TenantRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return Expense.bindKnex(this.knex);
+  }
+
+  /**
+   * Publish the given expense.
+   * @param {number} expenseId 
+   */
+  publish(expenseId: number): Promise<void> {
+    return super.update({
+      id: expenseId,
+      publishedAt: moment().toMySqlDateTime(),
+    });
+  }
+
+  /**
+   * Publishes the given expenses in bulk.
+   * @param  {number[]} expensesIds 
+   * @return {Promise<void>}
+   */
+  async whereIdInPublish(expensesIds: number): Promise<void> {
+    await this.model.query().whereIn('id', expensesIds).patch({
+      publishedAt: moment().toMySqlDateTime(),
+    });
+    this.flushCache();
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/repositories/InventoryTransactionRepository.ts b/packages/server/src/repositories/InventoryTransactionRepository.ts
new file mode 100644
index 000000000..e4e6f80b5
--- /dev/null
+++ b/packages/server/src/repositories/InventoryTransactionRepository.ts
@@ -0,0 +1,11 @@
+import TenantRepository from '@/repositories/TenantRepository';
+import { InventoryTransaction } from 'models';
+
+export default class InventoryTransactionRepository extends TenantRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return InventoryTransaction.bindKnex(this.knex);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/repositories/ItemRepository.ts b/packages/server/src/repositories/ItemRepository.ts
new file mode 100644
index 000000000..043d6a715
--- /dev/null
+++ b/packages/server/src/repositories/ItemRepository.ts
@@ -0,0 +1,12 @@
+
+import { Item } from "models";
+import TenantRepository from "./TenantRepository";
+
+export default class ItemRepository extends TenantRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return Item.bindKnex(this.knex);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/repositories/JournalRepository.ts b/packages/server/src/repositories/JournalRepository.ts
new file mode 100644
index 000000000..ec91da4a1
--- /dev/null
+++ b/packages/server/src/repositories/JournalRepository.ts
@@ -0,0 +1,11 @@
+import { ManualJournal } from 'models';
+import TenantRepository from '@/repositories/TenantRepository';
+
+export default class JournalRepository extends TenantRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return ManualJournal.bindKnex(this.knex);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/repositories/PaymentReceiveEntryRepository.ts b/packages/server/src/repositories/PaymentReceiveEntryRepository.ts
new file mode 100644
index 000000000..38f0cc5be
--- /dev/null
+++ b/packages/server/src/repositories/PaymentReceiveEntryRepository.ts
@@ -0,0 +1,11 @@
+import { PaymentReceiveEntry } from 'models';
+import TenantRepository from '@/repositories/TenantRepository';
+
+export default class PaymentReceiveEntryRepository extends TenantRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return PaymentReceiveEntry.bindKnex(this.knex);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/repositories/PaymentReceiveRepository.ts b/packages/server/src/repositories/PaymentReceiveRepository.ts
new file mode 100644
index 000000000..3db6ba6e4
--- /dev/null
+++ b/packages/server/src/repositories/PaymentReceiveRepository.ts
@@ -0,0 +1,11 @@
+import { PaymentReceive } from 'models';
+import TenantRepository from '@/repositories/TenantRepository';
+
+export default class PaymentReceiveRepository extends TenantRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return PaymentReceive.bindKnex(this.knex);
+  }
+}
diff --git a/packages/server/src/repositories/SaleInvoiceRepository.ts b/packages/server/src/repositories/SaleInvoiceRepository.ts
new file mode 100644
index 000000000..3cb431da5
--- /dev/null
+++ b/packages/server/src/repositories/SaleInvoiceRepository.ts
@@ -0,0 +1,30 @@
+import moment from 'moment';
+import { SaleInvoice } from 'models';
+import TenantRepository from '@/repositories/TenantRepository';
+
+export default class SaleInvoiceRepository extends TenantRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return SaleInvoice.bindKnex(this.knex);
+  }
+
+  dueInvoices(asDate = moment().format('YYYY-MM-DD'), withRelations) {
+    return this.model
+      .query()
+      .modify('dueInvoices')
+      .modify('notOverdue', asDate)
+      .modify('fromDate', asDate)
+      .withGraphFetched(withRelations);
+  }
+
+  overdueInvoices(asDate = moment().format('YYYY-MM-DD'), withRelations) {
+    return this.model
+      .query()
+      .modify('dueInvoices')
+      .modify('overdue', asDate)
+      .modify('fromDate', asDate)
+      .withGraphFetched(withRelations);
+  }
+}
diff --git a/packages/server/src/repositories/SettingRepository.ts b/packages/server/src/repositories/SettingRepository.ts
new file mode 100644
index 000000000..84cdde764
--- /dev/null
+++ b/packages/server/src/repositories/SettingRepository.ts
@@ -0,0 +1,11 @@
+import TenantRepository from '@/repositories/TenantRepository';
+import Setting from 'models/Setting';
+
+export default class SettingRepository extends TenantRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return Setting.bindKnex(this.knex);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/repositories/TenantRepository.ts b/packages/server/src/repositories/TenantRepository.ts
new file mode 100644
index 000000000..b24b9d079
--- /dev/null
+++ b/packages/server/src/repositories/TenantRepository.ts
@@ -0,0 +1,15 @@
+import { Container } from 'typedi';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import CachableRepository from './CachableRepository';
+
+export default class TenantRepository extends CachableRepository {
+  repositoryName: string;
+   
+  /**
+   * Constructor method.
+   * @param {number} tenantId 
+   */
+  constructor(knex, cache, i18n) {
+    super(knex, cache, i18n);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/repositories/VendorRepository.ts b/packages/server/src/repositories/VendorRepository.ts
new file mode 100644
index 000000000..af9e7a899
--- /dev/null
+++ b/packages/server/src/repositories/VendorRepository.ts
@@ -0,0 +1,50 @@
+import { Vendor } from "models";
+import TenantRepository from "./TenantRepository";
+
+export default class VendorRepository extends TenantRepository {
+  /**
+   * Contact repository. 
+   */
+  constructor(knex, cache, i18n) {
+    super(knex, cache, i18n);
+    this.repositoryName = 'VendorRepository';
+  }
+
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return Vendor.bindKnex(this.knex);
+  }
+
+  unpaid() {
+      
+  }
+
+  changeBalance(vendorId: number, amount: number) {
+    return super.changeNumber({ id: vendorId }, 'balance', amount);
+  }
+
+  async changeDiffBalance(
+    vendorId: number,
+    amount: number,
+    oldAmount: number,
+    oldVendorId?: number,
+  ) {
+    const diffAmount = amount - oldAmount;
+    const asyncOpers = [];
+    const _oldVendorId = oldVendorId || vendorId;
+
+    if (vendorId != _oldVendorId) {
+      const oldCustomerOper = this.changeBalance(_oldVendorId, (oldAmount * -1));
+      const customerOper = this.changeBalance(vendorId, amount);
+
+      asyncOpers.push(customerOper);
+      asyncOpers.push(oldCustomerOper);
+    } else {
+      const balanceChangeOper = this.changeBalance(vendorId, diffAmount);
+      asyncOpers.push(balanceChangeOper);
+    }
+    await Promise.all(asyncOpers);
+  }
+}
diff --git a/packages/server/src/repositories/ViewRepository.ts b/packages/server/src/repositories/ViewRepository.ts
new file mode 100644
index 000000000..8bcfbf13f
--- /dev/null
+++ b/packages/server/src/repositories/ViewRepository.ts
@@ -0,0 +1,18 @@
+import { View } from 'models';
+import TenantRepository from '@/repositories/TenantRepository';
+
+export default class ViewRepository extends TenantRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return View.bindKnex(this.knex);
+  }
+
+  /**
+   * Retrieve all views of the given resource id.
+   */
+  allByResource(resourceModel: string, withRelations?) {
+    return super.find({ resource_model: resourceModel }, withRelations);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/repositories/ViewRoleRepository.ts b/packages/server/src/repositories/ViewRoleRepository.ts
new file mode 100644
index 000000000..1f96bb332
--- /dev/null
+++ b/packages/server/src/repositories/ViewRoleRepository.ts
@@ -0,0 +1,6 @@
+import { omit } from 'lodash';
+import TenantRepository from '@/repositories/TenantRepository';
+
+export default class ViewRoleRepository extends TenantRepository {
+
+}
\ No newline at end of file
diff --git a/packages/server/src/server.ts b/packages/server/src/server.ts
new file mode 100644
index 000000000..de1fecd70
--- /dev/null
+++ b/packages/server/src/server.ts
@@ -0,0 +1,28 @@
+import 'reflect-metadata'; // We need this in order to use @Decorators
+import '@/config';
+import './before';
+
+import express from 'express';
+import loadersFactory from 'loaders';
+
+async function startServer() {
+  const app = express();
+
+  // Intiialize all registered loaders.
+  await loadersFactory({ expressApp: app });
+
+  app.listen(app.get('port'), (err) => {
+    if (err) {
+      console.log(err);
+      process.exit(1);
+      return;
+    }
+    console.log(`
+      ################################################
+        Server listening on port: ${app.get('port')}
+      ################################################
+    `);
+  });
+}
+
+startServer();
diff --git a/packages/server/src/services/Accounting/AccountsTransactionsWarehousesSubscribe.ts b/packages/server/src/services/Accounting/AccountsTransactionsWarehousesSubscribe.ts
new file mode 100644
index 000000000..dd6486e91
--- /dev/null
+++ b/packages/server/src/services/Accounting/AccountsTransactionsWarehousesSubscribe.ts
@@ -0,0 +1,38 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { InventoryTransactionsWarehouses } from './AcountsTransactionsWarehouses';
+import { IBranchesActivatedPayload } from '@/interfaces';
+
+@Service()
+export class AccountsTransactionsWarehousesSubscribe {
+  @Inject()
+  accountsTransactionsWarehouses: InventoryTransactionsWarehouses;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.branch.onActivated,
+      this.updateGLTransactionsToPrimaryBranchOnActivated
+    );
+    return bus;
+  };
+
+  /**
+   * Updates all GL transactions to primary branch once
+   * the multi-branches activated.
+   * @param {IBranchesActivatedPayload}
+   */
+  private updateGLTransactionsToPrimaryBranchOnActivated = async ({
+    tenantId,
+    primaryBranch,
+    trx,
+  }: IBranchesActivatedPayload) => {
+    await this.accountsTransactionsWarehouses.updateTransactionsWithWarehouse(
+      tenantId,
+      primaryBranch.id,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Accounting/AcountsTransactionsWarehouses.ts b/packages/server/src/services/Accounting/AcountsTransactionsWarehouses.ts
new file mode 100644
index 000000000..2673c01ad
--- /dev/null
+++ b/packages/server/src/services/Accounting/AcountsTransactionsWarehouses.ts
@@ -0,0 +1,26 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class InventoryTransactionsWarehouses {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Updates all accounts transctions with the priamry branch.
+   * @param tenantId
+   * @param primaryBranchId
+   */
+  public updateTransactionsWithWarehouse = async (
+    tenantId: number,
+    primaryBranchId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { AccountTransaction } = await this.tenancy.models(tenantId);
+
+    await AccountTransaction.query(trx).update({
+      branchId: primaryBranchId,
+    });
+  };
+}
diff --git a/packages/server/src/services/Accounting/JournalCommands.ts b/packages/server/src/services/Accounting/JournalCommands.ts
new file mode 100644
index 000000000..d1c585646
--- /dev/null
+++ b/packages/server/src/services/Accounting/JournalCommands.ts
@@ -0,0 +1,71 @@
+import moment from 'moment';
+import { castArray, sumBy, toArray } from 'lodash';
+import { IBill, ISystemUser, IAccount } from '@/interfaces';
+import JournalPoster from './JournalPoster';
+import JournalEntry from './JournalEntry';
+import { IExpense, IExpenseCategory } from '@/interfaces';
+import { increment } from 'utils';
+export default class JournalCommands {
+  journal: JournalPoster;
+  models: any;
+  repositories: any;
+
+  /**
+   * Constructor method.
+   * @param {JournalPoster} journal -
+   */
+  constructor(journal: JournalPoster) {
+    this.journal = journal;
+
+    this.repositories = this.journal.repositories;
+    this.models = this.journal.models;
+  }
+  /**
+   * Reverts the jouranl entries.
+   * @param {number|number[]} referenceId - Reference id.
+   * @param {string} referenceType - Reference type.
+   */
+  async revertJournalEntries(
+    referenceId: number | number[],
+    referenceType: string | string[]
+  ) {
+    const { AccountTransaction } = this.models;
+
+    const transactions = await AccountTransaction.query()
+      .whereIn('reference_type', castArray(referenceType))
+      .whereIn('reference_id', castArray(referenceId))
+      .withGraphFetched('account');
+
+    this.journal.fromTransactions(transactions);
+    this.journal.removeEntries();
+  }
+
+  /**
+   * Reverts the sale invoice cost journal entries.
+   * @param {Date|string} startingDate
+   * @return {Promise<void>}
+   */
+  async revertInventoryCostJournalEntries(
+    startingDate: Date | string
+  ): Promise<void> {
+    const { AccountTransaction } = this.models;
+
+    this.journal.fromTransactions(transactions);
+    this.journal.removeEntries();
+  }
+
+  /**
+   * Reverts sale invoice the income journal entries.
+   * @param {number} saleInvoiceId
+   */
+  async revertInvoiceIncomeEntries(saleInvoiceId: number) {
+    const { transactionsRepository } = this.repositories;
+
+    const transactions = await transactionsRepository.journal({
+      referenceType: ['SaleInvoice'],
+      referenceId: [saleInvoiceId],
+    });
+    this.journal.fromTransactions(transactions);
+    this.journal.removeEntries();
+  }
+}
diff --git a/packages/server/src/services/Accounting/JournalContacts.ts b/packages/server/src/services/Accounting/JournalContacts.ts
new file mode 100644
index 000000000..6ae2b22c5
--- /dev/null
+++ b/packages/server/src/services/Accounting/JournalContacts.ts
@@ -0,0 +1,74 @@
+import async from 'async';
+
+export default class JournalContacts {
+  saveContactBalanceQueue: any;
+  contactsBalanceTable: {
+    [key: number]: { credit: number; debit: number };
+  } = {};
+
+  constructor(journal) {
+    this.journal = journal;
+    this.saveContactBalanceQueue = async.queue(
+      this.saveContactBalanceChangeTask.bind(this),
+      10
+    );
+  }
+  /**
+   * Sets the contact balance change.
+   */
+  private getContactsBalanceChanges(entry) {
+    if (!entry.contactId) {
+      return;
+    }
+    const change = {
+      debit: entry.debit,
+      credit: entry.credit,
+    };
+    if (!this.contactsBalanceTable[entry.contactId]) {
+      this.contactsBalanceTable[entry.contactId] = { credit: 0, debit: 0 };
+    }
+    if (change.credit) {
+      this.contactsBalanceTable[entry.contactId].credit += change.credit;
+    }
+    if (change.debit) {
+      this.contactsBalanceTable[entry.contactId].debit += change.debit;
+    }
+  }
+
+  /**
+   * Save contacts balance change.
+   */
+  saveContactsBalance() {
+    const balanceChanges = Object.entries(
+      this.contactsBalanceTable
+    ).map(([contactId, { credit, debit }]) => ({ contactId, credit, debit }));
+
+    return this.saveContactBalanceQueue.pushAsync(balanceChanges);
+  }
+
+  /**
+   * Saves contact balance change task.
+   * @param {number} contactId - Contact id.
+   * @param {number} credit - Credit amount.
+   * @param {number} debit - Debit amount.
+   */
+  async saveContactBalanceChangeTask({ contactId, credit, debit }, callback) {
+    const { contactRepository } = this.repositories;
+
+    const contact = await contactRepository.findOneById(contactId);
+    let balanceChange = 0;
+
+    if (contact.contactNormal === 'credit') {
+      balanceChange += credit - debit;
+    } else {
+      balanceChange += debit - credit;
+    }
+    // Contact change balance.
+    await contactRepository.changeNumber(
+      { id: contactId },
+      'balance',
+      balanceChange
+    );
+    callback();
+  }
+}
diff --git a/packages/server/src/services/Accounting/JournalEntry.ts b/packages/server/src/services/Accounting/JournalEntry.ts
new file mode 100644
index 000000000..177ace1f1
--- /dev/null
+++ b/packages/server/src/services/Accounting/JournalEntry.ts
@@ -0,0 +1,10 @@
+
+export default class JournalEntry {
+  constructor(entry) {
+    const defaults = {
+      credit: 0,
+      debit: 0,
+    };
+    this.entry = { ...defaults, ...entry };
+  }
+}
diff --git a/packages/server/src/services/Accounting/JournalFinancial.ts b/packages/server/src/services/Accounting/JournalFinancial.ts
new file mode 100644
index 000000000..65e18491d
--- /dev/null
+++ b/packages/server/src/services/Accounting/JournalFinancial.ts
@@ -0,0 +1,17 @@
+import moment from 'moment';
+import { IJournalPoster } from '@/interfaces';
+
+export default class JournalFinancial {
+  journal: IJournalPoster;
+  
+  accountsDepGraph: any;
+
+  /**
+   * Journal poster.
+   * @param {IJournalPoster} journal 
+   */
+  constructor(journal: IJournalPoster) {
+    this.journal = journal;
+    this.accountsDepGraph = this.journal.accountsDepGraph;
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Accounting/JournalPoster.ts b/packages/server/src/services/Accounting/JournalPoster.ts
new file mode 100644
index 000000000..d3400396d
--- /dev/null
+++ b/packages/server/src/services/Accounting/JournalPoster.ts
@@ -0,0 +1,759 @@
+import { omit, get, chain } from 'lodash';
+import moment from 'moment';
+import { Container } from 'typedi';
+import async from 'async';
+import JournalEntry from '@/services/Accounting/JournalEntry';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import {
+  IJournalEntry,
+  IJournalPoster,
+  IAccountChange,
+  IAccountsChange,
+  TEntryType,
+} from '@/interfaces';
+import Knex from 'knex';
+
+const CONTACTS_CONFIG = [
+  {
+    accountBySlug: 'accounts-receivable',
+    contactService: 'customer',
+    assignRequired: true,
+  },
+  {
+    accountBySlug: 'accounts-payable',
+    contactService: 'vendor',
+    assignRequired: true,
+  },
+];
+
+export default class JournalPoster implements IJournalPoster {
+  tenantId: number;
+  tenancy: TenancyService;
+  logger: any;
+  models: any;
+  repositories: any;
+
+  deletedEntriesIds: number[] = [];
+  entries: IJournalEntry[] = [];
+  balancesChange: IAccountsChange = {};
+  accountsDepGraph: IAccountsChange;
+
+  accountsBalanceTable: { [key: number]: number } = {};
+  contactsBalanceTable: {
+    [key: number]: { credit: number; debit: number }[];
+  } = {};
+  saveContactBalanceQueue: any;
+
+  /**
+   * Journal poster constructor.
+   * @param {number} tenantId -
+   */
+  constructor(tenantId: number, accountsGraph?: any, trx?: Knex.Transaction) {
+    this.initTenancy();
+
+    this.tenantId = tenantId;
+    this.models = this.tenancy.models(tenantId);
+    this.repositories = this.tenancy.repositories(tenantId);
+
+    if (accountsGraph) {
+      this.accountsDepGraph = accountsGraph;
+    }
+    this.trx = trx;
+    this.saveContactBalanceQueue = async.queue(
+      this.saveContactBalanceChangeTask.bind(this),
+      10
+    );
+  }
+
+  /**
+   * Initial tenancy.
+   * @private
+   */
+  private initTenancy() {
+    try {
+      this.tenancy = Container.get(TenancyService);
+      this.logger = Container.get('logger');
+    } catch (exception) {
+      throw new Error('Should execute this class inside tenancy area.');
+    }
+  }
+
+  /**
+   * Async initialize acccounts dependency graph.
+   * @private
+   * @returns {Promise<void>}
+   */
+  public async initAccountsDepGraph(): Promise<void> {
+    const { accountRepository } = this.repositories;
+
+    if (!this.accountsDepGraph) {
+      const accountsDepGraph = await accountRepository.getDependencyGraph();
+      this.accountsDepGraph = accountsDepGraph;
+    }
+  }
+
+  /**
+   * Detarmines the ledger is empty.
+   */
+  public isEmpty() {
+    return this.entries.length === 0;
+  }
+
+  /**
+   * Writes the credit entry for the given account.
+   * @param {IJournalEntry} entry -
+   */
+  public credit(entryModel: IJournalEntry): void {
+    if (entryModel instanceof JournalEntry === false) {
+      throw new Error('The entry is not instance of JournalEntry.');
+    }
+    this.entries.push(entryModel.entry);
+    this.setAccountBalanceChange(entryModel.entry);
+    this.setContactBalanceChange(entryModel.entry);
+  }
+
+  /**
+   * Writes the debit entry for the given account.
+   * @param {JournalEntry} entry -
+   */
+  public debit(entryModel: IJournalEntry): void {
+    if (entryModel instanceof JournalEntry === false) {
+      throw new Error('The entry is not instance of JournalEntry.');
+    }
+    this.entries.push(entryModel.entry);
+    this.setAccountBalanceChange(entryModel.entry);
+    this.setContactBalanceChange(entryModel.entry);
+  }
+
+  /**
+   * Sets the contact balance change.
+   */
+  private setContactBalanceChange(entry) {
+    if (!entry.contactId) {
+      return;
+    }
+    const change = {
+      debit: entry.debit || 0,
+      credit: entry.credit || 0,
+      account: entry.account,
+    };
+    if (!this.contactsBalanceTable[entry.contactId]) {
+      this.contactsBalanceTable[entry.contactId] = [];
+    }
+    this.contactsBalanceTable[entry.contactId].push(change);
+  }
+
+  /**
+   * Save contacts balance change.
+   */
+  async saveContactsBalance() {
+    await this.initAccountsDepGraph();
+
+    const balanceChanges = Object.entries(this.contactsBalanceTable).map(
+      ([contactId, entries]) => ({
+        contactId,
+        entries: entries.filter((entry) => {
+          const account = this.accountsDepGraph.getNodeData(entry.account);
+
+          return (
+            account &&
+            CONTACTS_CONFIG.some((config) => {
+              return config.accountBySlug === account.slug;
+            })
+          );
+        }),
+      })
+    );
+
+    const balanceEntries = chain(balanceChanges)
+      .map((change) =>
+        change.entries.map((entry) => ({
+          ...entry,
+          contactId: change.contactId,
+        }))
+      )
+      .flatten()
+      .value();
+
+    return this.saveContactBalanceQueue.pushAsync(balanceEntries);
+  }
+
+  /**
+   * Saves contact balance change task.
+   * @param {number} contactId - Contact id.
+   * @param {number} credit - Credit amount.
+   * @param {number} debit - Debit amount.
+   */
+  async saveContactBalanceChangeTask({ contactId, credit, debit }) {
+    const { contactRepository } = this.repositories;
+
+    const contact = await contactRepository.findOneById(contactId);
+    let balanceChange = 0;
+
+    if (contact.contactNormal === 'credit') {
+      balanceChange += credit - debit;
+    } else {
+      balanceChange += debit - credit;
+    }
+    // Contact change balance.
+    await contactRepository.changeNumber(
+      { id: contactId },
+      'balance',
+      balanceChange,
+      this.trx
+    );
+  }
+
+  /**
+   * Sets account balance change.
+   * @param {JournalEntry} entry
+   * @param {String} type
+   */
+  private setAccountBalanceChange(entry: IJournalEntry): void {
+    const accountChange: IAccountChange = {
+      debit: entry.debit,
+      credit: entry.credit,
+    };
+    this._setAccountBalanceChange(entry.account, accountChange);
+  }
+
+  /**
+   * Sets account balance change.
+   * @private
+   * @param {number} accountId -
+   * @param {IAccountChange} accountChange
+   */
+  private _setAccountBalanceChange(
+    accountId: number,
+    accountChange: IAccountChange
+  ) {
+    this.balancesChange = this.accountBalanceChangeReducer(
+      this.balancesChange,
+      accountId,
+      accountChange
+    );
+  }
+
+  /**
+   * Accounts balance change reducer.
+   * @param {IAccountsChange} balancesChange
+   * @param {number} accountId
+   * @param {IAccountChange} accountChange
+   * @return {IAccountChange}
+   */
+  private accountBalanceChangeReducer(
+    balancesChange: IAccountsChange,
+    accountId: number,
+    accountChange: IAccountChange
+  ) {
+    const change = { ...balancesChange };
+
+    if (!change[accountId]) {
+      change[accountId] = { credit: 0, debit: 0 };
+    }
+    if (accountChange.credit) {
+      change[accountId].credit += accountChange.credit;
+    }
+    if (accountChange.debit) {
+      change[accountId].debit += accountChange.debit;
+    }
+    return change;
+  }
+
+  /**
+   * Converts balance changes to array.
+   * @private
+   * @param {IAccountsChange} accountsChange -
+   * @return {Promise<{ account: number, change: number }>}
+   */
+  private async convertBalanceChangesToArr(
+    accountsChange: IAccountsChange
+  ): Promise<{ account: number; change: number }[]> {
+    const mappedList: { account: number; change: number }[] = [];
+    const accountsIds: number[] = Object.keys(accountsChange).map((id) =>
+      parseInt(id, 10)
+    );
+
+    await Promise.all(
+      accountsIds.map(async (account: number) => {
+        const accountChange = accountsChange[account];
+        const accountNode = this.accountsDepGraph.getNodeData(account);
+        const normal = accountNode.accountNormal;
+
+        let change = 0;
+
+        if (accountChange.credit) {
+          change +=
+            normal === 'credit'
+              ? accountChange.credit
+              : -1 * accountChange.credit;
+        }
+        if (accountChange.debit) {
+          change +=
+            normal === 'debit' ? accountChange.debit : -1 * accountChange.debit;
+        }
+        mappedList.push({ account, change });
+      })
+    );
+    return mappedList;
+  }
+
+  /**
+   * Saves the balance change of journal entries.
+   * @returns {Promise<void>}
+   */
+  public async saveBalance() {
+    await this.initAccountsDepGraph();
+
+    const { Account } = this.models;
+    const accountsChange = this.balanceChangeWithDepends(this.balancesChange);
+    const balancesList = await this.convertBalanceChangesToArr(accountsChange);
+    const balancesAccounts = balancesList.map((b) => b.account);
+
+    // Ensure the accounts has atleast zero in amount.
+    await Account.query(this.trx)
+      .where('amount', null)
+      .whereIn('id', balancesAccounts)
+      .patch({ amount: 0 });
+
+    const balanceUpdateOpers: Promise<void>[] = [];
+
+    balancesList.forEach((balance: { account: number; change: number }) => {
+      const method: string = balance.change < 0 ? 'decrement' : 'increment';
+
+      this.logger.info(
+        '[journal_poster] increment/decrement account balance.',
+        {
+          balance,
+          tenantId: this.tenantId,
+        }
+      );
+      const query = Account.query(this.trx)
+        [method]('amount', Math.abs(balance.change))
+        .where('id', balance.account);
+
+      balanceUpdateOpers.push(query);
+    });
+
+    await Promise.all(balanceUpdateOpers);
+    this.resetAccountsBalanceChange();
+  }
+
+  /**
+   * Changes all accounts that dependencies of changed accounts.
+   * @param {IAccountsChange} accountsChange
+   * @returns {IAccountsChange}
+   */
+  private balanceChangeWithDepends(
+    accountsChange: IAccountsChange
+  ): IAccountsChange {
+    const accountsIds = Object.keys(accountsChange);
+    let changes: IAccountsChange = {};
+
+    accountsIds.forEach((accountId) => {
+      const accountChange = accountsChange[accountId];
+      const depAccountsIds = this.accountsDepGraph.dependantsOf(accountId);
+
+      [accountId, ...depAccountsIds].forEach((account) => {
+        changes = this.accountBalanceChangeReducer(
+          changes,
+          account,
+          accountChange
+        );
+      });
+    });
+    return changes;
+  }
+
+  /**
+   * Resets accounts balance change.
+   * @private
+   */
+  private resetAccountsBalanceChange() {
+    this.balancesChange = {};
+  }
+
+  /**
+   * Saves the stacked journal entries to the storage.
+   * @returns {Promise<void>}
+   */
+  public async saveEntries() {
+    const { transactionsRepository } = this.repositories;
+    const saveOperations: Promise<void>[] = [];
+
+    this.logger.info('[journal] trying to insert accounts transactions.');
+
+    this.entries.forEach((entry) => {
+      const oper = transactionsRepository.create(
+        {
+          accountId: entry.account,
+          ...omit(entry, ['account']),
+        },
+        this.trx
+      );
+      saveOperations.push(oper);
+    });
+    await Promise.all(saveOperations);
+  }
+
+  /**
+   * Reverses the stacked journal entries.
+   */
+  public reverseEntries() {
+    const reverseEntries: IJournalEntry[] = [];
+
+    this.entries.forEach((entry) => {
+      const reverseEntry = { ...entry };
+
+      if (entry.credit) {
+        reverseEntry.debit = entry.credit;
+      }
+      if (entry.debit) {
+        reverseEntry.credit = entry.debit;
+      }
+      reverseEntries.push(reverseEntry);
+    });
+    this.entries = reverseEntries;
+  }
+
+  /**
+   * Removes all stored entries or by the given in ids.
+   * @param {Array} ids -
+   */
+  removeEntries(ids: number[] = []) {
+    const targetIds = ids.length <= 0 ? this.entries.map((e) => e.id) : ids;
+    const removeEntries = this.entries.filter(
+      (e) => targetIds.indexOf(e.id) !== -1
+    );
+    this.entries = this.entries.filter((e) => targetIds.indexOf(e.id) === -1);
+
+    removeEntries.forEach((entry) => {
+      entry.credit = -1 * entry.credit;
+      entry.debit = -1 * entry.debit;
+
+      this.setAccountBalanceChange(entry);
+      this.setContactBalanceChange(entry);
+    });
+    this.deletedEntriesIds.push(...removeEntries.map((entry) => entry.id));
+  }
+
+  /**
+   * Delete all the stacked entries.
+   * @return {Promise<void>}
+   */
+  public async deleteEntries() {
+    const { transactionsRepository } = this.repositories;
+
+    if (this.deletedEntriesIds.length > 0) {
+      await transactionsRepository.deleteWhereIdIn(
+        this.deletedEntriesIds,
+        this.trx
+      );
+    }
+  }
+
+  /**
+   * Load fetched accounts journal entries.
+   * @param {IJournalEntry[]} entries -
+   */
+  fromTransactions(transactions) {
+    transactions.forEach((transaction) => {
+      this.entries.push({
+        ...transaction,
+        referenceTypeFormatted: transaction.referenceTypeFormatted,
+        account: transaction.accountId,
+        accountNormal: get(transaction, 'account.accountNormal'),
+      });
+    });
+  }
+
+  /**
+   * Calculates the entries balance change.
+   * @public
+   */
+  public calculateEntriesBalanceChange() {
+    this.entries.forEach((entry) => {
+      if (entry.credit) {
+        this.setAccountBalanceChange(entry, 'credit');
+      }
+      if (entry.debit) {
+        this.setAccountBalanceChange(entry, 'debit');
+      }
+    });
+  }
+
+  static fromTransactions(entries, ...args: [number, ...any]) {
+    const journal = new this(...args);
+    journal.fromTransactions(entries);
+
+    return journal;
+  }
+
+  /**
+   * Retrieve the closing balance for the given account and closing date.
+   * @param  {Number} accountId -
+   * @param  {Date} closingDate -
+   * @param  {string} dataType? -
+   * @return {number}
+   */
+  getClosingBalance(
+    accountId: number,
+    closingDate: Date | string,
+    dateType: string = 'day'
+  ): number {
+    let closingBalance = 0;
+    const momentClosingDate = moment(closingDate);
+
+    this.entries.forEach((entry) => {
+      // Can not continue if not before or event same closing date.
+      if (
+        (!momentClosingDate.isAfter(entry.date, dateType) &&
+          !momentClosingDate.isSame(entry.date, dateType)) ||
+        (entry.account !== accountId && accountId)
+      ) {
+        return;
+      }
+      if (entry.accountNormal === 'credit') {
+        closingBalance += entry.credit ? entry.credit : -1 * entry.debit;
+      } else if (entry.accountNormal === 'debit') {
+        closingBalance += entry.debit ? entry.debit : -1 * entry.credit;
+      }
+    });
+    return closingBalance;
+  }
+
+  /**
+   * Retrieve the given account balance with dependencies accounts.
+   * @param {Number} accountId -
+   * @param {Date} closingDate -
+   * @param {String} dateType -
+   * @return {Number}
+   */
+  getAccountBalance(
+    accountId: number,
+    closingDate: Date | string,
+    dateType: string
+  ) {
+    const accountNode = this.accountsDepGraph.getNodeData(accountId);
+    const depAccountsIds = this.accountsDepGraph.dependenciesOf(accountId);
+    const depAccounts = depAccountsIds.map((id) =>
+      this.accountsDepGraph.getNodeData(id)
+    );
+
+    let balance: number = 0;
+
+    [...depAccounts, accountNode].forEach((account) => {
+      const closingBalance = this.getClosingBalance(
+        account.id,
+        closingDate,
+        dateType
+      );
+      this.accountsBalanceTable[account.id] = closingBalance;
+      balance += this.accountsBalanceTable[account.id];
+    });
+    return balance;
+  }
+
+  /**
+   * Retrieve the credit/debit sumation for the given account and date.
+   * @param {Number} account -
+   * @param {Date|String} closingDate -
+   */
+  getTrialBalance(accountId, closingDate) {
+    const momentClosingDate = moment(closingDate);
+    const result = {
+      credit: 0,
+      debit: 0,
+      balance: 0,
+    };
+    this.entries.forEach((entry) => {
+      if (
+        (!momentClosingDate.isAfter(entry.date, 'day') &&
+          !momentClosingDate.isSame(entry.date, 'day')) ||
+        (entry.account !== accountId && accountId)
+      ) {
+        return;
+      }
+      result.credit += entry.credit;
+      result.debit += entry.debit;
+
+      if (entry.accountNormal === 'credit') {
+        result.balance += entry.credit - entry.debit;
+      } else if (entry.accountNormal === 'debit') {
+        result.balance += entry.debit - entry.credit;
+      }
+    });
+    return result;
+  }
+
+  /**
+   * Retrieve trial balance of the given account with depends.
+   * @param {Number} accountId
+   * @param {Date} closingDate
+   * @param {String} dateType
+   * @return {Number}
+   */
+
+  getTrialBalanceWithDepands(
+    accountId: number,
+    closingDate: Date,
+    dateType: string
+  ) {
+    const accountNode = this.accountsDepGraph.getNodeData(accountId);
+    const depAccountsIds = this.accountsDepGraph.dependenciesOf(accountId);
+    const depAccounts = depAccountsIds.map((id) =>
+      this.accountsDepGraph.getNodeData(id)
+    );
+    const trialBalance = { credit: 0, debit: 0, balance: 0 };
+
+    [...depAccounts, accountNode].forEach((account) => {
+      const _trialBalance = this.getTrialBalance(
+        account.id,
+        closingDate,
+        dateType
+      );
+
+      trialBalance.credit += _trialBalance.credit;
+      trialBalance.debit += _trialBalance.debit;
+      trialBalance.balance += _trialBalance.balance;
+    });
+    return trialBalance;
+  }
+
+  getContactTrialBalance(
+    accountId: number,
+    contactId: number,
+    contactType: string,
+    closingDate?: Date | string,
+    openingDate?: Date | string
+  ) {
+    const momentClosingDate = moment(closingDate);
+    const momentOpeningDate = moment(openingDate);
+    const trial = {
+      credit: 0,
+      debit: 0,
+      balance: 0,
+    };
+
+    this.entries.forEach((entry) => {
+      if (
+        (closingDate &&
+          !momentClosingDate.isAfter(entry.date, 'day') &&
+          !momentClosingDate.isSame(entry.date, 'day')) ||
+        (openingDate &&
+          !momentOpeningDate.isBefore(entry.date, 'day') &&
+          !momentOpeningDate.isSame(entry.date)) ||
+        (accountId && entry.account !== accountId) ||
+        (contactId && entry.contactId !== contactId) ||
+        entry.contactType !== contactType
+      ) {
+        return;
+      }
+      if (entry.credit) {
+        trial.balance -= entry.credit;
+        trial.credit += entry.credit;
+      }
+      if (entry.debit) {
+        trial.balance += entry.debit;
+        trial.debit += entry.debit;
+      }
+    });
+    return trial;
+  }
+
+  /**
+   * Retrieve total balnace of the given customer/vendor contact.
+   * @param {Number} accountId
+   * @param {Number} contactId
+   * @param {String} contactType
+   * @param {Date} closingDate
+   */
+  getContactBalance(
+    accountId: number,
+    contactId: number,
+    contactType: string,
+    closingDate: Date,
+    openingDate: Date
+  ) {
+    const momentClosingDate = moment(closingDate);
+    let balance = 0;
+
+    this.entries.forEach((entry) => {
+      if (
+        (closingDate &&
+          !momentClosingDate.isAfter(entry.date, 'day') &&
+          !momentClosingDate.isSame(entry.date, 'day')) ||
+        (entry.account !== accountId && accountId) ||
+        (contactId && entry.contactId !== contactId) ||
+        entry.contactType !== contactType
+      ) {
+        return;
+      }
+      if (entry.credit) {
+        balance -= entry.credit;
+      }
+      if (entry.debit) {
+        balance += entry.debit;
+      }
+    });
+    return balance;
+  }
+
+  getAccountEntries(accountId: number) {
+    return this.entries.filter((entry) => entry.account === accountId);
+  }
+
+  /**
+   * Retrieve account entries with depents accounts.
+   * @param {number} accountId - 
+   */
+  getAccountEntriesWithDepents(accountId: number) {
+    const depAccountsIds = this.accountsDepGraph.dependenciesOf(accountId);
+    const accountsIds = [accountId, ...depAccountsIds];
+
+    return this.entries.filter(
+      (entry) => accountsIds.indexOf(entry.account) !== -1
+    );
+  }
+
+  /**
+   * Retrieve total balnace of the given customer/vendor contact.
+   * @param {Number} accountId
+   * @param {Number} contactId
+   * @param {String} contactType
+   * @param {Date} closingDate
+   */
+  getEntriesBalance(entries) {
+    let balance = 0;
+
+    entries.forEach((entry) => {
+      if (entry.credit) {
+        balance -= entry.credit;
+      }
+      if (entry.debit) {
+        balance += entry.debit;
+      }
+    });
+    return balance;
+  }
+
+  getContactEntries(contactId: number, openingDate: Date, closingDate?: Date) {
+    const momentClosingDate = moment(closingDate);
+    const momentOpeningDate = moment(openingDate);
+
+    return this.entries.filter((entry) => {
+      if (
+        (closingDate &&
+          !momentClosingDate.isAfter(entry.date, 'day') &&
+          !momentClosingDate.isSame(entry.date, 'day')) ||
+        (openingDate &&
+          !momentOpeningDate.isBefore(entry.date, 'day') &&
+          !momentOpeningDate.isSame(entry.date)) ||
+        entry.contactId === contactId
+      ) {
+        return true;
+      }
+      return false;
+    });
+  }
+}
diff --git a/packages/server/src/services/Accounting/Ledger.ts b/packages/server/src/services/Accounting/Ledger.ts
new file mode 100644
index 000000000..ffd67a97a
--- /dev/null
+++ b/packages/server/src/services/Accounting/Ledger.ts
@@ -0,0 +1,249 @@
+import moment from 'moment';
+import { defaultTo, uniqBy } from 'lodash';
+import { IAccountTransaction, ILedger, ILedgerEntry } from '@/interfaces';
+
+export default class Ledger implements ILedger {
+  readonly entries: ILedgerEntry[];
+
+  /**
+   * Constructor method.
+   * @param {ILedgerEntry[]} entries
+   */
+  constructor(entries: ILedgerEntry[]) {
+    this.entries = entries;
+  }
+
+  /**
+   * Filters the ledegr entries.
+   * @param callback
+   * @returns {ILedger}
+   */
+  public filter(callback): ILedger {
+    const entries = this.entries.filter(callback);
+    return new Ledger(entries);
+  }
+
+  /**
+   * Retrieve the all entries of the ledger.
+   * @return {ILedgerEntry[]}
+   */
+  public getEntries(): ILedgerEntry[] {
+    return this.entries;
+  }
+
+  /**
+   * Filters entries by th given contact id and returns a new ledger.
+   * @param   {number} contactId
+   * @returns {ILedger}
+   */
+  public whereContactId(contactId: number): ILedger {
+    return this.filter((entry) => entry.contactId === contactId);
+  }
+
+  /**
+   * Filters entries by the given account id and returns a new ledger.
+   * @param   {number} accountId
+   * @returns {ILedger}
+   */
+  public whereAccountId(accountId: number): ILedger {
+    return this.filter((entry) => entry.accountId === accountId);
+  }
+
+  /**
+   * Filters entries that before or same the given date and returns a new ledger.
+   * @param   {Date|string} fromDate
+   * @returns {ILedger}
+   */
+  public whereFromDate(fromDate: Date | string): ILedger {
+    const fromDateParsed = moment(fromDate);
+
+    return this.filter(
+      (entry) =>
+        fromDateParsed.isBefore(entry.date) || fromDateParsed.isSame(entry.date)
+    );
+  }
+
+  /**
+   * Filters ledger entries that after the given date and retruns a new ledger.
+   * @param   {Date|string} toDate
+   * @returns {ILedger}
+   */
+  public whereToDate(toDate: Date | string): ILedger {
+    const toDateParsed = moment(toDate);
+
+    return this.filter(
+      (entry) =>
+        toDateParsed.isAfter(entry.date) || toDateParsed.isSame(entry.date)
+    );
+  }
+
+  /**
+   * Filters the ledget entries by the given currency code.
+   * @param   {string} currencyCode -
+   * @returns {ILedger}
+   */
+  public whereCurrencyCode(currencyCode: string): ILedger {
+    return this.filter((entry) => entry.currencyCode === currencyCode);
+  }
+
+  /**
+   * Filters the ledger entries by the given branch id.
+   * @param   {number} branchId
+   * @returns {ILedger}
+   */
+  public whereBranch(branchId: number): ILedger {
+    return this.filter((entry) => entry.branchId === branchId);
+  }
+
+  /**
+   *
+   * @param   {number} projectId
+   * @returns {ILedger}
+   */
+  public whereProject(projectId: number): ILedger {
+    return this.filter((entry) => entry.projectId === projectId);
+  }
+
+  /**
+   * Filters the ledger entries by the given item id.
+   * @param   {number} itemId
+   * @returns {ILedger}
+   */
+  public whereItem(itemId: number): ILedger {
+    return this.filter((entry) => entry.itemId === itemId);
+  }
+
+  /**
+   * Retrieve the closing balance of the entries.
+   * @returns {number}
+   */
+  public getClosingBalance(): number {
+    let closingBalance = 0;
+
+    this.entries.forEach((entry) => {
+      if (entry.accountNormal === 'credit') {
+        closingBalance += entry.credit - entry.debit;
+      } else if (entry.accountNormal === 'debit') {
+        closingBalance += entry.debit - entry.credit;
+      }
+    });
+    return closingBalance;
+  }
+
+  /**
+   * Retrieve the closing balance of the entries.
+   * @returns {number}
+   */
+  public getForeignClosingBalance(): number {
+    let closingBalance = 0;
+
+    this.entries.forEach((entry) => {
+      const exchangeRate = entry.exchangeRate || 1;
+
+      if (entry.accountNormal === 'credit') {
+        closingBalance += (entry.credit - entry.debit) / exchangeRate;
+      } else if (entry.accountNormal === 'debit') {
+        closingBalance += (entry.debit - entry.credit) / exchangeRate;
+      }
+    });
+    return closingBalance;
+  }
+
+  /**
+   * Detarmines whether the ledger has no entries.
+   * @returns {boolean}
+   */
+  public isEmpty(): boolean {
+    return this.entries.length === 0;
+  }
+
+  /**
+   * Retrieves the accounts ids of the entries uniquely.
+   * @returns {number[]}
+   */
+  public getAccountsIds = (): number[] => {
+    return uniqBy(this.entries, 'accountId').map(
+      (e: ILedgerEntry) => e.accountId
+    );
+  };
+
+  /**
+   * Retrieves the contacts ids of the entries uniquely.
+   * @returns {number[]}
+   */
+  public getContactsIds = (): number[] => {
+    return uniqBy(this.entries, 'contactId')
+      .filter((e: ILedgerEntry) => e.contactId)
+      .map((e: ILedgerEntry) => e.contactId);
+  };
+
+  /**
+   * Reverses the ledger entries.
+   * @returns {Ledger}
+   */
+  public reverse = (): Ledger => {
+    const newEntries = this.entries.map((e) => {
+      const credit = e.debit;
+      const debit = e.credit;
+
+      return { ...e, credit, debit };
+    });
+    return new Ledger(newEntries);
+  };
+
+  // ---------------------------------
+  // # STATIC METHODS.
+  // ----------------------------------
+
+  /**
+   * Mappes the account transactions to ledger entries.
+   * @param   {IAccountTransaction[]} entries
+   * @returns {ILedgerEntry[]}
+   */
+  static mappingTransactions(entries: IAccountTransaction[]): ILedgerEntry[] {
+    return entries.map(this.mapTransaction);
+  }
+
+  /**
+   * Mappes the account transaction to ledger entry.
+   * @param   {IAccountTransaction} entry
+   * @returns {ILedgerEntry}
+   */
+  static mapTransaction(entry: IAccountTransaction): ILedgerEntry {
+    return {
+      credit: defaultTo(entry.credit, 0),
+      debit: defaultTo(entry.debit, 0),
+      exchangeRate: entry.exchangeRate,
+      currencyCode: entry.currencyCode,
+
+      accountNormal: entry.account.accountNormal,
+      accountId: entry.accountId,
+      contactId: entry.contactId,
+
+      date: entry.date,
+
+      transactionId: entry.referenceId,
+      transactionType: entry.referenceType,
+
+      transactionNumber: entry.transactionNumber,
+      referenceNumber: entry.referenceNumber,
+
+      index: entry.index,
+      indexGroup: entry.indexGroup,
+
+      entryId: entry.id,
+      branchId: entry.branchId,
+      projectId: entry.projectId,
+    };
+  }
+
+  /**
+   * Mappes the account transactions to ledger entries.
+   * @param {IAccountTransaction[]} transactions
+   * @returns {ILedger}
+   */
+  static fromTransactions(transactions: IAccountTransaction[]): Ledger {
+    const entries = Ledger.mappingTransactions(transactions);
+    return new Ledger(entries);
+  }
+}
diff --git a/packages/server/src/services/Accounting/LedgerContactStorage.ts b/packages/server/src/services/Accounting/LedgerContactStorage.ts
new file mode 100644
index 000000000..06b5f9269
--- /dev/null
+++ b/packages/server/src/services/Accounting/LedgerContactStorage.ts
@@ -0,0 +1,103 @@
+import { Service, Inject } from 'typedi';
+import async from 'async';
+import { Knex } from 'knex';
+import { ILedger, ISaleContactsBalanceQueuePayload } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { TenantMetadata } from '@/system/models';
+
+@Service()
+export class LedgerContactsBalanceStorage {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   *
+   * @param   {number} tenantId -
+   * @param   {ILedger} ledger -
+   * @param   {Knex.Transaction} trx -
+   * @returns {Promise<void>}
+   */
+  public saveContactsBalance = async (
+    tenantId: number,
+    ledger: ILedger,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    // Save contact balance queue.
+    const saveContactsBalanceQueue = async.queue(
+      this.saveContactBalanceTask,
+      10
+    );
+    // Retrieves the effected contacts ids.
+    const effectedContactsIds = ledger.getContactsIds();
+
+    effectedContactsIds.forEach((contactId: number) => {
+      saveContactsBalanceQueue.push({ tenantId, contactId, ledger, trx });
+    });
+    if (effectedContactsIds.length > 0) await saveContactsBalanceQueue.drain();
+  };
+
+  /**
+   *
+   * @param   {ISaleContactsBalanceQueuePayload} task
+   * @returns {Promise<void>}
+   */
+  private saveContactBalanceTask = async (
+    task: ISaleContactsBalanceQueuePayload
+  ) => {
+    const { tenantId, contactId, ledger, trx } = task;
+
+    await this.saveContactBalance(tenantId, ledger, contactId, trx);
+  };
+
+  /**
+   *
+   * @param   {number} tenantId
+   * @param   {ILedger} ledger
+   * @param   {number} contactId
+   * @returns {Promise<void>}
+   */
+  private saveContactBalance = async (
+    tenantId: number,
+    ledger: ILedger,
+    contactId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { Contact } = this.tenancy.models(tenantId);
+    const contact = await Contact.query().findById(contactId);
+
+    // Retrieves the given tenant metadata.
+    const tenantMeta = await TenantMetadata.query().findOne({ tenantId });
+    
+    // Detarmines whether the contact has foreign currency.
+    const isForeignContact = contact.currencyCode !== tenantMeta.baseCurrency;
+
+    // Filters the ledger base on the given contact id.
+    const contactLedger = ledger.whereContactId(contactId);
+
+    const closingBalance = isForeignContact
+      ? contactLedger
+          .whereCurrencyCode(contact.currencyCode)
+          .getForeignClosingBalance()
+      : contactLedger.getClosingBalance();
+
+    await this.changeContactBalance(tenantId, contactId, closingBalance, trx);
+  };
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {number} contactId
+   * @param {number} change
+   * @returns
+   */
+  private changeContactBalance = (
+    tenantId: number,
+    contactId: number,
+    change: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { Contact } = this.tenancy.models(tenantId);
+
+    return Contact.changeAmount({ id: contactId }, 'balance', change, trx);
+  };
+}
diff --git a/packages/server/src/services/Accounting/LedgerEntriesStorage.ts b/packages/server/src/services/Accounting/LedgerEntriesStorage.ts
new file mode 100644
index 000000000..dd192b811
--- /dev/null
+++ b/packages/server/src/services/Accounting/LedgerEntriesStorage.ts
@@ -0,0 +1,87 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import async from 'async';
+import {
+  ILedgerEntry,
+  ISaveLedgerEntryQueuePayload,
+  ILedger,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { transformLedgerEntryToTransaction } from './utils';
+
+@Service()
+export class LedgerEntriesStorage {
+  @Inject()
+  tenancy: HasTenancyService;
+  /**
+   * Saves entries of the given ledger.
+   * @param   {number} tenantId
+   * @param   {ILedger} ledger
+   * @param   {Knex.Transaction} knex
+   * @returns {Promise<void>}
+   */
+  public saveEntries = async (
+    tenantId: number,
+    ledger: ILedger,
+    trx?: Knex.Transaction
+  ) => {
+    const saveEntryQueue = async.queue(this.saveEntryTask, 10);
+    const entries = ledger.getEntries();
+
+    entries.forEach((entry) => {
+      saveEntryQueue.push({ tenantId, entry, trx });
+    });
+    if (entries.length > 0) await saveEntryQueue.drain();
+  };
+
+  /**
+   * Deletes the ledger entries.
+   * @param {number} tenantId
+   * @param {ILedger} ledger
+   * @param {Knex.Transaction} trx
+   */
+  public deleteEntries = async (
+    tenantId: number,
+    ledger: ILedger,
+    trx?: Knex.Transaction
+  ) => {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+
+    const entriesIds = ledger
+      .getEntries()
+      .filter((e) => e.entryId)
+      .map((e) => e.entryId);
+
+    await AccountTransaction.query(trx).whereIn('id', entriesIds).delete();
+  };
+
+  /**
+   * Saves the ledger entry to the account transactions repository.
+   * @param   {number} tenantId
+   * @param   {ILedgerEntry} entry
+   * @returns {Promise<void>}
+   */
+  private saveEntry = async (
+    tenantId: number,
+    entry: ILedgerEntry,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+    const transaction = transformLedgerEntryToTransaction(entry);
+
+    await AccountTransaction.query(trx).insert(transaction);
+  };
+
+  /**
+   * Save the ledger entry to the transactions repository async task.
+   * @param   {ISaveLedgerEntryQueuePayload} task
+   * @returns {Promise<void>}
+   */
+  private saveEntryTask = async (
+    task: ISaveLedgerEntryQueuePayload
+  ): Promise<void> => {
+    const { entry, tenantId, trx } = task;
+
+    await this.saveEntry(tenantId, entry, trx);
+  };
+}
diff --git a/packages/server/src/services/Accounting/LedgerStorageRevert.ts b/packages/server/src/services/Accounting/LedgerStorageRevert.ts
new file mode 100644
index 000000000..0784c5d38
--- /dev/null
+++ b/packages/server/src/services/Accounting/LedgerStorageRevert.ts
@@ -0,0 +1,61 @@
+import { Inject } from 'typedi';
+import { castArray } from 'lodash';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import LedgerStorageService from './LedgerStorageService';
+import Ledger from './Ledger';
+import { Knex } from 'knex';
+
+export class LedgerRevert {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  ledgerStorage: LedgerStorageService;
+
+  /**
+   * Reverts the jouranl entries.
+   * @param {number|number[]} referenceId - Reference id.
+   * @param {string} referenceType - Reference type.
+   */
+  public getTransactionsByReference = async (
+    tenantId: number,
+    referenceId: number | number[],
+    referenceType: string | string[]
+  ) => {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+
+    const transactions = await AccountTransaction.query()
+      .whereIn('reference_type', castArray(referenceType))
+      .whereIn('reference_id', castArray(referenceId))
+      .withGraphFetched('account');
+
+    return transactions;
+  };
+
+  /**
+   *
+   * @param tenantId
+   * @param referenceId
+   * @param referenceType
+   * @param trx
+   */
+  public revertGLEntries = async (
+    tenantId: number,
+    referenceId: number | number[],
+    referenceType: string | string[],
+    trx?: Knex.Transaction
+  ) => {
+    //
+    const transactions = await this.getTransactionsByReference(
+      tenantId,
+      referenceId,
+      referenceType
+    );
+    // Creates a new ledger from transaction and reverse the entries.
+    const ledger = Ledger.fromTransactions(transactions);
+    const reversedLedger = ledger.reverse();
+
+    //
+    await this.ledgerStorage.commit(tenantId, reversedLedger, trx);
+  };
+}
diff --git a/packages/server/src/services/Accounting/LedgerStorageService.ts b/packages/server/src/services/Accounting/LedgerStorageService.ts
new file mode 100644
index 000000000..2ab78d8fb
--- /dev/null
+++ b/packages/server/src/services/Accounting/LedgerStorageService.ts
@@ -0,0 +1,98 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import { ILedger } from '@/interfaces';
+import { LedgerContactsBalanceStorage } from './LedgerContactStorage';
+import { LedegrAccountsStorage } from './LedgetAccountStorage';
+import { LedgerEntriesStorage } from './LedgerEntriesStorage';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import Ledger from './Ledger';
+@Service()
+export default class LedgerStorageService {
+  @Inject()
+  private ledgerEntriesService: LedgerEntriesStorage;
+
+  @Inject()
+  private ledgerContactsBalance: LedgerContactsBalanceStorage;
+
+  @Inject()
+  private ledgerAccountsBalance: LedegrAccountsStorage;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Commit the ledger to the storage layer as one unit-of-work.
+   * @param   {number} tenantId
+   * @param   {ILedger} ledger
+   * @returns {Promise<void>}
+   */
+  public commit = async (
+    tenantId: number,
+    ledger: ILedger,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const tasks = [
+      // Saves the ledger entries.
+      this.ledgerEntriesService.saveEntries(tenantId, ledger, trx),
+
+      // Mutates the assocaited accounts balances.
+      this.ledgerAccountsBalance.saveAccountsBalance(tenantId, ledger, trx),
+
+      // Mutates the associated contacts balances.
+      this.ledgerContactsBalance.saveContactsBalance(tenantId, ledger, trx),
+    ];
+    await Promise.all(tasks);
+  };
+
+  /**
+   * Deletes the given ledger and revert balances.
+   * @param   {number} tenantId
+   * @param   {ILedger} ledger
+   * @param   {Knex.Transaction} trx
+   * @returns {Promise<void>}
+   */
+  public delete = async (
+    tenantId: number,
+    ledger: ILedger,
+    trx?: Knex.Transaction
+  ) => {
+    const tasks = [
+      // Deletes the ledger entries.
+      this.ledgerEntriesService.deleteEntries(tenantId, ledger, trx),
+
+      // Mutates the assocaited accounts balances.
+      this.ledgerAccountsBalance.saveAccountsBalance(tenantId, ledger, trx),
+
+      // Mutates the associated contacts balances.
+      this.ledgerContactsBalance.saveContactsBalance(tenantId, ledger, trx),
+    ];
+    await Promise.all(tasks);
+  };
+
+  /**
+   * @param tenantId
+   * @param referenceId
+   * @param referenceType
+   * @param trx
+   */
+  public deleteByReference = async (
+    tenantId: number,
+    referenceId: number | number[],
+    referenceType: string | string[],
+    trx?: Knex.Transaction
+  ) => {
+    const { transactionsRepository } = this.tenancy.repositories(tenantId);
+
+    // Retrieves the transactions of the given reference.
+    const transactions =
+      await transactionsRepository.getTransactionsByReference(
+        referenceId,
+        referenceType
+      );
+    // Creates a new ledger from transaction and reverse the entries.
+    const reversedLedger = Ledger.fromTransactions(transactions).reverse();
+
+    // Deletes and reverts the balances.
+    await this.delete(tenantId, reversedLedger, trx);
+  };
+}
diff --git a/packages/server/src/services/Accounting/LedgetAccountStorage.ts b/packages/server/src/services/Accounting/LedgetAccountStorage.ts
new file mode 100644
index 000000000..0bb5ae8fb
--- /dev/null
+++ b/packages/server/src/services/Accounting/LedgetAccountStorage.ts
@@ -0,0 +1,155 @@
+import { Service, Inject } from 'typedi';
+import async from 'async';
+import { Knex } from 'knex';
+import { uniq } from 'lodash';
+import { ILedger, ISaveAccountsBalanceQueuePayload } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { TenantMetadata } from '@/system/models';
+
+@Service()
+export class LedegrAccountsStorage {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve depepants ids of the give accounts ids.
+   * @param   {number[]} accountsIds
+   * @param   depGraph
+   * @returns {number[]}
+   */
+  private getDependantsAccountsIds = (
+    accountsIds: number[],
+    depGraph
+  ): number[] => {
+    const depAccountsIds = [];
+
+    accountsIds.forEach((accountId: number) => {
+      const depAccountIds = depGraph.dependantsOf(accountId);
+      depAccountsIds.push(accountId, ...depAccountIds);
+    });
+    return uniq(depAccountsIds);
+  };
+
+  /**
+   *
+   * @param   {number} tenantId
+   * @param   {number[]} accountsIds
+   * @returns {number[]}
+   */
+  private findDependantsAccountsIds = async (
+    tenantId: number,
+    accountsIds: number[],
+    trx?: Knex.Transaction
+  ): Promise<number[]> => {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+    const accountsGraph = await accountRepository.getDependencyGraph(null, trx);
+
+    return this.getDependantsAccountsIds(accountsIds, accountsGraph);
+  };
+
+  /**
+   * Atomic mutation for accounts balances.
+   * @param   {number} tenantId
+   * @param   {ILedger} ledger
+   * @param   {Knex.Transaction} trx -
+   * @returns {Promise<void>}
+   */
+  public saveAccountsBalance = async (
+    tenantId: number,
+    ledger: ILedger,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    // Initiate a new queue for accounts balance mutation.
+    const saveAccountsBalanceQueue = async.queue(
+      this.saveAccountBalanceTask,
+      10
+    );
+    const effectedAccountsIds = ledger.getAccountsIds();
+    const dependAccountsIds = await this.findDependantsAccountsIds(
+      tenantId,
+      effectedAccountsIds,
+      trx
+    );
+    dependAccountsIds.forEach((accountId: number) => {
+      saveAccountsBalanceQueue.push({ tenantId, ledger, accountId, trx });
+    });
+    if (dependAccountsIds.length > 0) {
+      await saveAccountsBalanceQueue.drain();
+    }
+  };
+
+  /**
+   * Async task mutates the given account balance.
+   * @param   {ISaveAccountsBalanceQueuePayload} task
+   * @returns {Promise<void>}
+   */
+  private saveAccountBalanceTask = async (
+    task: ISaveAccountsBalanceQueuePayload
+  ): Promise<void> => {
+    const { tenantId, ledger, accountId, trx } = task;
+
+    await this.saveAccountBalanceFromLedger(tenantId, ledger, accountId, trx);
+  };
+
+  /**
+   * Saves specific account balance from the given ledger.
+   * @param   {number} tenantId
+   * @param   {ILedger} ledger
+   * @param   {number} accountId
+   * @param   {Knex.Transaction} trx -
+   * @returns {Promise<void>}
+   */
+  private saveAccountBalanceFromLedger = async (
+    tenantId: number,
+    ledger: ILedger,
+    accountId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { Account } = this.tenancy.models(tenantId);
+    const account = await Account.query(trx).findById(accountId);
+
+    // Filters the ledger entries by the current acount.
+    const accountLedger = ledger.whereAccountId(accountId);
+
+    // Retrieves the given tenant metadata.
+    const tenantMeta = await TenantMetadata.query().findOne({ tenantId });
+
+    // Detarmines whether the account has foreign currency.
+    const isAccountForeign = account.currencyCode !== tenantMeta.baseCurrency;
+
+    // Calculates the closing foreign balance by the given currency if account was has
+    // foreign currency otherwise get closing balance.
+    const closingBalance = isAccountForeign
+      ? accountLedger
+          .whereCurrencyCode(account.currencyCode)
+          .getForeignClosingBalance()
+      : accountLedger.getClosingBalance();
+
+    await this.saveAccountBalance(tenantId, accountId, closingBalance, trx);
+  };
+
+  /**
+   * Saves the account balance.
+   * @param   {number} tenantId
+   * @param   {number} accountId
+   * @param   {number} change
+   * @param   {Knex.Transaction} trx -
+   * @returns {Promise<void>}
+   */
+  private saveAccountBalance = async (
+    tenantId: number,
+    accountId: number,
+    change: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { Account } = this.tenancy.models(tenantId);
+
+    // Ensure the account has atleast zero in amount.
+    await Account.query(trx)
+      .findById(accountId)
+      .whereNull('amount')
+      .patch({ amount: 0 });
+
+    await Account.changeAmount({ id: accountId }, 'amount', change, trx);
+  };
+}
diff --git a/packages/server/src/services/Accounting/utils.ts b/packages/server/src/services/Accounting/utils.ts
new file mode 100644
index 000000000..081a0d14c
--- /dev/null
+++ b/packages/server/src/services/Accounting/utils.ts
@@ -0,0 +1,34 @@
+import { IAccountTransaction, ILedgerEntry } from '@/interfaces';
+
+export const transformLedgerEntryToTransaction = (
+  entry: ILedgerEntry
+): IAccountTransaction => {
+  return {
+    date: entry.date,
+
+    credit: entry.credit,
+    debit: entry.debit,
+
+    currencyCode: entry.currencyCode,
+    exchangeRate: entry.exchangeRate,
+
+    accountId: entry.accountId,
+    contactId: entry.contactId,
+
+    referenceType: entry.transactionType,
+    referenceId: entry.transactionId,
+
+    transactionNumber: entry.transactionNumber,
+    referenceNumber: entry.referenceNumber,
+
+    index: entry.index,
+    indexGroup: entry.indexGroup,
+
+    branchId: entry.branchId,
+    userId: entry.userId,
+    itemId: entry.itemId,
+    projectId: entry.projectId,
+
+    costable: entry.costable,
+  };
+};
diff --git a/packages/server/src/services/Accounts/AccountTransactionTransformer.ts b/packages/server/src/services/Accounts/AccountTransactionTransformer.ts
new file mode 100644
index 000000000..2c16aac76
--- /dev/null
+++ b/packages/server/src/services/Accounts/AccountTransactionTransformer.ts
@@ -0,0 +1,125 @@
+import { IAccountTransaction } from '@/interfaces';
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { transaction } from 'objection';
+
+export default class AccountTransactionTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'date',
+      'formattedDate',
+      'transactionType',
+      'transactionId',
+      'transactionTypeFormatted',
+      'credit',
+      'debit',
+      'formattedCredit',
+      'formattedDebit',
+      'fcCredit',
+      'fcDebit',
+      'formattedFcCredit',
+      'formattedFcDebit',
+    ];
+  };
+
+  /**
+   * Exclude all attributes of the model.
+   * @returns {Array<string>}
+   */
+  public excludeAttributes = (): string[] => {
+    return ['*'];
+  };
+
+  /**
+   * Retrieves the formatted date.
+   * @returns {string}
+   */
+  public formattedDate(transaction: IAccountTransaction) {
+    return this.formatDate(transaction.date);
+  }
+
+  /**
+   * Retrieves the formatted transaction type.
+   * @returns {string}
+   */
+  public transactionTypeFormatted(transaction: IAccountTransaction) {
+    return transaction.referenceTypeFormatted;
+  }
+
+  /**
+   * Retrieves the tranasction type.
+   * @returns {string}
+   */
+  public transactionType(transaction: IAccountTransaction) {
+    return transaction.referenceType;
+  }
+
+  /**
+   * Retrieves the transaction id.
+   * @returns {number}
+   */
+  public transactionId(transaction: IAccountTransaction) {
+    return transaction.referenceId;
+  }
+
+  /**
+   * Retrieves the credit amount.
+   * @returns {string}
+   */
+  protected formattedCredit(transaction: IAccountTransaction) {
+    return this.formatMoney(transaction.credit, {
+      excerptZero: true,
+    });
+  }
+
+  /**
+   * Retrieves the credit amount.
+   * @returns {string}
+   */
+  protected formattedDebit(transaction: IAccountTransaction) {
+    return this.formatMoney(transaction.debit, {
+      excerptZero: true,
+    });
+  }
+
+  /**
+   * Retrieves the foreign credit amount.
+   * @returns {number}
+   */
+  protected fcCredit(transaction: IAccountTransaction) {
+    return transaction.credit * transaction.exchangeRate;
+  }
+
+  /**
+   * Retrieves the foreign debit amount.
+   * @returns {number}
+   */
+  protected fcDebit(transaction: IAccountTransaction) {
+    return transaction.debit * transaction.exchangeRate;
+  }
+
+  /**
+   * Retrieves the formatted foreign credit amount.
+   * @returns {string}
+   */
+  protected formattedFcCredit(transaction: IAccountTransaction) {
+    return this.formatMoney(this.fcDebit(transaction), {
+      currencyCode: transaction.currencyCode,
+      excerptZero: true,
+    });
+  }
+
+  /**
+   * Retrieves the formatted foreign debit amount.
+   * @returns {string}
+   */
+  protected formattedFcDebit(transaction: IAccountTransaction) {
+    return this.formatMoney(this.fcCredit(transaction), {
+      currencyCode: transaction.currencyCode,
+      excerptZero: true,
+    });
+  }
+}
diff --git a/packages/server/src/services/Accounts/AccountTransform.ts b/packages/server/src/services/Accounts/AccountTransform.ts
new file mode 100644
index 000000000..62e3eddd7
--- /dev/null
+++ b/packages/server/src/services/Accounts/AccountTransform.ts
@@ -0,0 +1,24 @@
+import { IAccount } from '@/interfaces';
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class AccountTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return ['formattedAmount'];
+  };
+
+  /**
+   * Retrieve formatted account amount.
+   * @param   {IAccount} invoice
+   * @returns {string}
+   */
+  protected formattedAmount = (account: IAccount): string => {
+    return formatNumber(account.amount, {
+      currencyCode: account.currencyCode,
+    });
+  };
+}
diff --git a/packages/server/src/services/Accounts/AccountsApplication.ts b/packages/server/src/services/Accounts/AccountsApplication.ts
new file mode 100644
index 000000000..5e7043b9a
--- /dev/null
+++ b/packages/server/src/services/Accounts/AccountsApplication.ts
@@ -0,0 +1,139 @@
+import { Service, Inject } from 'typedi';
+import {
+  IAccount,
+  IAccountCreateDTO,
+  IAccountEditDTO,
+  IAccountsFilter,
+  IAccountsTransactionsFilter,
+  IGetAccountTransactionPOJO,
+} from '@/interfaces';
+import { CreateAccount } from './CreateAccount';
+import { DeleteAccount } from './DeleteAccount';
+import { EditAccount } from './EditAccount';
+import { ActivateAccount } from './ActivateAccount';
+import { GetAccounts } from './GetAccounts';
+import { GetAccount } from './GetAccount';
+import { GetAccountTransactions } from './GetAccountTransactions';
+@Service()
+export class AccountsApplication {
+  @Inject()
+  private createAccountService: CreateAccount;
+
+  @Inject()
+  private deleteAccountService: DeleteAccount;
+
+  @Inject()
+  private editAccountService: EditAccount;
+
+  @Inject()
+  private activateAccountService: ActivateAccount;
+
+  @Inject()
+  private getAccountsService: GetAccounts;
+
+  @Inject()
+  private getAccountService: GetAccount;
+
+  @Inject()
+  private getAccountTransactionsService: GetAccountTransactions;
+
+  /**
+   * Creates a new account.
+   * @param   {number} tenantId
+   * @param   {IAccountCreateDTO} accountDTO
+   * @returns {Promise<IAccount>}
+   */
+  public createAccount = (
+    tenantId: number,
+    accountDTO: IAccountCreateDTO
+  ): Promise<IAccount> => {
+    return this.createAccountService.createAccount(tenantId, accountDTO);
+  };
+
+  /**
+   * Deletes the given account.
+   * @param   {number} tenantId
+   * @param   {number} accountId
+   * @returns {Promise<void>}
+   */
+  public deleteAccount = (tenantId: number, accountId: number) => {
+    return this.deleteAccountService.deleteAccount(tenantId, accountId);
+  };
+
+  /**
+   * Edits the given account.
+   * @param {number} tenantId
+   * @param {number} accountId
+   * @param {IAccountEditDTO} accountDTO
+   * @returns
+   */
+  public editAccount = (
+    tenantId: number,
+    accountId: number,
+    accountDTO: IAccountEditDTO
+  ) => {
+    return this.editAccountService.editAccount(tenantId, accountId, accountDTO);
+  };
+
+  /**
+   * Activate the given account.
+   * @param {number} tenantId -
+   * @param {number} accountId -
+   */
+  public activateAccount = (tenantId: number, accountId: number) => {
+    return this.activateAccountService.activateAccount(
+      tenantId,
+      accountId,
+      true
+    );
+  };
+
+  /**
+   * Inactivate the given account.
+   * @param {number} tenantId -
+   * @param {number} accountId -
+   */
+  public inactivateAccount = (tenantId: number, accountId: number) => {
+    return this.activateAccountService.activateAccount(
+      tenantId,
+      accountId,
+      false
+    );
+  };
+
+  /**
+   * Retrieves the account details.
+   * @param   {number} tenantId
+   * @param   {number} accountId
+   * @returns {Promise<IAccount>}
+   */
+  public getAccount = (tenantId: number, accountId: number) => {
+    return this.getAccountService.getAccount(tenantId, accountId);
+  };
+
+  /**
+   * Retrieves the accounts list.
+   * @param   {number} tenantId
+   * @param   {IAccountsFilter} filterDTO
+   * @returns
+   */
+  public getAccounts = (tenantId: number, filterDTO: IAccountsFilter) => {
+    return this.getAccountsService.getAccountsList(tenantId, filterDTO);
+  };
+
+  /**
+   * Retrieves the given account transactions.
+   * @param    {number} tenantId
+   * @param    {IAccountsTransactionsFilter} filter
+   * @returns  {Promise<IGetAccountTransactionPOJO[]>}
+   */
+  public getAccountsTransactions = (
+    tenantId: number,
+    filter: IAccountsTransactionsFilter
+  ): Promise<IGetAccountTransactionPOJO[]> => {
+    return this.getAccountTransactionsService.getAccountsTransactions(
+      tenantId,
+      filter
+    );
+  };
+}
diff --git a/packages/server/src/services/Accounts/AccountsTypesServices.ts b/packages/server/src/services/Accounts/AccountsTypesServices.ts
new file mode 100644
index 000000000..25de9ab5c
--- /dev/null
+++ b/packages/server/src/services/Accounts/AccountsTypesServices.ts
@@ -0,0 +1,21 @@
+import { Inject, Service } from 'typedi';
+import { IAccountsTypesService, IAccountType } from '@/interfaces';
+import AccountTypesUtils from '@/lib/AccountTypes';
+import I18nService from '@/services/I18n/I18nService';
+
+
+@Service()
+export default class AccountsTypesService implements IAccountsTypesService {
+  @Inject()
+  i18nService: I18nService;
+
+  /**
+   * Retrieve all accounts types.
+   * @param {number} tenantId - 
+   * @return {IAccountType}
+   */
+  public getAccountsTypes(tenantId: number): IAccountType[] {
+    const accountTypes = AccountTypesUtils.getList();
+    return this.i18nService.i18nMapper(accountTypes, ['label'], tenantId);
+  }
+}
diff --git a/packages/server/src/services/Accounts/ActivateAccount.ts b/packages/server/src/services/Accounts/ActivateAccount.ts
new file mode 100644
index 000000000..1fcd104f6
--- /dev/null
+++ b/packages/server/src/services/Accounts/ActivateAccount.ts
@@ -0,0 +1,64 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import { IAccountEventActivatedPayload } from '@/interfaces';
+import events from '@/subscribers/events';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import { CommandAccountValidators } from './CommandAccountValidators';
+
+@Service()
+export class ActivateAccount {
+  @Inject()
+  private tenancy: TenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private validator: CommandAccountValidators;
+
+  /**
+   * Activates/Inactivates the given account.
+   * @param {number} tenantId
+   * @param {number} accountId
+   * @param {boolean} activate
+   */
+  public activateAccount = async (
+    tenantId: number,
+    accountId: number,
+    activate?: boolean
+  ) => {
+    const { Account } = this.tenancy.models(tenantId);
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    // Retrieve the given account or throw not found error.
+    const oldAccount = await Account.query()
+      .findById(accountId)
+      .throwIfNotFound();
+
+    // Get all children accounts.
+    const accountsGraph = await accountRepository.getDependencyGraph();
+    const dependenciesAccounts = accountsGraph.dependenciesOf(accountId);
+
+    const patchAccountsIds = [...dependenciesAccounts, accountId];
+
+    // Activate account and associated transactions under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Activate and inactivate the given accounts ids.
+      activate
+        ? await accountRepository.activateByIds(patchAccountsIds, trx)
+        : await accountRepository.inactivateByIds(patchAccountsIds, trx);
+
+      // Triggers `onAccountActivated` event.
+      this.eventPublisher.emitAsync(events.accounts.onActivated, {
+        tenantId,
+        accountId,
+        trx,
+      } as IAccountEventActivatedPayload);
+    });
+  };
+}
diff --git a/packages/server/src/services/Accounts/CommandAccountValidators.ts b/packages/server/src/services/Accounts/CommandAccountValidators.ts
new file mode 100644
index 000000000..e499c51fa
--- /dev/null
+++ b/packages/server/src/services/Accounts/CommandAccountValidators.ts
@@ -0,0 +1,211 @@
+import { Inject, Service } from 'typedi';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import { ServiceError } from '@/exceptions';
+import { IAccountDTO, IAccount, IAccountCreateDTO } from '@/interfaces';
+import AccountTypesUtils from '@/lib/AccountTypes';
+import { ERRORS } from './constants';
+
+@Service()
+export class CommandAccountValidators {
+  @Inject()
+  private tenancy: TenancyService;
+
+  /**
+   * Throws error if the account was prefined.
+   * @param {IAccount} account
+   */
+  public throwErrorIfAccountPredefined(account: IAccount) {
+    if (account.predefined) {
+      throw new ServiceError(ERRORS.ACCOUNT_PREDEFINED);
+    }
+  }
+
+  /**
+   * Diff account type between new and old account, throw service error
+   * if they have different account type.
+   *
+   * @param {IAccount|IAccountDTO} oldAccount
+   * @param {IAccount|IAccountDTO} newAccount
+   */
+  public async isAccountTypeChangedOrThrowError(
+    oldAccount: IAccount | IAccountDTO,
+    newAccount: IAccount | IAccountDTO
+  ) {
+    if (oldAccount.accountType !== newAccount.accountType) {
+      throw new ServiceError(ERRORS.ACCOUNT_TYPE_NOT_ALLOWED_TO_CHANGE);
+    }
+  }
+
+  /**
+   * Retrieve account type or throws service error.
+   * @param {number} tenantId -
+   * @param {number} accountTypeId -
+   * @return {IAccountType}
+   */
+  public getAccountTypeOrThrowError(accountTypeKey: string) {
+    const accountType = AccountTypesUtils.getType(accountTypeKey);
+
+    if (!accountType) {
+      throw new ServiceError(ERRORS.ACCOUNT_TYPE_NOT_FOUND);
+    }
+    return accountType;
+  }
+
+  /**
+   * Retrieve parent account or throw service error.
+   * @param {number} tenantId
+   * @param {number} accountId
+   * @param {number} notAccountId
+   */
+  public async getParentAccountOrThrowError(
+    tenantId: number,
+    accountId: number,
+    notAccountId?: number
+  ) {
+    const { Account } = this.tenancy.models(tenantId);
+
+    const parentAccount = await Account.query()
+      .findById(accountId)
+      .onBuild((query) => {
+        if (notAccountId) {
+          query.whereNot('id', notAccountId);
+        }
+      });
+    if (!parentAccount) {
+      throw new ServiceError(ERRORS.PARENT_ACCOUNT_NOT_FOUND);
+    }
+    return parentAccount;
+  }
+
+  /**
+   * Throws error if the account type was not unique on the storage.
+   * @param {number} tenantId
+   * @param {string} accountCode
+   * @param {number} notAccountId
+   */
+  public async isAccountCodeUniqueOrThrowError(
+    tenantId: number,
+    accountCode: string,
+    notAccountId?: number
+  ) {
+    const { Account } = this.tenancy.models(tenantId);
+
+    const account = await Account.query()
+      .where('code', accountCode)
+      .onBuild((query) => {
+        if (notAccountId) {
+          query.whereNot('id', notAccountId);
+        }
+      });
+
+    if (account.length > 0) {
+      throw new ServiceError(ERRORS.ACCOUNT_CODE_NOT_UNIQUE);
+    }
+  }
+
+  /**
+   * Validates the account name uniquiness.
+   * @param {number} tenantId
+   * @param {string} accountName
+   * @param {number} notAccountId - Ignore the account id.
+   */
+  public async validateAccountNameUniquiness(
+    tenantId: number,
+    accountName: string,
+    notAccountId?: number
+  ) {
+    const { Account } = this.tenancy.models(tenantId);
+
+    const foundAccount = await Account.query()
+      .findOne('name', accountName)
+      .onBuild((query) => {
+        if (notAccountId) {
+          query.whereNot('id', notAccountId);
+        }
+      });
+    if (foundAccount) {
+      throw new ServiceError(ERRORS.ACCOUNT_NAME_NOT_UNIQUE);
+    }
+  }
+
+  /**
+   * Validates the given account type supports multi-currency.
+   * @param {IAccountDTO} accountDTO -
+   */
+  public validateAccountTypeSupportCurrency = (
+    accountDTO: IAccountCreateDTO,
+    baseCurrency: string
+  ) => {
+    // Can't continue to validate the type has multi-currency feature
+    // if the given currency equals the base currency or not assigned.
+    if (accountDTO.currencyCode === baseCurrency || !accountDTO.currencyCode) {
+      return;
+    }
+    const meta = AccountTypesUtils.getType(accountDTO.accountType);
+
+    // Throw error if the account type does not support multi-currency.
+    if (!meta?.multiCurrency) {
+      throw new ServiceError(ERRORS.ACCOUNT_TYPE_NOT_SUPPORTS_MULTI_CURRENCY);
+    }
+  };
+
+  /**
+   * Validates the account DTO currency code whether equals the currency code of
+   * parent account.
+   * @param  {IAccountCreateDTO} accountDTO
+   * @param  {IAccount} parentAccount
+   * @param  {string} baseCurrency - 
+   * @throws {ServiceError(ERRORS.ACCOUNT_CURRENCY_NOT_SAME_PARENT_ACCOUNT)}
+   */
+  public validateCurrentSameParentAccount = (
+    accountDTO: IAccountCreateDTO,
+    parentAccount: IAccount,
+    baseCurrency: string,
+  ) => {
+    // If the account DTO currency not assigned and the parent account has no base currency.
+    if (
+      !accountDTO.currencyCode &&
+      parentAccount.currencyCode !== baseCurrency
+    ) {
+      throw new ServiceError(ERRORS.ACCOUNT_CURRENCY_NOT_SAME_PARENT_ACCOUNT);
+    }
+    // If the account DTO is assigned and not equals the currency code of parent account.
+    if (
+      accountDTO.currencyCode &&
+      parentAccount.currencyCode !== accountDTO.currencyCode
+    ) {
+      throw new ServiceError(ERRORS.ACCOUNT_CURRENCY_NOT_SAME_PARENT_ACCOUNT);
+    }
+  };
+
+  /**
+   * Throws service error if parent account has different type.
+   * @param {IAccountDTO} accountDTO
+   * @param {IAccount} parentAccount
+   */
+  public throwErrorIfParentHasDiffType(
+    accountDTO: IAccountDTO,
+    parentAccount: IAccount
+  ) {
+    if (accountDTO.accountType !== parentAccount.accountType) {
+      throw new ServiceError(ERRORS.PARENT_ACCOUNT_HAS_DIFFERENT_TYPE);
+    }
+  }
+
+  /**
+   * Retrieve account of throw service error in case account not found.
+   * @param {number} tenantId
+   * @param {number} accountId
+   * @return {IAccount}
+   */
+  public async getAccountOrThrowError(tenantId: number, accountId: number) {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    const account = await accountRepository.findOneById(accountId);
+
+    if (!account) {
+      throw new ServiceError(ERRORS.ACCOUNT_NOT_FOUND);
+    }
+    return account;
+  }
+}
diff --git a/packages/server/src/services/Accounts/CreateAccount.ts b/packages/server/src/services/Accounts/CreateAccount.ts
new file mode 100644
index 000000000..fc9342a80
--- /dev/null
+++ b/packages/server/src/services/Accounts/CreateAccount.ts
@@ -0,0 +1,140 @@
+import { Inject, Service } from 'typedi';
+import { kebabCase } from 'lodash';
+import { Knex } from 'knex';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import {
+  IAccount,
+  IAccountEventCreatedPayload,
+  IAccountEventCreatingPayload,
+  IAccountCreateDTO,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import { TenantMetadata } from '@/system/models';
+import { CommandAccountValidators } from './CommandAccountValidators';
+
+@Service()
+export class CreateAccount {
+  @Inject()
+  private tenancy: TenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private validator: CommandAccountValidators;
+
+  /**
+   * Authorize the account creation.
+   * @param  {number} tenantId
+   * @param  {IAccountCreateDTO} accountDTO
+   */
+  private authorize = async (
+    tenantId: number,
+    accountDTO: IAccountCreateDTO,
+    baseCurrency: string
+  ) => {
+    // Validate account name uniquiness.
+    await this.validator.validateAccountNameUniquiness(
+      tenantId,
+      accountDTO.name
+    );
+    // Validate the account code uniquiness.
+    if (accountDTO.code) {
+      await this.validator.isAccountCodeUniqueOrThrowError(
+        tenantId,
+        accountDTO.code
+      );
+    }
+    // Retrieve the account type meta or throw service error if not found.
+    this.validator.getAccountTypeOrThrowError(accountDTO.accountType);
+
+    // Ingore the parent account validation if not presented.
+    if (accountDTO.parentAccountId) {
+      const parentAccount = await this.validator.getParentAccountOrThrowError(
+        tenantId,
+        accountDTO.parentAccountId
+      );
+      this.validator.throwErrorIfParentHasDiffType(accountDTO, parentAccount);
+
+      // Inherit active status from parent account.
+      accountDTO.active = parentAccount.active;
+
+      // Validate should currency code be the same currency of parent account.
+      this.validator.validateCurrentSameParentAccount(
+        accountDTO,
+        parentAccount,
+        baseCurrency
+      );
+    }
+    // Validates the given account type supports the multi-currency.
+    this.validator.validateAccountTypeSupportCurrency(accountDTO, baseCurrency);
+  };
+
+  /**
+   * Transformes the create account DTO to input model.
+   * @param   {IAccountCreateDTO} createAccountDTO
+   */
+  private transformDTOToModel = (
+    createAccountDTO: IAccountCreateDTO,
+    baseCurrency: string
+  ) => {
+    return {
+      ...createAccountDTO,
+      slug: kebabCase(createAccountDTO.name),
+      currencyCode: createAccountDTO.currencyCode || baseCurrency,
+    };
+  };
+
+  /**
+   * Creates a new account on the storage.
+   * @param   {number} tenantId
+   * @param   {IAccountCreateDTO} accountDTO
+   * @returns {Promise<IAccount>}
+   */
+  public createAccount = async (
+    tenantId: number,
+    accountDTO: IAccountCreateDTO
+  ): Promise<IAccount> => {
+    const { Account } = this.tenancy.models(tenantId);
+
+    // Retrieves the given tenant metadata.
+    const tenantMeta = await TenantMetadata.query().findOne({ tenantId });
+
+    // Authorize the account creation.
+    await this.authorize(tenantId, accountDTO, tenantMeta.baseCurrency);
+
+    // Transformes the DTO to model.
+    const accountInputModel = this.transformDTOToModel(
+      accountDTO,
+      tenantMeta.baseCurrency
+    );
+    // Creates a new account with associated transactions under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onAccountCreating` event.
+      await this.eventPublisher.emitAsync(events.accounts.onCreating, {
+        tenantId,
+        accountDTO,
+        trx,
+      } as IAccountEventCreatingPayload);
+
+      // Inserts account to the storage.
+      const account = await Account.query(trx).insertAndFetch({
+        ...accountInputModel,
+      });
+      // Triggers `onAccountCreated` event.
+      await this.eventPublisher.emitAsync(events.accounts.onCreated, {
+        tenantId,
+        account,
+        accountId: account.id,
+        trx,
+      } as IAccountEventCreatedPayload);
+
+      return account;
+    });
+  };
+}
diff --git a/packages/server/src/services/Accounts/DeleteAccount.ts b/packages/server/src/services/Accounts/DeleteAccount.ts
new file mode 100644
index 000000000..4534d5fdd
--- /dev/null
+++ b/packages/server/src/services/Accounts/DeleteAccount.ts
@@ -0,0 +1,107 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { IAccountEventDeletedPayload, IAccount } from '@/interfaces';
+import events from '@/subscribers/events';
+import { CommandAccountValidators } from './CommandAccountValidators';
+import { ERRORS } from './constants';
+
+@Service()
+export class DeleteAccount {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private validator: CommandAccountValidators;
+
+  /**
+   * Authorize account delete.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} accountId - Account id.
+   */
+  private authorize = async (
+    tenantId: number,
+    accountId: number,
+    oldAccount: IAccount
+  ) => {
+    // Throw error if the account was predefined.
+    this.validator.throwErrorIfAccountPredefined(oldAccount);
+  };
+
+  /**
+   * Unlink the given parent account with children accounts.
+   * @param {number} tenantId -
+   * @param {number|number[]} parentAccountId -
+   */
+  private async unassociateChildrenAccountsFromParent(
+    tenantId: number,
+    parentAccountId: number | number[],
+    trx?: Knex.Transaction
+  ) {
+    const { Account } = this.tenancy.models(tenantId);
+    const accountsIds = Array.isArray(parentAccountId)
+      ? parentAccountId
+      : [parentAccountId];
+
+    await Account.query(trx)
+      .whereIn('parent_account_id', accountsIds)
+      .patch({ parent_account_id: null });
+  }
+
+  /**
+   * Deletes the account from the storage.
+   * @param {number} tenantId
+   * @param {number} accountId
+   */
+  public deleteAccount = async (
+    tenantId: number,
+    accountId: number
+  ): Promise<void> => {
+    const { Account } = this.tenancy.models(tenantId);
+
+    // Retrieve account or not found service error.
+    const oldAccount = await Account.query()
+      .findById(accountId)
+      .throwIfNotFound()
+      .queryAndThrowIfHasRelations({
+        type: ERRORS.ACCOUNT_HAS_ASSOCIATED_TRANSACTIONS,
+      });
+    // Authorize before delete account.
+    await this.authorize(tenantId, accountId, oldAccount);
+
+    // Deletes the account and assocaited transactions under UOW envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onAccountDelete` event.
+      await this.eventPublisher.emitAsync(events.accounts.onDelete, {
+        trx,
+        oldAccount,
+        tenantId,
+      } as IAccountEventDeletedPayload);
+
+      // Unlink the parent account from children accounts.
+      await this.unassociateChildrenAccountsFromParent(
+        tenantId,
+        accountId,
+        trx
+      );
+      // Deletes account by the given id.
+      await Account.query(trx).findById(accountId).delete();
+
+      // Triggers `onAccountDeleted` event.
+      await this.eventPublisher.emitAsync(events.accounts.onDeleted, {
+        tenantId,
+        accountId,
+        oldAccount,
+        trx,
+      } as IAccountEventDeletedPayload);
+    });
+  };
+}
diff --git a/packages/server/src/services/Accounts/EditAccount.ts b/packages/server/src/services/Accounts/EditAccount.ts
new file mode 100644
index 000000000..3f55f4eb0
--- /dev/null
+++ b/packages/server/src/services/Accounts/EditAccount.ts
@@ -0,0 +1,116 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import {
+  IAccountEventEditedPayload,
+  IAccountEditDTO,
+  IAccount,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import { CommandAccountValidators } from './CommandAccountValidators';
+
+@Service()
+export class EditAccount {
+  @Inject()
+  private tenancy: TenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private validator: CommandAccountValidators;
+
+  /**
+   * Authorize the account editing.
+   * @param {number} tenantId
+   * @param {number} accountId
+   * @param {IAccountEditDTO} accountDTO
+   * @param {IAccount} oldAccount -
+   */
+  private authorize = async (
+    tenantId: number,
+    accountId: number,
+    accountDTO: IAccountEditDTO,
+    oldAccount: IAccount
+  ) => {
+    // Validate account name uniquiness.
+    await this.validator.validateAccountNameUniquiness(
+      tenantId,
+      accountDTO.name,
+      accountId
+    );
+    // Validate the account type should be not mutated.
+    await this.validator.isAccountTypeChangedOrThrowError(
+      oldAccount,
+      accountDTO
+    );
+    // Validate the account code not exists on the storage.
+    if (accountDTO.code && accountDTO.code !== oldAccount.code) {
+      await this.validator.isAccountCodeUniqueOrThrowError(
+        tenantId,
+        accountDTO.code,
+        oldAccount.id
+      );
+    }
+    // Retrieve the parent account of throw not found service error.
+    if (accountDTO.parentAccountId) {
+      const parentAccount = await this.validator.getParentAccountOrThrowError(
+        tenantId,
+        accountDTO.parentAccountId,
+        oldAccount.id
+      );
+      this.validator.throwErrorIfParentHasDiffType(accountDTO, parentAccount);
+    }
+  };
+
+  /**
+   * Edits details of the given account.
+   * @param {number} tenantId
+   * @param {number} accountId
+   * @param {IAccountDTO} accountDTO
+   */
+  public async editAccount(
+    tenantId: number,
+    accountId: number,
+    accountDTO: IAccountEditDTO
+  ): Promise<IAccount> {
+    const { Account } = this.tenancy.models(tenantId);
+
+    // Retrieve the old account or throw not found service error.
+    const oldAccount = await Account.query()
+      .findById(accountId)
+      .throwIfNotFound();
+
+    // Authorize the account editing.
+    await this.authorize(tenantId, accountId, accountDTO, oldAccount);
+
+    // Edits account and associated transactions under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onAccountEditing` event.
+      await this.eventPublisher.emitAsync(events.accounts.onEditing, {
+        tenantId,
+        oldAccount,
+        accountDTO,
+      });
+      // Update the account on the storage.
+      const account = await Account.query(trx)
+        .findById(accountId)
+        .update({ ...accountDTO });
+
+      // Triggers `onAccountEdited` event.
+      await this.eventPublisher.emitAsync(events.accounts.onEdited, {
+        tenantId,
+        account,
+        oldAccount,
+        trx,
+      } as IAccountEventEditedPayload);
+
+      return account;
+    });
+  }
+}
diff --git a/packages/server/src/services/Accounts/GetAccount.ts b/packages/server/src/services/Accounts/GetAccount.ts
new file mode 100644
index 000000000..f14c1afc7
--- /dev/null
+++ b/packages/server/src/services/Accounts/GetAccount.ts
@@ -0,0 +1,41 @@
+import { Service, Inject } from 'typedi';
+import I18nService from '@/services/I18n/I18nService';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { AccountTransformer } from './AccountTransform';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export class GetAccount {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private i18nService: I18nService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the given account details.
+   * @param {number} tenantId
+   * @param {number} accountId
+   */
+  public getAccount = async (tenantId: number, accountId: number) => {
+    const { Account } = this.tenancy.models(tenantId);
+
+    // Find the given account or throw not found error.
+    const account = await Account.query().findById(accountId).throwIfNotFound();
+
+    // Transformes the account model to POJO.
+    const transformed = await this.transformer.transform(
+      tenantId,
+      account,
+      new AccountTransformer()
+    );
+    return this.i18nService.i18nApply(
+      [['accountTypeLabel'], ['accountNormalFormatted']],
+      transformed,
+      tenantId
+    );
+  };
+}
diff --git a/packages/server/src/services/Accounts/GetAccountTransactions.ts b/packages/server/src/services/Accounts/GetAccountTransactions.ts
new file mode 100644
index 000000000..7022666ee
--- /dev/null
+++ b/packages/server/src/services/Accounts/GetAccountTransactions.ts
@@ -0,0 +1,51 @@
+import { Service, Inject } from 'typedi';
+import {
+  IAccountsTransactionsFilter,
+  IAccountTransaction,
+  IGetAccountTransactionPOJO,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import AccountTransactionTransformer from './AccountTransactionTransformer';
+
+@Service()
+export class GetAccountTransactions {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the accounts transactions.
+   * @param {number} tenantId -
+   * @param {IAccountsTransactionsFilter} filter -
+   */
+  public getAccountsTransactions = async (
+    tenantId: number,
+    filter: IAccountsTransactionsFilter
+  ): Promise<IGetAccountTransactionPOJO[]> => {
+    const { AccountTransaction, Account } = this.tenancy.models(tenantId);
+
+    // Retrieve the given account or throw not found error.
+    if (filter.accountId) {
+      await Account.query().findById(filter.accountId).throwIfNotFound();
+    }
+    const transactions = await AccountTransaction.query().onBuild((query) => {
+      query.orderBy('date', 'DESC');
+
+      if (filter.accountId) {
+        query.where('account_id', filter.accountId);
+      }
+      query.withGraphFetched('account');
+      query.withGraphFetched('contact');
+      query.limit(filter.limit || 50);
+    });
+    // Transform the account transaction.
+    return this.transformer.transform(
+      tenantId,
+      transactions,
+      new AccountTransactionTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/Accounts/GetAccounts.ts b/packages/server/src/services/Accounts/GetAccounts.ts
new file mode 100644
index 000000000..3599ddc23
--- /dev/null
+++ b/packages/server/src/services/Accounts/GetAccounts.ts
@@ -0,0 +1,66 @@
+import { Inject, Service } from 'typedi';
+import * as R from 'ramda';
+import { IAccountsFilter, IAccountResponse, IFilterMeta } from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { AccountTransformer } from './AccountTransform';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export class GetAccounts {
+  @Inject()
+  private tenancy: TenancyService;
+
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Parsees accounts list filter DTO.
+   * @param filterDTO
+   * @returns
+   */
+  private parseListFilterDTO(filterDTO) {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  }
+
+  /**
+   * Retrieve accounts datatable list.
+   * @param {number} tenantId
+   * @param {IAccountsFilter} accountsFilter
+   * @returns {Promise<{ accounts: IAccountResponse[]; filterMeta: IFilterMeta }>}
+   */
+  public getAccountsList = async (
+    tenantId: number,
+    filterDTO: IAccountsFilter
+  ): Promise<{ accounts: IAccountResponse[]; filterMeta: IFilterMeta }> => {
+    const { Account } = this.tenancy.models(tenantId);
+
+    // Parses the stringified filter roles.
+    const filter = this.parseListFilterDTO(filterDTO);
+
+    // Dynamic list service.
+    const dynamicList = await this.dynamicListService.dynamicList(
+      tenantId,
+      Account,
+      filter
+    );
+    // Retrieve accounts model based on the given query.
+    const accounts = await Account.query().onBuild((builder) => {
+      dynamicList.buildQuery()(builder);
+      builder.modify('inactiveMode', filter.inactiveMode);
+    });
+    // Retrievs the formatted accounts collection.
+    const transformedAccounts = await this.transformer.transform(
+      tenantId,
+      accounts,
+      new AccountTransformer()
+    );
+    return {
+      accounts: transformedAccounts,
+      filterMeta: dynamicList.getResponseMeta(),
+    };
+  };
+}
diff --git a/packages/server/src/services/Accounts/MutateBaseCurrencyAccounts.ts b/packages/server/src/services/Accounts/MutateBaseCurrencyAccounts.ts
new file mode 100644
index 000000000..46abfc33b
--- /dev/null
+++ b/packages/server/src/services/Accounts/MutateBaseCurrencyAccounts.ts
@@ -0,0 +1,22 @@
+import { Inject, Service } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class MutateBaseCurrencyAccounts {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Mutates the all accounts or the organziation.
+   * @param {number} tenantId
+   * @param {string} currencyCode
+   */
+  public mutateAllAccountsCurrency = async (
+    tenantId: number,
+    currencyCode: string
+  ) => {
+    const { Account } = this.tenancy.models(tenantId);
+
+    await Account.query().update({ currencyCode });
+  };
+}
diff --git a/packages/server/src/services/Accounts/constants.ts b/packages/server/src/services/Accounts/constants.ts
new file mode 100644
index 000000000..640fdf932
--- /dev/null
+++ b/packages/server/src/services/Accounts/constants.ts
@@ -0,0 +1,77 @@
+export const ERRORS = {
+  ACCOUNT_NOT_FOUND: 'account_not_found',
+  ACCOUNT_TYPE_NOT_FOUND: 'account_type_not_found',
+  PARENT_ACCOUNT_NOT_FOUND: 'parent_account_not_found',
+  ACCOUNT_CODE_NOT_UNIQUE: 'account_code_not_unique',
+  ACCOUNT_NAME_NOT_UNIQUE: 'account_name_not_unqiue',
+  PARENT_ACCOUNT_HAS_DIFFERENT_TYPE: 'parent_has_different_type',
+  ACCOUNT_TYPE_NOT_ALLOWED_TO_CHANGE: 'account_type_not_allowed_to_changed',
+  ACCOUNT_PREDEFINED: 'account_predefined',
+  ACCOUNT_HAS_ASSOCIATED_TRANSACTIONS: 'account_has_associated_transactions',
+  PREDEFINED_ACCOUNTS: 'predefined_accounts',
+  ACCOUNTS_HAVE_TRANSACTIONS: 'accounts_have_transactions',
+  CLOSE_ACCOUNT_AND_TO_ACCOUNT_NOT_SAME_TYPE:
+    'close_account_and_to_account_not_same_type',
+  ACCOUNTS_NOT_FOUND: 'accounts_not_found',
+  ACCOUNT_TYPE_NOT_SUPPORTS_MULTI_CURRENCY: 'ACCOUNT_TYPE_NOT_SUPPORTS_MULTI_CURRENCY',
+  ACCOUNT_CURRENCY_NOT_SAME_PARENT_ACCOUNT: 'ACCOUNT_CURRENCY_NOT_SAME_PARENT_ACCOUNT',
+};
+
+// Default views columns.
+export const DEFAULT_VIEW_COLUMNS = [
+  { key: 'name', label: 'Account name' },
+  { key: 'code', label: 'Account code' },
+  { key: 'account_type_label', label: 'Account type' },
+  { key: 'account_normal', label: 'Account normal' },
+  { key: 'amount', label: 'Balance' },
+  { key: 'currencyCode', label: 'Currency' },
+];
+
+// Accounts default views.
+export const DEFAULT_VIEWS = [
+  {
+    name: 'Assets',
+    slug: 'assets',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'root_type', comparator: 'equals', value: 'asset' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Liabilities',
+    slug: 'liabilities',
+    rolesLogicExpression: '1',
+    roles: [
+      { fieldKey: 'root_type', index: 1, comparator: 'equals', value: 'liability' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Equity',
+    slug: 'equity',
+    rolesLogicExpression: '1',
+    roles: [
+      { fieldKey: 'root_type', index: 1, comparator: 'equals', value: 'equity' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Income',
+    slug: 'income',
+    rolesLogicExpression: '1',
+    roles: [
+      { fieldKey: 'root_type', index: 1, comparator: 'equals', value: 'income' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Expenses',
+    slug: 'expenses',
+    rolesLogicExpression: '1',
+    roles: [
+      { fieldKey: 'root_type', index: 1, comparator: 'equals', value: 'expense' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+];
diff --git a/packages/server/src/services/Accounts/susbcribers/MutateBaseCurrencyAccounts.ts b/packages/server/src/services/Accounts/susbcribers/MutateBaseCurrencyAccounts.ts
new file mode 100644
index 000000000..ba65e963d
--- /dev/null
+++ b/packages/server/src/services/Accounts/susbcribers/MutateBaseCurrencyAccounts.ts
@@ -0,0 +1,34 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { MutateBaseCurrencyAccounts } from '../MutateBaseCurrencyAccounts';
+
+@Service()
+export class MutateBaseCurrencyAccountsSubscriber {
+  @Inject()
+  public mutateBaseCurrencyAccounts: MutateBaseCurrencyAccounts;
+
+  /**
+   * Attaches the events with handles.
+   * @param bus
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.organization.baseCurrencyUpdated,
+      this.updateAccountsCurrencyOnBaseCurrencyMutated
+    );
+  }
+
+  /**
+   * Updates the all accounts currency once the base currency
+   * of the organization is mutated.
+   */
+  private updateAccountsCurrencyOnBaseCurrencyMutated = async ({
+    tenantId,
+    organizationDTO,
+  }) => {
+    await this.mutateBaseCurrencyAccounts.mutateAllAccountsCurrency(
+      tenantId,
+      organizationDTO.baseCurrency
+    );
+  };
+}
diff --git a/packages/server/src/services/AccountsReceivable/AccountsReceivableRepository.ts b/packages/server/src/services/AccountsReceivable/AccountsReceivableRepository.ts
new file mode 100644
index 000000000..17bd1f154
--- /dev/null
+++ b/packages/server/src/services/AccountsReceivable/AccountsReceivableRepository.ts
@@ -0,0 +1,9 @@
+
+
+export class AccountsReceivableRepository {
+
+
+  findOrCreateAccount = (currencyCode?: string) => {
+    
+  };
+}
\ No newline at end of file
diff --git a/packages/server/src/services/AuthenticatedAccount/index.ts b/packages/server/src/services/AuthenticatedAccount/index.ts
new file mode 100644
index 000000000..1afb217dd
--- /dev/null
+++ b/packages/server/src/services/AuthenticatedAccount/index.ts
@@ -0,0 +1,15 @@
+import { Service, Inject } from 'typedi';
+import { ISystemUser } from '@/interfaces';
+
+@Service()
+export default class AuthenticatedAccount {
+  /**
+   *
+   * @param {number} tenantId
+   * @param {ISystemUser} authorizedUser
+   * @returns
+   */
+  getAccount = async (tenantId: number, authorizedUser: ISystemUser) => {
+    return authorizedUser;
+  };
+}
diff --git a/packages/server/src/services/Authentication/AuthenticationMailMessages.ts b/packages/server/src/services/Authentication/AuthenticationMailMessages.ts
new file mode 100644
index 000000000..df3cd7ce2
--- /dev/null
+++ b/packages/server/src/services/Authentication/AuthenticationMailMessages.ts
@@ -0,0 +1,73 @@
+import { Service } from 'typedi';
+import { ISystemUser } from '@/interfaces';
+import config from '@/config';
+import Mail from '@/lib/Mail';
+
+@Service()
+export default class AuthenticationMailMesssages {
+  /**
+   * Sends welcome message.
+   * @param {ISystemUser} user - The system user.
+   * @param {string} organizationName -
+   * @return {Promise<void>}
+   */
+  async sendWelcomeMessage(
+    user: ISystemUser,
+    organizationId: string
+  ): Promise<void> {
+    const root = __dirname + '/../../../views/images/bigcapital.png';
+
+    const mail = new Mail()
+      .setView('mail/Welcome.html')
+      .setSubject('Welcome to Bigcapital')
+      .setTo(user.email)
+      .setAttachments([
+        {
+          filename: 'bigcapital.png',
+          path: root,
+          cid: 'bigcapital_logo',
+        },
+      ])
+      .setData({
+        firstName: user.firstName,
+        organizationId,
+        successPhoneNumber: config.customerSuccess.phoneNumber,
+        successEmail: config.customerSuccess.email,
+      });
+
+    await mail.send();
+  }
+
+  /**
+   * Sends reset password message.
+   * @param {ISystemUser} user - The system user.
+   * @param {string} token - Reset password token.
+   * @return {Promise<void>}
+   */
+  async sendResetPasswordMessage(
+    user: ISystemUser,
+    token: string
+  ): Promise<void> {
+    const root = __dirname + '/../../../views/images/bigcapital.png';
+
+    const mail = new Mail()
+      .setSubject('Bigcapital - Password Reset')
+      .setView('mail/ResetPassword.html')
+      .setTo(user.email)
+      .setAttachments([
+        {
+          filename: 'bigcapital.png',
+          path: root,
+          cid: 'bigcapital_logo',
+        },
+      ])
+      .setData({
+        resetPasswordUrl: `${config.baseURL}/auth/reset_password/${token}`,
+        first_name: user.firstName,
+        last_name: user.lastName,
+        contact_us_email: config.contactUsMail,
+      });
+
+    await mail.send();
+  }
+}
diff --git a/packages/server/src/services/Authentication/AuthenticationSMSMessages.ts b/packages/server/src/services/Authentication/AuthenticationSMSMessages.ts
new file mode 100644
index 000000000..6567d8817
--- /dev/null
+++ b/packages/server/src/services/Authentication/AuthenticationSMSMessages.ts
@@ -0,0 +1,19 @@
+import { Service, Inject } from 'typedi';
+import { ISystemUser, ITenant } from '@/interfaces';
+
+@Service()
+export default class AuthenticationSMSMessages {
+  @Inject('SMSClient')
+  smsClient: any;
+
+  /**
+   * Sends welcome sms message.
+   * @param {ITenant} tenant
+   * @param {ISystemUser} user
+   */
+  sendWelcomeMessage(tenant: ITenant, user: ISystemUser) {
+    const message: string = `Hi ${user.firstName}, Welcome to Bigcapital, You've joined the new workspace, if you need any help please don't hesitate to contact us.`;
+
+    return this.smsClient.sendMessage(user.phoneNumber, message);
+  }
+}
diff --git a/packages/server/src/services/Authentication/RateLimiter.ts b/packages/server/src/services/Authentication/RateLimiter.ts
new file mode 100644
index 000000000..efbe7b7d2
--- /dev/null
+++ b/packages/server/src/services/Authentication/RateLimiter.ts
@@ -0,0 +1,49 @@
+import { RateLimiterClusterMasterPM2, RateLimiterMemory, RateLimiterRedis, RateLimiterRes } from 'rate-limiter-flexible';
+
+export default class RateLimiter {
+  rateLimiter: RateLimiterRedis;
+
+   /**
+   * Rate limiter redis constructor.
+   * @param {RateLimiterRedis} rateLimiter 
+   */
+  constructor(rateLimiter: RateLimiterMemory) {
+    this.rateLimiter = rateLimiter;
+  }
+
+  /**
+   * 
+   * @return {boolean}
+   */
+  public attempt(key: string, pointsToConsume = 1): Promise<RateLimiterRes> {
+    return this.rateLimiter.consume(key, pointsToConsume);
+  }
+
+  /**
+   * Increment the counter for a given key for a given decay time.
+   * @param {string} key -
+   */
+  public hit(
+    key: string | number,
+    points: number,
+    secDuration: number,
+  ): Promise<RateLimiterRes> {
+    return this.rateLimiter.penalty(key, points, secDuration);
+  }
+
+  /**
+   * Retrieve the rate limiter response of the given key.
+   * @param {string} key 
+   */
+  public get(key: string): Promise<RateLimiterRes> {
+    return this.rateLimiter.get(key);
+  }
+
+  /**
+   * Resets the rate limiter of the given key.
+   * @param key 
+   */
+  public reset(key: string): Promise<boolean> {
+    return this.rateLimiter.delete(key);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Authentication/index.ts b/packages/server/src/services/Authentication/index.ts
new file mode 100644
index 000000000..8e5a35d77
--- /dev/null
+++ b/packages/server/src/services/Authentication/index.ts
@@ -0,0 +1,322 @@
+import { Service, Inject, Container } from 'typedi';
+import JWT from 'jsonwebtoken';
+import uniqid from 'uniqid';
+import { omit, cloneDeep } from 'lodash';
+import moment from 'moment';
+import { PasswordReset, Tenant } from '@/system/models';
+import {
+  IRegisterDTO,
+  ITenant,
+  ISystemUser,
+  IPasswordReset,
+  IAuthenticationService,
+} from '@/interfaces';
+import { hashPassword } from 'utils';
+import { ServiceError, ServiceErrors } from '@/exceptions';
+import config from '@/config';
+import events from '@/subscribers/events';
+import AuthenticationMailMessages from '@/services/Authentication/AuthenticationMailMessages';
+import TenantsManager from '@/services/Tenancy/TenantsManager';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+const ERRORS = {
+  INVALID_DETAILS: 'INVALID_DETAILS',
+  USER_INACTIVE: 'USER_INACTIVE',
+  EMAIL_NOT_FOUND: 'EMAIL_NOT_FOUND',
+  TOKEN_INVALID: 'TOKEN_INVALID',
+  USER_NOT_FOUND: 'USER_NOT_FOUND',
+  TOKEN_EXPIRED: 'TOKEN_EXPIRED',
+  PHONE_NUMBER_EXISTS: 'PHONE_NUMBER_EXISTS',
+  EMAIL_EXISTS: 'EMAIL_EXISTS',
+};
+@Service()
+export default class AuthenticationService implements IAuthenticationService {
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  mailMessages: AuthenticationMailMessages;
+
+  @Inject('repositories')
+  sysRepositories: any;
+
+  @Inject()
+  tenantsManager: TenantsManager;
+
+  /**
+   * Signin and generates JWT token.
+   * @throws  {ServiceError}
+   * @param  {string} emailOrPhone - Email or phone number.
+   * @param  {string} password - Password.
+   * @return {Promise<{user: IUser, token: string}>}
+   */
+  public async signIn(
+    emailOrPhone: string,
+    password: string
+  ): Promise<{
+    user: ISystemUser;
+    token: string;
+    tenant: ITenant;
+  }> {
+    this.logger.info('[login] Someone trying to login.', {
+      emailOrPhone,
+      password,
+    });
+    const { systemUserRepository } = this.sysRepositories;
+    const loginThrottler = Container.get('rateLimiter.login');
+
+    // Finds the user of the given email or phone number.
+    const user = await systemUserRepository.findByCrediential(emailOrPhone);
+
+    if (!user) {
+      // Hits the loging throttler to the given crediential.
+      await loginThrottler.hit(emailOrPhone);
+
+      this.logger.info('[login] invalid data');
+      throw new ServiceError(ERRORS.INVALID_DETAILS);
+    }
+
+    this.logger.info('[login] check password validation.', {
+      emailOrPhone,
+      password,
+    });
+    if (!user.verifyPassword(password)) {
+      // Hits the loging throttler to the given crediential.
+      await loginThrottler.hit(emailOrPhone);
+
+      throw new ServiceError(ERRORS.INVALID_DETAILS);
+    }
+    if (!user.active) {
+      this.logger.info('[login] user inactive.', { userId: user.id });
+      throw new ServiceError(ERRORS.USER_INACTIVE);
+    }
+
+    this.logger.info('[login] generating JWT token.', { userId: user.id });
+    const token = this.generateToken(user);
+
+    this.logger.info('[login] updating user last login at.', {
+      userId: user.id,
+    });
+    await systemUserRepository.patchLastLoginAt(user.id);
+
+    this.logger.info('[login] Logging success.', { user, token });
+
+    // Triggers `onLogin` event.
+    await this.eventPublisher.emitAsync(events.auth.login, {
+      emailOrPhone,
+      password,
+      user,
+    });
+    const tenant = await Tenant.query().findById(user.tenantId).withGraphFetched('metadata');
+
+    // Keep the user object immutable.
+    const outputUser = cloneDeep(user);
+
+    // Remove password property from user object.
+    Reflect.deleteProperty(outputUser, 'password');
+
+    return { user: outputUser, token, tenant };
+  }
+
+  /**
+   * Validates email and phone number uniqiness on the storage.
+   * @throws {ServiceErrors}
+   * @param  {IRegisterDTO} registerDTO - Register data object.
+   */
+  private async validateEmailAndPhoneUniqiness(registerDTO: IRegisterDTO) {
+    const { systemUserRepository } = this.sysRepositories;
+
+    const isEmailExists = await systemUserRepository.findOneByEmail(
+      registerDTO.email
+    );
+    const isPhoneExists = await systemUserRepository.findOneByPhoneNumber(
+      registerDTO.phoneNumber
+    );
+    const errorReasons: ServiceError[] = [];
+
+    if (isPhoneExists) {
+      this.logger.info('[register] phone number exists on the storage.');
+      errorReasons.push(new ServiceError(ERRORS.PHONE_NUMBER_EXISTS));
+    }
+    if (isEmailExists) {
+      this.logger.info('[register] email exists on the storage.');
+      errorReasons.push(new ServiceError(ERRORS.EMAIL_EXISTS));
+    }
+    if (errorReasons.length > 0) {
+      throw new ServiceErrors(errorReasons);
+    }
+  }
+
+  /**
+   * Registers a new tenant with user from user input.
+   * @throws {ServiceErrors}
+   * @param {IUserDTO} user
+   */
+  public async register(registerDTO: IRegisterDTO): Promise<ISystemUser> {
+    this.logger.info('[register] Someone trying to register.');
+    await this.validateEmailAndPhoneUniqiness(registerDTO);
+
+    this.logger.info('[register] Creating a new tenant organization.');
+    const tenant = await this.newTenantOrganization();
+
+    this.logger.info('[register] Trying hashing the password.');
+    const hashedPassword = await hashPassword(registerDTO.password);
+
+    const { systemUserRepository } = this.sysRepositories;
+    const registeredUser = await systemUserRepository.create({
+      ...omit(registerDTO, 'country'),
+      active: true,
+      password: hashedPassword,
+      tenantId: tenant.id,
+      inviteAcceptedAt: moment().format('YYYY-MM-DD'),
+    });
+    // Triggers `onRegister` event.
+    await this.eventPublisher.emitAsync(events.auth.register, {
+      registerDTO,
+      tenant,
+      user: registeredUser,
+    });
+    return registeredUser;
+  }
+
+  /**
+   * Generates and insert new tenant organization id.
+   * @async
+   * @return {Promise<ITenant>}
+   */
+  private async newTenantOrganization(): Promise<ITenant> {
+    return this.tenantsManager.createTenant();
+  }
+
+  /**
+   * Validate the given email existance on the storage.
+   * @throws {ServiceError}
+   * @param  {string} email - email address.
+   */
+  private async validateEmailExistance(email: string): Promise<ISystemUser> {
+    const { systemUserRepository } = this.sysRepositories;
+    const userByEmail = await systemUserRepository.findOneByEmail(email);
+
+    if (!userByEmail) {
+      this.logger.info('[send_reset_password] The given email not found.');
+      throw new ServiceError(ERRORS.EMAIL_NOT_FOUND);
+    }
+    return userByEmail;
+  }
+
+  /**
+   * Generates and retrieve password reset token for the given user email.
+   * @param {string} email
+   * @return {<Promise<IPasswordReset>}
+   */
+  public async sendResetPassword(email: string): Promise<IPasswordReset> {
+    this.logger.info('[send_reset_password] Trying to send reset password.');
+    const user = await this.validateEmailExistance(email);
+
+    // Delete all stored tokens of reset password that associate to the give email.
+    this.logger.info(
+      '[send_reset_password] trying to delete all tokens by email.'
+    );
+    this.deletePasswordResetToken(email);
+
+    const token: string = uniqid();
+
+    this.logger.info('[send_reset_password] insert the generated token.');
+    const passwordReset = await PasswordReset.query().insert({ email, token });
+
+    // Triggers `onSendResetPassword` event.
+    await this.eventPublisher.emitAsync(events.auth.sendResetPassword, {
+      user,
+      token,
+    });
+    return passwordReset;
+  }
+
+  /**
+   * Resets a user password from given token.
+   * @param {string} token - Password reset token.
+   * @param {string} password - New Password.
+   * @return {Promise<void>}
+   */
+  public async resetPassword(token: string, password: string): Promise<void> {
+    const { systemUserRepository } = this.sysRepositories;
+
+    // Finds the password reset token.
+    const tokenModel: IPasswordReset = await PasswordReset.query().findOne(
+      'token',
+      token
+    );
+    // In case the password reset token not found throw token invalid error..
+    if (!tokenModel) {
+      this.logger.info('[reset_password] token invalid.');
+      throw new ServiceError(ERRORS.TOKEN_INVALID);
+    }
+    // Different between tokne creation datetime and current time.
+    if (
+      moment().diff(tokenModel.createdAt, 'seconds') >
+      config.resetPasswordSeconds
+    ) {
+      this.logger.info('[reset_password] token expired.');
+
+      // Deletes the expired token by expired token email.
+      await this.deletePasswordResetToken(tokenModel.email);
+      throw new ServiceError(ERRORS.TOKEN_EXPIRED);
+    }
+    const user = await systemUserRepository.findOneByEmail(tokenModel.email);
+
+    if (!user) {
+      throw new ServiceError(ERRORS.USER_NOT_FOUND);
+    }
+    const hashedPassword = await hashPassword(password);
+
+    this.logger.info('[reset_password] saving a new hashed password.');
+    await systemUserRepository.update(
+      { password: hashedPassword },
+      { id: user.id }
+    );
+
+    // Deletes the used token.
+    await this.deletePasswordResetToken(tokenModel.email);
+
+    // Triggers `onResetPassword` event.
+    await this.eventPublisher.emitAsync(events.auth.resetPassword, {
+      user,
+      token,
+      password,
+    });
+    this.logger.info('[reset_password] reset password success.');
+  }
+
+  /**
+   * Deletes the password reset token by the given email.
+   * @param  {string} email
+   * @returns {Promise}
+   */
+  private async deletePasswordResetToken(email: string) {
+    this.logger.info('[reset_password] trying to delete all tokens by email.');
+    return PasswordReset.query().where('email', email).delete();
+  }
+
+  /**
+   * Generates JWT token for the given user.
+   * @param {ISystemUser} user
+   * @return {string} token
+   */
+  generateToken(user: ISystemUser): string {
+    const today = new Date();
+    const exp = new Date(today);
+    exp.setDate(today.getDate() + 60);
+
+    this.logger.silly(`Sign JWT for userId: ${user.id}`);
+    return JWT.sign(
+      {
+        id: user.id, // We are gonna use this in the middleware 'isAuth'
+        exp: exp.getTime() / 1000,
+      },
+      config.jwtSecret
+    );
+  }
+}
diff --git a/packages/server/src/services/Branches/ActivateBranches.ts b/packages/server/src/services/Branches/ActivateBranches.ts
new file mode 100644
index 000000000..b642ab359
--- /dev/null
+++ b/packages/server/src/services/Branches/ActivateBranches.ts
@@ -0,0 +1,90 @@
+import { Service, Inject } from 'typedi';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+import { Knex } from 'knex';
+import events from '@/subscribers/events';
+import {
+  IBranchesActivatedPayload,
+  IBranchesActivatePayload,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+import { CreateBranch } from './CreateBranch';
+import { BranchesSettings } from './BranchesSettings';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class ActivateBranches {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private createBranch: CreateBranch;
+
+  @Inject()
+  private branchesSettings: BranchesSettings;
+
+  /**
+   * Throws service error if multi-branches feature is already activated.
+   * @param {boolean} isActivated
+   */
+  private throwIfMultiBranchesActivated = (isActivated: boolean) => {
+    if (isActivated) {
+      throw new ServiceError(ERRORS.MUTLI_BRANCHES_ALREADY_ACTIVATED);
+    }
+  };
+
+  /**
+   * Creates a new initial branch.
+   * @param {number} tenantId
+   */
+  private createInitialBranch = (tenantId: number) => {
+    const { __ } = this.tenancy.i18n(tenantId);
+
+    return this.createBranch.createBranch(tenantId, {
+      name: __('branches.head_branch'),
+      code: '10001',
+      primary: true,
+    });
+  };
+
+  /**
+   * Activate multi-branches feature.
+   * @param   {number} tenantId
+   * @returns {Promise<void>}
+   */
+  public activateBranches = (tenantId: number): Promise<void> => {
+    const isActivated = this.branchesSettings.isMultiBranchesActive(tenantId);
+
+    // Throw error if mutli-branches is already activated.
+    this.throwIfMultiBranchesActivated(isActivated);
+
+    // Activate multi-branches under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onBranchActivate` branch.
+      await this.eventPublisher.emitAsync(events.branch.onActivate, {
+        tenantId,
+        trx,
+      } as IBranchesActivatePayload);
+
+      // Create a new branch as primary branch.
+      const primaryBranch = await this.createInitialBranch(tenantId);
+
+      // Mark the mutli-branches is activated.
+      await this.branchesSettings.markMultiBranchesAsActivated(tenantId);
+
+      // Triggers `onBranchActivated` branch.
+      await this.eventPublisher.emitAsync(events.branch.onActivated, {
+        tenantId,
+        primaryBranch,
+        trx,
+      } as IBranchesActivatedPayload);
+    });
+  };
+}
diff --git a/packages/server/src/services/Branches/BranchIntegrationErrorsMiddleware.ts b/packages/server/src/services/Branches/BranchIntegrationErrorsMiddleware.ts
new file mode 100644
index 000000000..96a35bf43
--- /dev/null
+++ b/packages/server/src/services/Branches/BranchIntegrationErrorsMiddleware.ts
@@ -0,0 +1,35 @@
+import { Request, Response, NextFunction } from 'express';
+import { ServiceError } from '@/exceptions';
+
+/**
+ * Handles branches integration service errors.
+ * @param {Error} error
+ * @param {Request} req
+ * @param {Response} res
+ * @param {NextFunction} next
+ */
+export function BranchIntegrationErrorsMiddleware(
+  error: Error,
+  req: Request,
+  res: Response,
+  next: NextFunction
+) {
+  if (error instanceof ServiceError) {
+    if (error.errorType === 'WAREHOUSE_ID_NOT_FOUND') {
+      return res.boom.badRequest(null, {
+        errors: [{ type: 'WAREHOUSE_ID_NOT_FOUND', code: 5000 }],
+      });
+    }
+    if (error.errorType === 'BRANCH_ID_REQUIRED') {
+      return res.boom.badRequest(null, {
+        errors: [{ type: 'BRANCH_ID_REQUIRED', code: 5100 }],
+      });
+    }
+    if (error.errorType === 'BRANCH_ID_NOT_FOUND') {
+      return res.boom.badRequest(null, {
+        errors: [{ type: 'BRANCH_ID_NOT_FOUND', code: 5300 }],
+      });
+    }
+  }
+  next(error);
+}
diff --git a/packages/server/src/services/Branches/BranchValidate.ts b/packages/server/src/services/Branches/BranchValidate.ts
new file mode 100644
index 000000000..836787525
--- /dev/null
+++ b/packages/server/src/services/Branches/BranchValidate.ts
@@ -0,0 +1,52 @@
+import { Inject, Service } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+
+@Service()
+export class BranchValidator {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  public validateBranchNotOnlyWarehouse = async (
+    tenantId: number,
+    branchId: number
+  ) => {
+    const { Branch } = this.tenancy.models(tenantId);
+
+    const warehouses = await Branch.query().whereNot('id', branchId);
+
+    if (warehouses.length === 0) {
+      throw new ServiceError(ERRORS.COULD_NOT_DELETE_ONLY_BRANCH);
+    }
+  };
+
+  /**
+   * Validates the given branch whether is unique.
+   * @param {number} tenantId
+   * @param {string} code
+   * @param {number} exceptBranchId
+   */
+  public validateBranchCodeUnique = async (
+    tenantId: number,
+    code: string,
+    exceptBranchId?: number
+  ): Promise<void> => {
+    const { Branch } = this.tenancy.models(tenantId);
+
+    const branch = await Branch.query()
+      .onBuild((query) => {
+        query.select(['id']);
+        query.where('code', code);
+
+        if (exceptBranchId) {
+          query.whereNot('id', exceptBranchId);
+        }
+      })
+      .first();
+
+    if (branch) {
+      throw new ServiceError(ERRORS.BRANCH_CODE_NOT_UNIQUE);
+    }
+  };
+}
diff --git a/packages/server/src/services/Branches/BranchesApplication.ts b/packages/server/src/services/Branches/BranchesApplication.ts
new file mode 100644
index 000000000..247a444c8
--- /dev/null
+++ b/packages/server/src/services/Branches/BranchesApplication.ts
@@ -0,0 +1,112 @@
+import { IBranch, ICreateBranchDTO, IEditBranchDTO } from '@/interfaces';
+import { Service, Inject } from 'typedi';
+import { ActivateBranches } from './ActivateBranches';
+import { CreateBranch } from './CreateBranch';
+import { DeleteBranch } from './DeleteBranch';
+import { EditBranch } from './EditBranch';
+import { GetBranch } from './GetBranch';
+import { GetBranches } from './GetBranches';
+import { MarkBranchAsPrimary } from './MarkBranchAsPrimary';
+
+@Service()
+export class BranchesApplication {
+  @Inject()
+  private deleteBranchService: DeleteBranch;
+
+  @Inject()
+  private createBranchService: CreateBranch;
+
+  @Inject()
+  private getBranchService: GetBranch;
+
+  @Inject()
+  private editBranchService: EditBranch;
+
+  @Inject()
+  private getBranchesService: GetBranches;
+
+  @Inject()
+  private activateBranchesService: ActivateBranches;
+
+  @Inject()
+  private markBranchAsPrimaryService: MarkBranchAsPrimary;
+
+  /**
+   * Retrieves branches list.
+   * @param   {number} tenantId
+   * @returns {IBranch}
+   */
+  public getBranches = (tenantId: number): Promise<IBranch[]> => {
+    return this.getBranchesService.getBranches(tenantId);
+  };
+
+  /**
+   * Retrieves the given branch details.
+   * @param   {number} tenantId - Tenant id.
+   * @param   {number} branchId - Branch id.
+   * @returns {Promise<IBranch>}
+   */
+  public getBranch = (tenantId: number, branchId: number): Promise<IBranch> => {
+    return this.getBranchService.getBranch(tenantId, branchId);
+  };
+
+  /**
+   * Creates a new branch.
+   * @param   {number} tenantId -
+   * @param   {ICreateBranchDTO} createBranchDTO
+   * @returns {Promise<IBranch>}
+   */
+  public createBranch = (
+    tenantId: number,
+    createBranchDTO: ICreateBranchDTO
+  ): Promise<IBranch> => {
+    return this.createBranchService.createBranch(tenantId, createBranchDTO);
+  };
+
+  /**
+   * Edits the given branch.
+   * @param   {number} tenantId - Tenant id.
+   * @param   {number} branchId - Branch id.
+   * @param   {IEditBranchDTO} editBranchDTO - Edit branch DTO.
+   * @returns {Promise<IBranch>}
+   */
+  public editBranch = (
+    tenantId: number,
+    branchId: number,
+    editBranchDTO: IEditBranchDTO
+  ): Promise<IBranch> => {
+    return this.editBranchService.editBranch(tenantId, branchId, editBranchDTO);
+  };
+
+  /**
+   * Deletes the given branch.
+   * @param   {number} tenantId - Tenant id.
+   * @param   {number} branchId - Branch id.
+   * @returns {Promise<void>}
+   */
+  public deleteBranch = (tenantId: number, branchId: number): Promise<void> => {
+    return this.deleteBranchService.deleteBranch(tenantId, branchId);
+  };
+
+  /**
+   * Activates the given branches.
+   * @param   {number} tenantId - Tenant id.
+   * @returns {Promise<void>}
+   */
+  public activateBranches = (tenantId: number): Promise<void> => {
+    return this.activateBranchesService.activateBranches(tenantId);
+  };
+
+  /**
+   * Marks the given branch as primary.
+   * @param   {number} tenantId
+   * @param   {number} branchId
+   * @returns {Promise<IBranch>}
+   */
+  public markBranchAsPrimary = async (
+    tenantId: number,
+    branchId: number
+  ): Promise<IBranch> => {
+    return this.markBranchAsPrimaryService.markAsPrimary(tenantId, branchId);
+  };
+}
diff --git a/packages/server/src/services/Branches/BranchesSettings.ts b/packages/server/src/services/Branches/BranchesSettings.ts
new file mode 100644
index 000000000..ee1d6c1b9
--- /dev/null
+++ b/packages/server/src/services/Branches/BranchesSettings.ts
@@ -0,0 +1,29 @@
+import { Service, Inject } from 'typedi';
+import { Features } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class BranchesSettings {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Marks multi-branches as activated.
+   * @param {number} tenantId -
+   */
+  public markMultiBranchesAsActivated = (tenantId: number) => {
+    const settings = this.tenancy.settings(tenantId);
+
+    settings.set({ group: 'features', key: Features.BRANCHES, value: 1 });
+  };
+
+  /**
+   * Retrieves whether multi-branches is active.
+   * @param {number} tenantId
+   */
+  public isMultiBranchesActive = (tenantId: number) => {
+    const settings = this.tenancy.settings(tenantId);
+
+    return settings.get({ group: 'features', key: Features.BRANCHES });
+  };
+}
diff --git a/packages/server/src/services/Branches/CRUDBranch.ts b/packages/server/src/services/Branches/CRUDBranch.ts
new file mode 100644
index 000000000..3895c5eae
--- /dev/null
+++ b/packages/server/src/services/Branches/CRUDBranch.ts
@@ -0,0 +1,30 @@
+import { Inject } from "typedi";
+import { ServiceError } from "exceptions";
+import HasTenancyService from "services/Tenancy/TenancyService";
+import { ERRORS } from "./constants";
+
+export class CURDBranch {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * 
+   * @param branch 
+   */
+  throwIfBranchNotFound = (branch) => {
+    if (!branch) {
+      throw new ServiceError(ERRORS.BRANCH_NOT_FOUND);
+    } 
+  }
+
+  getBranchOrThrowNotFound = async (tenantId: number, branchId: number) => {
+    const { Branch } = this.tenancy.models(tenantId);
+
+    const foundBranch = await Branch.query().findById(branchId);
+
+    if (!foundBranch) {
+      throw new ServiceError(ERRORS.BRANCH_NOT_FOUND);
+    }
+    return foundBranch;
+  } 
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Branches/CreateBranch.ts b/packages/server/src/services/Branches/CreateBranch.ts
new file mode 100644
index 000000000..5de58aaa5
--- /dev/null
+++ b/packages/server/src/services/Branches/CreateBranch.ts
@@ -0,0 +1,64 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import {
+  IBranch,
+  IBranchCreatedPayload,
+  IBranchCreatePayload,
+  ICreateBranchDTO,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import { BranchValidator } from './BranchValidate';
+
+@Service()
+export class CreateBranch {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private validator: BranchValidator;
+  
+  /**
+   * Creates a new branch.
+   * @param   {number} tenantId
+   * @param   {ICreateBranchDTO} createBranchDTO
+   * @returns {Promise<IBranch>}
+   */
+  public createBranch = (
+    tenantId: number,
+    createBranchDTO: ICreateBranchDTO
+  ): Promise<IBranch> => {
+    const { Branch } = this.tenancy.models(tenantId);
+
+    // Creates a new branch under unit-of-work.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onBranchCreate` event.
+      await this.eventPublisher.emitAsync(events.warehouse.onEdit, {
+        tenantId,
+        createBranchDTO,
+        trx,
+      } as IBranchCreatePayload);
+
+      const branch = await Branch.query().insertAndFetch({
+        ...createBranchDTO,
+      });
+      // Triggers `onBranchCreated` event.
+      await this.eventPublisher.emitAsync(events.warehouse.onEdited, {
+        tenantId,
+        createBranchDTO,
+        branch,
+        trx,
+      } as IBranchCreatedPayload);
+
+      return branch;
+    });
+  };
+}
diff --git a/packages/server/src/services/Branches/DeleteBranch.ts b/packages/server/src/services/Branches/DeleteBranch.ts
new file mode 100644
index 000000000..bb40da392
--- /dev/null
+++ b/packages/server/src/services/Branches/DeleteBranch.ts
@@ -0,0 +1,76 @@
+import { Service, Inject } from 'typedi';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { Knex } from 'knex';
+import events from '@/subscribers/events';
+import { IBranchDeletedPayload, IBranchDeletePayload } from '@/interfaces';
+import { CURDBranch } from './CRUDBranch';
+import { BranchValidator } from './BranchValidate';
+import { ERRORS } from './constants';
+@Service()
+export class DeleteBranch extends CURDBranch {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private validator: BranchValidator;
+
+  /**
+   * Validates the branch deleteing.
+   * @param   {number} tenantId
+   * @param   {number} branchId
+   * @returns {Promise<void>}
+   */
+  private authorize = async (tenantId: number, branchId: number) => {
+    await this.validator.validateBranchNotOnlyWarehouse(tenantId, branchId);
+  };
+
+  /**
+   * Deletes branch.
+   * @param   {number} tenantId
+   * @param   {number} branchId
+   * @returns {Promise<void>}
+   */
+  public deleteBranch = async (
+    tenantId: number,
+    branchId: number
+  ): Promise<void> => {
+    const { Branch } = this.tenancy.models(tenantId);
+
+    // Retrieves the old branch or throw not found service error.
+    const oldBranch = await Branch.query()
+      .findById(branchId)
+      .throwIfNotFound()
+      .queryAndThrowIfHasRelations({
+        type: ERRORS.BRANCH_HAS_ASSOCIATED_TRANSACTIONS,
+      });
+    // Authorize the branch before deleting.
+    await this.authorize(tenantId, branchId);
+
+    // Deletes branch under unit-of-work.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onBranchCreate` event.
+      await this.eventPublisher.emitAsync(events.warehouse.onEdit, {
+        tenantId,
+        oldBranch,
+        trx,
+      } as IBranchDeletePayload);
+
+      await Branch.query().findById(branchId).delete();
+
+      // Triggers `onBranchCreate` event.
+      await this.eventPublisher.emitAsync(events.warehouse.onEdited, {
+        tenantId,
+        oldBranch,
+        trx,
+      } as IBranchDeletedPayload);
+    });
+  };
+}
diff --git a/packages/server/src/services/Branches/EditBranch.ts b/packages/server/src/services/Branches/EditBranch.ts
new file mode 100644
index 000000000..e59f6cd8a
--- /dev/null
+++ b/packages/server/src/services/Branches/EditBranch.ts
@@ -0,0 +1,65 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import {
+  IBranchEditedPayload,
+  IBranchEditPayload,
+  IEditBranchDTO,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { CURDBranch } from './CRUDBranch';
+import events from '@/subscribers/events';
+
+@Service()
+export class EditBranch extends CURDBranch {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  /**
+   * Edits branch.
+   * @param {number} tenantId
+   * @param {number} branchId
+   * @param editBranchDTO
+   */
+  public editBranch = async (
+    tenantId: number,
+    branchId: number,
+    editBranchDTO: IEditBranchDTO
+  ) => {
+    const { Branch } = this.tenancy.models(tenantId);
+
+    // Retrieves the old branch or throw not found service error.
+    const oldBranch = await this.getBranchOrThrowNotFound(tenantId, branchId);
+
+    // Deletes branch under unit-of-work.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onBranchEdit` event.
+      await this.eventPublisher.emitAsync(events.warehouse.onEdit, {
+        tenantId,
+        oldBranch,
+        trx,
+      } as IBranchEditPayload);
+
+      // Edits the branch on the storage.
+      const branch = await Branch.query().patchAndFetchById(branchId, {
+        ...editBranchDTO,
+      });
+      // Triggers `onBranchEdited` event.
+      await this.eventPublisher.emitAsync(events.warehouse.onEdited, {
+        tenantId,
+        oldBranch,
+        branch,
+        trx,
+      } as IBranchEditedPayload);
+
+      return branch;
+    });
+  };
+}
diff --git a/packages/server/src/services/Branches/EventsProvider.ts b/packages/server/src/services/Branches/EventsProvider.ts
new file mode 100644
index 000000000..e86d03b62
--- /dev/null
+++ b/packages/server/src/services/Branches/EventsProvider.ts
@@ -0,0 +1,50 @@
+import {
+  CreditNoteActivateBranchesSubscriber,
+  PaymentReceiveActivateBranchesSubscriber,
+  SaleEstimatesActivateBranchesSubscriber,
+  SaleInvoicesActivateBranchesSubscriber,
+  PaymentMadeActivateBranchesSubscriber,
+  SaleReceiptsActivateBranchesSubscriber,
+} from './Subscribers/Activate';
+import {
+  BillBranchValidateSubscriber,
+  VendorCreditBranchValidateSubscriber,
+  PaymentMadeBranchValidateSubscriber,
+  SaleEstimateBranchValidateSubscriber,
+  CreditNoteBranchValidateSubscriber,
+  ExpenseBranchValidateSubscriber,
+  SaleReceiptBranchValidateSubscriber,
+  ManualJournalBranchValidateSubscriber,
+  PaymentReceiveBranchValidateSubscriber,
+  CreditNoteRefundBranchValidateSubscriber,
+  CashflowBranchDTOValidatorSubscriber,
+  VendorCreditRefundBranchValidateSubscriber,
+  InvoiceBranchValidateSubscriber,
+  ContactBranchValidateSubscriber,
+  InventoryAdjustmentBranchValidateSubscriber
+} from './Subscribers/Validators';
+
+export default () => [
+  BillBranchValidateSubscriber,
+  CreditNoteBranchValidateSubscriber,
+  ExpenseBranchValidateSubscriber,
+  PaymentMadeBranchValidateSubscriber,
+  SaleReceiptBranchValidateSubscriber,
+  VendorCreditBranchValidateSubscriber,
+  SaleEstimateBranchValidateSubscriber,
+  ManualJournalBranchValidateSubscriber,
+  PaymentReceiveBranchValidateSubscriber,
+  CreditNoteRefundBranchValidateSubscriber,
+  VendorCreditRefundBranchValidateSubscriber,
+
+  CreditNoteActivateBranchesSubscriber,
+  PaymentReceiveActivateBranchesSubscriber,
+  SaleEstimatesActivateBranchesSubscriber,
+  SaleInvoicesActivateBranchesSubscriber,
+  PaymentMadeActivateBranchesSubscriber,
+  SaleReceiptsActivateBranchesSubscriber,
+  CashflowBranchDTOValidatorSubscriber,
+  InvoiceBranchValidateSubscriber,
+  ContactBranchValidateSubscriber,
+  InventoryAdjustmentBranchValidateSubscriber
+];
diff --git a/packages/server/src/services/Branches/GetBranch.ts b/packages/server/src/services/Branches/GetBranch.ts
new file mode 100644
index 000000000..777947361
--- /dev/null
+++ b/packages/server/src/services/Branches/GetBranch.ts
@@ -0,0 +1,26 @@
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Service, Inject } from 'typedi';
+import { CURDBranch } from './CRUDBranch';
+
+@Service()
+export class GetBranch extends CURDBranch{
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * 
+   * @param {number} tenantId 
+   * @param {number} branchId 
+   * @returns 
+   */
+  public getBranch = async (tenantId: number, branchId: number) => {
+    const { Branch } = this.tenancy.models(tenantId);
+
+    const branch = await Branch.query().findById(branchId);
+
+    // Throw not found service error if the branch not found.
+    this.throwIfBranchNotFound(branch);
+
+    return branch;
+  };
+}
diff --git a/packages/server/src/services/Branches/GetBranches.ts b/packages/server/src/services/Branches/GetBranches.ts
new file mode 100644
index 000000000..33ccb8d8c
--- /dev/null
+++ b/packages/server/src/services/Branches/GetBranches.ts
@@ -0,0 +1,22 @@
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Service, Inject } from 'typedi';
+
+@Service()
+export class GetBranches {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieves branches list.
+   * @param {number} tenantId 
+   * @param {number} branchId 
+   * @returns 
+   */
+  public getBranches = async (tenantId: number) => {
+    const { Branch } = this.tenancy.models(tenantId);
+
+    const branches = await Branch.query().orderBy('name', 'DESC');
+
+    return branches;
+  };
+}
diff --git a/packages/server/src/services/Branches/Integrations/BranchTransactionDTOTransform.ts b/packages/server/src/services/Branches/Integrations/BranchTransactionDTOTransform.ts
new file mode 100644
index 000000000..57f5f5a71
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/BranchTransactionDTOTransform.ts
@@ -0,0 +1,35 @@
+import { Service, Inject } from 'typedi';
+import { omit } from 'lodash';
+import { BranchesSettings } from '../BranchesSettings';
+
+@Service()
+export class BranchTransactionDTOTransform {
+  @Inject()
+  branchesSettings: BranchesSettings;
+
+  /**
+   * Excludes DTO branch id when mutli-warehouses feature is inactive.
+   * @param   {number} tenantId
+   * @returns {any}
+   */
+  private excludeDTOBranchIdWhenInactive = <T extends { branchId?: number }>(
+    tenantId: number,
+    DTO: T
+  ): Omit<T, 'branchId'> | T => {
+    const isActive = this.branchesSettings.isMultiBranchesActive(tenantId);
+
+    return !isActive ? omit(DTO, ['branchId']) : DTO;
+  };
+
+  /**
+   * Transformes the input DTO for branches feature.
+   * @param   {number} tenantId -
+   * @param   {T}      DTO -
+   * @returns {Omit<T, 'branchId'> | T}
+   */
+  public transformDTO =
+    <T extends { branchId?: number }>(tenantId: number) =>
+    (DTO: T): Omit<T, 'branchId'> | T => {
+      return this.excludeDTOBranchIdWhenInactive<T>(tenantId, DTO);
+    };
+}
diff --git a/packages/server/src/services/Branches/Integrations/Cashflow/CashflowActivateBranches.ts b/packages/server/src/services/Branches/Integrations/Cashflow/CashflowActivateBranches.ts
new file mode 100644
index 000000000..9f1c148aa
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/Cashflow/CashflowActivateBranches.ts
@@ -0,0 +1,26 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class CashflowTransactionsActivateBranches {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Updates all cashflow transactions with the primary branch.
+   * @param   {number} tenantId
+   * @param   {number} primaryBranchId
+   * @returns {Promise<void>}
+   */
+  public updateCashflowTransactionsWithBranch = async (
+    tenantId: number,
+    primaryBranchId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { CashflowTransaction } = this.tenancy.models(tenantId);
+
+    // Updates the cashflow transactions with primary branch.
+    await CashflowTransaction.query(trx).update({ branchId: primaryBranchId });
+  };
+}
diff --git a/packages/server/src/services/Branches/Integrations/Expense/ExpensesActivateBranches.ts b/packages/server/src/services/Branches/Integrations/Expense/ExpensesActivateBranches.ts
new file mode 100644
index 000000000..6601235d3
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/Expense/ExpensesActivateBranches.ts
@@ -0,0 +1,26 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class ExpensesActivateBranches {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Updates all expenses transactions with the primary branch.
+   * @param   {number} tenantId
+   * @param   {number} primaryBranchId
+   * @returns {Promise<void>}
+   */
+  public updateExpensesWithBranch = async (
+    tenantId: number,
+    primaryBranchId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { Expense } = this.tenancy.models(tenantId);
+
+    // Updates the expenses with primary branch.
+    await Expense.query(trx).update({ branchId: primaryBranchId });
+  };
+}
diff --git a/packages/server/src/services/Branches/Integrations/ManualJournals/ManualJournalBranchesActivate.ts b/packages/server/src/services/Branches/Integrations/ManualJournals/ManualJournalBranchesActivate.ts
new file mode 100644
index 000000000..5113b25d9
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/ManualJournals/ManualJournalBranchesActivate.ts
@@ -0,0 +1,26 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Knex } from 'knex';
+
+@Service()
+export class ManualJournalsActivateBranches {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Updates all manual journals transactions with the primary branch.
+   * @param   {number} tenantId
+   * @param   {number} primaryBranchId
+   * @returns {Promise<void>}
+   */
+  public updateManualJournalsWithBranch = async (
+    tenantId: number,
+    primaryBranchId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { ManualJournal } = this.tenancy.models(tenantId);
+
+    // Updates the manual journal with primary branch.
+    await ManualJournal.query(trx).update({ branchId: primaryBranchId });
+  };
+}
diff --git a/packages/server/src/services/Branches/Integrations/ManualJournals/ManualJournalDTOTransformer.ts b/packages/server/src/services/Branches/Integrations/ManualJournals/ManualJournalDTOTransformer.ts
new file mode 100644
index 000000000..a6f3cab4a
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/ManualJournals/ManualJournalDTOTransformer.ts
@@ -0,0 +1,32 @@
+import { omit } from 'lodash';
+import { Inject, Service } from 'typedi';
+import { IManualJournal } from '@/interfaces';
+import { BranchesSettings } from '../../BranchesSettings';
+
+@Service()
+export class ManualJournalBranchesDTOTransformer {
+  @Inject()
+  branchesSettings: BranchesSettings;
+
+  private excludeDTOBranchIdWhenInactive = (
+    tenantId: number,
+    DTO: IManualJournal
+  ): IManualJournal => {
+    const isActive = this.branchesSettings.isMultiBranchesActive(tenantId);
+
+    if (isActive) return DTO;
+
+    return {
+      ...DTO,
+      entries: DTO.entries.map((e) => omit(e, ['branchId'])),
+    };
+  };
+  /**
+   *
+   */
+  public transformDTO =
+    (tenantId: number) =>
+    (DTO: IManualJournal): IManualJournal => {
+      return this.excludeDTOBranchIdWhenInactive(tenantId, DTO);
+    };
+}
diff --git a/packages/server/src/services/Branches/Integrations/ManualJournals/ManualJournalsBranchesValidator.ts b/packages/server/src/services/Branches/Integrations/ManualJournals/ManualJournalsBranchesValidator.ts
new file mode 100644
index 000000000..ed3628d50
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/ManualJournals/ManualJournalsBranchesValidator.ts
@@ -0,0 +1,23 @@
+import { Service, Inject } from 'typedi';
+import { ServiceError } from '@/exceptions';
+import { IManualJournalDTO, IManualJournalEntryDTO } from '@/interfaces';
+import { ERRORS } from './constants';
+
+@Service()
+export class ManualJournalBranchesValidator {
+  /**
+   * Validates the DTO entries should have branch id.
+   * @param {IManualJournalDTO} manualJournalDTO
+   */
+  public validateEntriesHasBranchId = async (
+    manualJournalDTO: IManualJournalDTO
+  ) => {
+    const hasNoIdEntries = manualJournalDTO.entries.filter(
+      (entry: IManualJournalEntryDTO) =>
+        !entry.branchId && !manualJournalDTO.branchId
+    );
+    if (hasNoIdEntries.length > 0) {
+      throw new ServiceError(ERRORS.MANUAL_JOURNAL_ENTRIES_HAVE_NO_BRANCH_ID);
+    }
+  };
+}
diff --git a/packages/server/src/services/Branches/Integrations/ManualJournals/constants.ts b/packages/server/src/services/Branches/Integrations/ManualJournals/constants.ts
new file mode 100644
index 000000000..46e4327e5
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/ManualJournals/constants.ts
@@ -0,0 +1,4 @@
+export const ERRORS = {
+  MANUAL_JOURNAL_ENTRIES_HAVE_NO_BRANCH_ID:
+    'MANUAL_JOURNAL_ENTRIES_HAVE_NO_BRANCH_ID',
+};
diff --git a/packages/server/src/services/Branches/Integrations/Purchases/BillBranchesActivate.ts b/packages/server/src/services/Branches/Integrations/Purchases/BillBranchesActivate.ts
new file mode 100644
index 000000000..81af0a4a5
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/Purchases/BillBranchesActivate.ts
@@ -0,0 +1,26 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Knex } from 'knex';
+
+@Service()
+export class BillActivateBranches {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Updates all bills transactions with the primary branch.
+   * @param   {number} tenantId
+   * @param   {number} primaryBranchId
+   * @returns {Promise<void>}
+   */
+  public updateBillsWithBranch = async (
+    tenantId: number,
+    primaryBranchId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    // Updates the sale invoice with primary branch.
+    await Bill.query(trx).update({ branchId: primaryBranchId });
+  };
+}
diff --git a/packages/server/src/services/Branches/Integrations/Purchases/PaymentMadeBranchesActivate.ts b/packages/server/src/services/Branches/Integrations/Purchases/PaymentMadeBranchesActivate.ts
new file mode 100644
index 000000000..1c9173966
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/Purchases/PaymentMadeBranchesActivate.ts
@@ -0,0 +1,26 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Knex } from 'knex';
+
+@Service()
+export class BillPaymentsActivateBranches {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Updates all bills payments transcations with the primary branch.
+   * @param   {number} tenantId
+   * @param   {number} primaryBranchId
+   * @returns {Promise<void>}
+   */
+  public updateBillPaymentsWithBranch = async (
+    tenantId: number,
+    primaryBranchId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { BillPayment } = this.tenancy.models(tenantId);
+
+    // Updates the bill payments with primary branch.
+    await BillPayment.query(trx).update({ branchId: primaryBranchId });
+  };
+}
diff --git a/packages/server/src/services/Branches/Integrations/Purchases/VendorCreditBranchesActivate.ts b/packages/server/src/services/Branches/Integrations/Purchases/VendorCreditBranchesActivate.ts
new file mode 100644
index 000000000..cd4638723
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/Purchases/VendorCreditBranchesActivate.ts
@@ -0,0 +1,26 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Knex } from 'knex';
+
+@Service()
+export class VendorCreditActivateBranches {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Updates all vendor credits transcations with the primary branch.
+   * @param   {number} tenantId
+   * @param   {number} primaryBranchId
+   * @returns {Promise<void>}
+   */
+  public updateVendorCreditsWithBranch = async (
+    tenantId: number,
+    primaryBranchId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { VendorCredit } = this.tenancy.models(tenantId);
+
+    // Updates the vendors credits with primary branch.
+    await VendorCredit.query(trx).update({ branchId: primaryBranchId });
+  };
+}
diff --git a/packages/server/src/services/Branches/Integrations/Sales/CreditNoteBranchesActivate.ts b/packages/server/src/services/Branches/Integrations/Sales/CreditNoteBranchesActivate.ts
new file mode 100644
index 000000000..7bc115156
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/Sales/CreditNoteBranchesActivate.ts
@@ -0,0 +1,26 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Knex } from 'knex';
+
+@Service()
+export class CreditNoteActivateBranches {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Updates all creidt notes transactions with the primary branch.
+   * @param   {number} tenantId
+   * @param   {number} primaryBranchId
+   * @returns {Promise<void>}
+   */
+  public updateCreditsWithBranch = async (
+    tenantId: number,
+    primaryBranchId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { CreditNote } = this.tenancy.models(tenantId);
+
+    // Updates the sale invoice with primary branch.
+    await CreditNote.query(trx).update({ branchId: primaryBranchId });
+  };
+}
diff --git a/packages/server/src/services/Branches/Integrations/Sales/PaymentReceiveBranchesActivate.ts b/packages/server/src/services/Branches/Integrations/Sales/PaymentReceiveBranchesActivate.ts
new file mode 100644
index 000000000..c5c8a5f68
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/Sales/PaymentReceiveBranchesActivate.ts
@@ -0,0 +1,26 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Knex } from 'knex';
+
+@Service()
+export class PaymentReceiveActivateBranches {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Updates all creidt notes transactions with the primary branch.
+   * @param   {number} tenantId
+   * @param   {number} primaryBranchId
+   * @returns {Promise<void>}
+   */
+  public updatePaymentsWithBranch = async (
+    tenantId: number,
+    primaryBranchId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { PaymentReceive } = this.tenancy.models(tenantId);
+
+    // Updates the sale invoice with primary branch.
+    await PaymentReceive.query(trx).update({ branchId: primaryBranchId });
+  };
+}
diff --git a/packages/server/src/services/Branches/Integrations/Sales/SaleEstimatesBranchesActivate.ts b/packages/server/src/services/Branches/Integrations/Sales/SaleEstimatesBranchesActivate.ts
new file mode 100644
index 000000000..269cd82b5
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/Sales/SaleEstimatesBranchesActivate.ts
@@ -0,0 +1,26 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Knex } from 'knex';
+
+@Service()
+export class SaleEstimateActivateBranches {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Updates all sale estimates transactions with the primary branch.
+   * @param   {number} tenantId
+   * @param   {number} primaryBranchId
+   * @returns {Promise<void>}
+   */
+  public updateEstimatesWithBranch = async (
+    tenantId: number,
+    primaryBranchId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { PaymentReceive } = this.tenancy.models(tenantId);
+
+    // Updates the sale invoice with primary branch.
+    await PaymentReceive.query(trx).update({ branchId: primaryBranchId });
+  };
+}
diff --git a/packages/server/src/services/Branches/Integrations/Sales/SaleInvoiceBranchesActivate.ts b/packages/server/src/services/Branches/Integrations/Sales/SaleInvoiceBranchesActivate.ts
new file mode 100644
index 000000000..243d60c62
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/Sales/SaleInvoiceBranchesActivate.ts
@@ -0,0 +1,26 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Knex } from 'knex';
+
+@Service()
+export class SaleInvoiceActivateBranches {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Updates all sale invoices transactions with the primary branch.
+   * @param   {number} tenantId
+   * @param   {number} primaryBranchId
+   * @returns {Promise<void>}
+   */
+  public updateInvoicesWithBranch = async (
+    tenantId: number,
+    primaryBranchId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    // Updates the sale invoice with primary branch.
+    await SaleInvoice.query(trx).update({ branchId: primaryBranchId });
+  };
+}
diff --git a/packages/server/src/services/Branches/Integrations/Sales/SaleReceiptBranchesActivate.ts b/packages/server/src/services/Branches/Integrations/Sales/SaleReceiptBranchesActivate.ts
new file mode 100644
index 000000000..fb487696a
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/Sales/SaleReceiptBranchesActivate.ts
@@ -0,0 +1,26 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Knex } from 'knex';
+
+@Service()
+export class SaleReceiptActivateBranches {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Updates all sale receipts transactions with the primary branch.
+   * @param   {number} tenantId
+   * @param   {number} primaryBranchId
+   * @returns {Promise<void>}
+   */
+  public updateReceiptsWithBranch = async (
+    tenantId: number,
+    primaryBranchId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { SaleReceipt } = this.tenancy.models(tenantId);
+
+    // Updates the sale receipt with primary branch.
+    await SaleReceipt.query(trx).update({ branchId: primaryBranchId });
+  };
+}
diff --git a/packages/server/src/services/Branches/Integrations/ValidateBranchExistance.ts b/packages/server/src/services/Branches/Integrations/ValidateBranchExistance.ts
new file mode 100644
index 000000000..8c3d12eee
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/ValidateBranchExistance.ts
@@ -0,0 +1,74 @@
+import { ServiceError } from '@/exceptions';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Service, Inject } from 'typedi';
+import { BranchesSettings } from '../BranchesSettings';
+import { ERRORS } from './constants';
+
+@Service()
+export class ValidateBranchExistance {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  branchesSettings: BranchesSettings;
+
+  /**
+   * Validate transaction branch id when the feature is active.
+   * @param   {number} tenantId 
+   * @param   {number} branchId 
+   * @returns {Promise<void>}
+   */
+  public validateTransactionBranchWhenActive = async (
+    tenantId: number,
+    branchId: number | null
+  ) => {
+    const isActive = this.branchesSettings.isMultiBranchesActive(tenantId);
+
+    // Can't continue if the multi-warehouses feature is inactive.
+    if (!isActive) return;
+
+    return this.validateTransactionBranch(tenantId, branchId);
+  };
+
+  /**
+   * Validate transaction branch id existance.
+   * @param  {number} tenantId 
+   * @param  {number} branchId 
+   * @return {Promise<void>}
+   */
+  public validateTransactionBranch = async (
+    tenantId: number,
+    branchId: number | null
+  ) => {
+    //
+    this.validateBranchIdExistance(branchId);
+
+    //
+    await this.validateBranchExistance(tenantId, branchId);
+  };
+
+  /**
+   *
+   * @param branchId
+   */
+  public validateBranchIdExistance = (branchId: number | null) => {
+    if (!branchId) {
+      throw new ServiceError(ERRORS.BRANCH_ID_REQUIRED);
+    }
+  };
+
+  /**
+   *
+   * @param tenantId
+   * @param branchId
+   */
+  public validateBranchExistance = async (tenantId: number, branchId: number) => {
+    const { Branch } = this.tenancy.models(tenantId);
+
+    const branch = await Branch.query().findById(branchId);
+
+    if (!branch) {
+      throw new ServiceError(ERRORS.BRANCH_ID_NOT_FOUND);
+    }
+  };
+}
diff --git a/packages/server/src/services/Branches/Integrations/constants.ts b/packages/server/src/services/Branches/Integrations/constants.ts
new file mode 100644
index 000000000..af66f6dae
--- /dev/null
+++ b/packages/server/src/services/Branches/Integrations/constants.ts
@@ -0,0 +1,6 @@
+
+
+export const ERRORS = {
+  BRANCH_ID_REQUIRED: 'BRANCH_ID_REQUIRED',
+  BRANCH_ID_NOT_FOUND: 'BRANCH_ID_NOT_FOUND'
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Branches/MarkBranchAsPrimary.ts b/packages/server/src/services/Branches/MarkBranchAsPrimary.ts
new file mode 100644
index 000000000..03e733c8f
--- /dev/null
+++ b/packages/server/src/services/Branches/MarkBranchAsPrimary.ts
@@ -0,0 +1,67 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import { CURDBranch } from './CRUDBranch';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import {
+  IBranch,
+  IBranchMarkAsPrimaryPayload,
+  IBranchMarkedAsPrimaryPayload,
+} from '@/interfaces';
+
+@Service()
+export class MarkBranchAsPrimary extends CURDBranch {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Marks the given branch as primary.
+   * @param   {number} tenantId
+   * @param   {number} branchId
+   * @returns {Promise<IBranch>}
+   */
+  public markAsPrimary = async (
+    tenantId: number,
+    branchId: number
+  ): Promise<IBranch> => {
+    const { Branch } = this.tenancy.models(tenantId);
+
+    // Retrieves the old branch or throw not found service error.
+    const oldBranch = await this.getBranchOrThrowNotFound(tenantId, branchId);
+
+    // Updates the branches under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onBranchMarkPrimary` event.
+      await this.eventPublisher.emitAsync(events.branch.onMarkPrimary, {
+        tenantId,
+        oldBranch,
+        trx,
+      } as IBranchMarkAsPrimaryPayload);
+
+      // Updates all branches as not primary.
+      await Branch.query(trx).update({ primary: false });
+
+      // Updates the given branch as primary.
+      const markedBranch = await Branch.query(trx).patchAndFetchById(branchId, {
+        primary: true,
+      });
+      // Triggers `onBranchMarkedPrimary` event.
+      await this.eventPublisher.emitAsync(events.branch.onMarkedPrimary, {
+        tenantId,
+        markedBranch,
+        oldBranch,
+        trx,
+      } as IBranchMarkedAsPrimaryPayload);
+
+      return markedBranch;
+    });
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Activate/CashflowBranchesActviateSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Activate/CashflowBranchesActviateSubscriber.ts
new file mode 100644
index 000000000..05e27810c
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Activate/CashflowBranchesActviateSubscriber.ts
@@ -0,0 +1,38 @@
+import { IBranchesActivatedPayload } from '@/interfaces';
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { CashflowTransactionsActivateBranches } from '../../Integrations/Cashflow/CashflowActivateBranches';
+
+@Service()
+export class CreditNoteActivateBranchesSubscriber {
+  @Inject()
+  private cashflowActivateBranches: CashflowTransactionsActivateBranches;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.branch.onActivated,
+      this.updateCashflowWithBranchOnActivated
+    );
+    return bus;
+  }
+
+  /**
+   * Updates accounts transactions with the primary branch once
+   * the multi-branches is activated.
+   * @param {IBranchesActivatedPayload}
+   */
+  private updateCashflowWithBranchOnActivated = async ({
+    tenantId,
+    primaryBranch,
+    trx,
+  }: IBranchesActivatedPayload) => {
+    await this.cashflowActivateBranches.updateCashflowTransactionsWithBranch(
+      tenantId,
+      primaryBranch.id,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Activate/CreditNoteBranchesActivateSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Activate/CreditNoteBranchesActivateSubscriber.ts
new file mode 100644
index 000000000..046a806b2
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Activate/CreditNoteBranchesActivateSubscriber.ts
@@ -0,0 +1,38 @@
+import { IBranchesActivatedPayload } from '@/interfaces';
+import { Service, Inject } from 'typedi';
+import { CreditNoteActivateBranches } from '../../Integrations/Sales/CreditNoteBranchesActivate';
+import events from '@/subscribers/events';
+
+@Service()
+export class CreditNoteActivateBranchesSubscriber {
+  @Inject()
+  private creditNotesActivateBranches: CreditNoteActivateBranches;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.branch.onActivated,
+      this.updateCreditNoteWithBranchOnActivated
+    );
+    return bus;
+  }
+
+  /**
+   * Updates accounts transactions with the primary branch once
+   * the multi-branches is activated.
+   * @param {IBranchesActivatedPayload}
+   */
+  private updateCreditNoteWithBranchOnActivated = async ({
+    tenantId,
+    primaryBranch,
+    trx,
+  }: IBranchesActivatedPayload) => {
+    await this.creditNotesActivateBranches.updateCreditsWithBranch(
+      tenantId,
+      primaryBranch.id,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Activate/ExpenseBranchesActivateSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Activate/ExpenseBranchesActivateSubscriber.ts
new file mode 100644
index 000000000..378490801
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Activate/ExpenseBranchesActivateSubscriber.ts
@@ -0,0 +1,38 @@
+import { IBranchesActivatedPayload } from '@/interfaces';
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { ExpensesActivateBranches } from '../../Integrations/Expense/ExpensesActivateBranches';
+
+@Service()
+export class ExpenseActivateBranchesSubscriber {
+  @Inject()
+  private expensesActivateBranches: ExpensesActivateBranches;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.branch.onActivated,
+      this.updateExpensesWithBranchOnActivated
+    );
+    return bus;
+  }
+
+  /**
+   * Updates accounts transactions with the primary branch once
+   * the multi-branches is activated.
+   * @param {IBranchesActivatedPayload}
+   */
+  private updateExpensesWithBranchOnActivated = async ({
+    tenantId,
+    primaryBranch,
+    trx,
+  }: IBranchesActivatedPayload) => {
+    await this.expensesActivateBranches.updateExpensesWithBranch(
+      tenantId,
+      primaryBranch.id,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Activate/PaymentMadeBranchesActivateSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Activate/PaymentMadeBranchesActivateSubscriber.ts
new file mode 100644
index 000000000..334cff548
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Activate/PaymentMadeBranchesActivateSubscriber.ts
@@ -0,0 +1,38 @@
+import { IBranchesActivatedPayload } from '@/interfaces';
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { BillPaymentsActivateBranches } from '../../Integrations/Purchases/PaymentMadeBranchesActivate';
+
+@Service()
+export class PaymentMadeActivateBranchesSubscriber {
+  @Inject()
+  private paymentsActivateBranches: BillPaymentsActivateBranches;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.branch.onActivated,
+      this.updatePaymentsWithBranchOnActivated
+    );
+    return bus;
+  }
+
+  /**
+   * Updates accounts transactions with the primary branch once
+   * the multi-branches is activated.
+   * @param {IBranchesActivatedPayload}
+   */
+  private updatePaymentsWithBranchOnActivated = async ({
+    tenantId,
+    primaryBranch,
+    trx,
+  }: IBranchesActivatedPayload) => {
+    await this.paymentsActivateBranches.updateBillPaymentsWithBranch(
+      tenantId,
+      primaryBranch.id,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Activate/PaymentReceiveBranchesActivateSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Activate/PaymentReceiveBranchesActivateSubscriber.ts
new file mode 100644
index 000000000..287abf627
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Activate/PaymentReceiveBranchesActivateSubscriber.ts
@@ -0,0 +1,38 @@
+import { IBranchesActivatedPayload } from '@/interfaces';
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { PaymentReceiveActivateBranches } from '../../Integrations/Sales/PaymentReceiveBranchesActivate';
+
+@Service()
+export class PaymentReceiveActivateBranchesSubscriber {
+  @Inject()
+  private paymentsActivateBranches: PaymentReceiveActivateBranches;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.branch.onActivated,
+      this.updateCreditNoteWithBranchOnActivated
+    );
+    return bus;
+  }
+
+  /**
+   * Updates accounts transactions with the primary branch once
+   * the multi-branches is activated.
+   * @param {IBranchesActivatedPayload}
+   */
+  private updateCreditNoteWithBranchOnActivated = async ({
+    tenantId,
+    primaryBranch,
+    trx,
+  }: IBranchesActivatedPayload) => {
+    await this.paymentsActivateBranches.updatePaymentsWithBranch(
+      tenantId,
+      primaryBranch.id,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Activate/SaleEstiamtesBranchesActivateSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Activate/SaleEstiamtesBranchesActivateSubscriber.ts
new file mode 100644
index 000000000..d01b7e235
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Activate/SaleEstiamtesBranchesActivateSubscriber.ts
@@ -0,0 +1,38 @@
+import { IBranchesActivatedPayload } from '@/interfaces';
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { SaleEstimateActivateBranches } from '../../Integrations/Sales/SaleEstimatesBranchesActivate';
+
+@Service()
+export class SaleEstimatesActivateBranchesSubscriber {
+  @Inject()
+  private estimatesActivateBranches: SaleEstimateActivateBranches;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.branch.onActivated,
+      this.updateEstimatesWithBranchOnActivated
+    );
+    return bus;
+  }
+
+  /**
+   * Updates accounts transactions with the primary branch once
+   * the multi-branches is activated.
+   * @param {IBranchesActivatedPayload}
+   */
+  private updateEstimatesWithBranchOnActivated = async ({
+    tenantId,
+    primaryBranch,
+    trx,
+  }: IBranchesActivatedPayload) => {
+    await this.estimatesActivateBranches.updateEstimatesWithBranch(
+      tenantId,
+      primaryBranch.id,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Activate/SaleInvoiceBranchesActivateSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Activate/SaleInvoiceBranchesActivateSubscriber.ts
new file mode 100644
index 000000000..89a3ced33
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Activate/SaleInvoiceBranchesActivateSubscriber.ts
@@ -0,0 +1,38 @@
+import { IBranchesActivatedPayload } from '@/interfaces';
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { SaleInvoiceActivateBranches } from '../../Integrations/Sales/SaleInvoiceBranchesActivate';
+
+@Service()
+export class SaleInvoicesActivateBranchesSubscriber {
+  @Inject()
+  private invoicesActivateBranches: SaleInvoiceActivateBranches;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.branch.onActivated,
+      this.updateInvoicesWithBranchOnActivated
+    );
+    return bus;
+  }
+
+  /**
+   * Updates accounts transactions with the primary branch once
+   * the multi-branches is activated.
+   * @param {IBranchesActivatedPayload}
+   */
+  private updateInvoicesWithBranchOnActivated = async ({
+    tenantId,
+    primaryBranch,
+    trx,
+  }: IBranchesActivatedPayload) => {
+    await this.invoicesActivateBranches.updateInvoicesWithBranch(
+      tenantId,
+      primaryBranch.id,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Activate/SaleReceiptsBranchesActivateSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Activate/SaleReceiptsBranchesActivateSubscriber.ts
new file mode 100644
index 000000000..95238d98f
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Activate/SaleReceiptsBranchesActivateSubscriber.ts
@@ -0,0 +1,38 @@
+import { IBranchesActivatedPayload } from '@/interfaces';
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { SaleReceiptActivateBranches } from '../../Integrations/Sales/SaleReceiptBranchesActivate';
+
+@Service()
+export class SaleReceiptsActivateBranchesSubscriber {
+  @Inject()
+  private receiptsActivateBranches: SaleReceiptActivateBranches;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.branch.onActivated,
+      this.updateReceiptsWithBranchOnActivated
+    );
+    return bus;
+  }
+
+  /**
+   * Updates accounts transactions with the primary branch once
+   * the multi-branches is activated.
+   * @param {IBranchesActivatedPayload}
+   */
+  private updateReceiptsWithBranchOnActivated = async ({
+    tenantId,
+    primaryBranch,
+    trx,
+  }: IBranchesActivatedPayload) => {
+    await this.receiptsActivateBranches.updateReceiptsWithBranch(
+      tenantId,
+      primaryBranch.id,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Activate/index.ts b/packages/server/src/services/Branches/Subscribers/Activate/index.ts
new file mode 100644
index 000000000..fa691a069
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Activate/index.ts
@@ -0,0 +1,8 @@
+export * from './CashflowBranchesActviateSubscriber';
+export * from './CreditNoteBranchesActivateSubscriber';
+export * from './PaymentMadeBranchesActivateSubscriber';
+export * from './PaymentReceiveBranchesActivateSubscriber';
+export * from './SaleReceiptsBranchesActivateSubscriber';
+export * from './SaleEstiamtesBranchesActivateSubscriber';
+export * from './SaleInvoiceBranchesActivateSubscriber';
+export * from './ExpenseBranchesActivateSubscriber';
\ No newline at end of file
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/BillBranchSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Validators/BillBranchSubscriber.ts
new file mode 100644
index 000000000..898557107
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/BillBranchSubscriber.ts
@@ -0,0 +1,53 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import { IBillCreatingPayload, IBillEditingPayload } from '@/interfaces';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+
+@Service()
+export class BillBranchValidateSubscriber {
+  @Inject()
+  private validateBranchExistance: ValidateBranchExistance;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.bill.onCreating,
+      this.validateBranchExistanceOnBillCreating
+    );
+    bus.subscribe(
+      events.bill.onEditing,
+      this.validateBranchExistanceOnBillEditing
+    );
+    return bus;
+  };
+
+  /**
+   * Validate branch existance on estimate creating.
+   * @param {ISaleEstimateCreatedPayload} payload
+   */
+  private validateBranchExistanceOnBillCreating = async ({
+    tenantId,
+    billDTO,
+  }: IBillCreatingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      billDTO.branchId
+    );
+  };
+
+  /**
+   * Validate branch existance once estimate editing.
+   * @param {ISaleEstimateEditingPayload} payload
+   */
+  private validateBranchExistanceOnBillEditing = async ({
+    billDTO,
+    tenantId,
+  }: IBillEditingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      billDTO.branchId
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/CashflowBranchDTOValidatorSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Validators/CashflowBranchDTOValidatorSubscriber.ts
new file mode 100644
index 000000000..5b8f20bd2
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/CashflowBranchDTOValidatorSubscriber.ts
@@ -0,0 +1,35 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import { ICommandCashflowCreatingPayload } from '@/interfaces';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+
+@Service()
+export class CashflowBranchDTOValidatorSubscriber {
+  @Inject()
+  private validateBranchExistance: ValidateBranchExistance;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.cashflow.onTransactionCreating,
+      this.validateBranchExistanceOnCashflowTransactionCreating
+    );
+    return bus;
+  };
+
+  /**
+   * Validate branch existance once cashflow transaction creating.
+   * @param {ICommandCashflowCreatingPayload} payload
+   */
+  private validateBranchExistanceOnCashflowTransactionCreating = async ({
+    tenantId,
+    newTransactionDTO,
+  }: ICommandCashflowCreatingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      newTransactionDTO.branchId
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/ContactOpeningBalanceBranchSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Validators/ContactOpeningBalanceBranchSubscriber.ts
new file mode 100644
index 000000000..6d663ea55
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/ContactOpeningBalanceBranchSubscriber.ts
@@ -0,0 +1,104 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  ICustomerEventCreatingPayload,
+  ICustomerOpeningBalanceEditingPayload,
+  IVendorEventCreatingPayload,
+  IVendorOpeningBalanceEditingPayload,
+} from '@/interfaces';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+
+@Service()
+export class ContactBranchValidateSubscriber {
+  @Inject()
+  private validateBranchExistance: ValidateBranchExistance;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.customers.onCreating,
+      this.validateBranchExistanceOnCustomerCreating
+    );
+    bus.subscribe(
+      events.customers.onOpeningBalanceChanging,
+      this.validateBranchExistanceOnCustomerOpeningBalanceEditing
+    );
+    bus.subscribe(
+      events.vendors.onCreating,
+      this.validateBranchExistanceonVendorCreating
+    );
+    bus.subscribe(
+      events.vendors.onOpeningBalanceChanging,
+      this.validateBranchExistanceOnVendorOpeningBalanceEditing
+    );
+    return bus;
+  };
+
+  /**
+   * Validate branch existance on customer creating.
+   * @param {ICustomerEventCreatingPayload} payload
+   */
+  private validateBranchExistanceOnCustomerCreating = async ({
+    tenantId,
+    customerDTO,
+  }: ICustomerEventCreatingPayload) => {
+    // Can't continue if the customer opening balance is zero.
+    if (!customerDTO.openingBalance) return;
+
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      customerDTO.openingBalanceBranchId
+    );
+  };
+
+  /**
+   * Validate branch existance once customer opening balance editing.
+   * @param {ICustomerOpeningBalanceEditingPayload} payload
+   */
+  private validateBranchExistanceOnCustomerOpeningBalanceEditing = async ({
+    openingBalanceEditDTO,
+    tenantId,
+  }: ICustomerOpeningBalanceEditingPayload) => {
+    if (!openingBalanceEditDTO.openingBalance) return;
+
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      openingBalanceEditDTO.openingBalanceBranchId
+    );
+  };
+
+  /**
+   * Validates the branch existance on vendor creating.
+   * @param {IVendorEventCreatingPayload} payload -
+   */
+  private validateBranchExistanceonVendorCreating = async ({
+    vendorDTO,
+    tenantId,
+  }: IVendorEventCreatingPayload) => {
+    // Can't continue if the customer opening balance is zero.
+    if (!vendorDTO.openingBalance) return;
+
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      vendorDTO.openingBalanceBranchId
+    );
+  };
+
+  /**
+   * Validate branch existance once the vendor opening balance editing.
+   * @param {IVendorOpeningBalanceEditingPayload}
+   */
+  private validateBranchExistanceOnVendorOpeningBalanceEditing = async ({
+    tenantId,
+    openingBalanceEditDTO,
+  }: IVendorOpeningBalanceEditingPayload) => {
+    if (!openingBalanceEditDTO.openingBalance) return;
+
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      openingBalanceEditDTO.openingBalanceBranchId
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/CreditNoteBranchesSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Validators/CreditNoteBranchesSubscriber.ts
new file mode 100644
index 000000000..a6a07d719
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/CreditNoteBranchesSubscriber.ts
@@ -0,0 +1,56 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  ICreditNoteCreatingPayload,
+  ICreditNoteEditingPayload,
+} from '@/interfaces';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+
+@Service()
+export class CreditNoteBranchValidateSubscriber {
+  @Inject()
+  private validateBranchExistance: ValidateBranchExistance;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.creditNote.onCreating,
+      this.validateBranchExistanceOnCreditCreating
+    );
+    bus.subscribe(
+      events.creditNote.onEditing,
+      this.validateBranchExistanceOnCreditEditing
+    );
+    return bus;
+  };
+
+  /**
+   * Validate branch existance on estimate creating.
+   * @param {ICreditNoteCreatingPayload} payload
+   */
+  private validateBranchExistanceOnCreditCreating = async ({
+    tenantId,
+    creditNoteDTO,
+  }: ICreditNoteCreatingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      creditNoteDTO.branchId
+    );
+  };
+
+  /**
+   * Validate branch existance once estimate editing.
+   * @param {ISaleEstimateEditingPayload} payload
+   */
+  private validateBranchExistanceOnCreditEditing = async ({
+    creditNoteEditDTO,
+    tenantId,
+  }: ICreditNoteEditingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      creditNoteEditDTO.branchId
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/CreditNoteRefundBranchSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Validators/CreditNoteRefundBranchSubscriber.ts
new file mode 100644
index 000000000..85181b38b
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/CreditNoteRefundBranchSubscriber.ts
@@ -0,0 +1,35 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import { IRefundCreditNoteCreatingPayload } from '@/interfaces';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+
+@Service()
+export class CreditNoteRefundBranchValidateSubscriber {
+  @Inject()
+  private validateBranchExistance: ValidateBranchExistance;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.creditNote.onRefundCreating,
+      this.validateBranchExistanceOnCreditRefundCreating
+    );
+    return bus;
+  };
+
+  /**
+   * Validate branch existance on refund credit note creating.
+   * @param {ICreditNoteCreatingPayload} payload
+   */
+  private validateBranchExistanceOnCreditRefundCreating = async ({
+    tenantId,
+    newCreditNoteDTO,
+  }: IRefundCreditNoteCreatingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      newCreditNoteDTO.branchId
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/ExpenseBranchSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Validators/ExpenseBranchSubscriber.ts
new file mode 100644
index 000000000..afac67563
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/ExpenseBranchSubscriber.ts
@@ -0,0 +1,56 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  IExpenseCreatingPayload,
+  IExpenseEventEditingPayload,
+} from '@/interfaces';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+
+@Service()
+export class ExpenseBranchValidateSubscriber {
+  @Inject()
+  private validateBranchExistance: ValidateBranchExistance;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.expenses.onCreating,
+      this.validateBranchExistanceOnExpenseCreating
+    );
+    bus.subscribe(
+      events.expenses.onEditing,
+      this.validateBranchExistanceOnExpenseEditing
+    );
+    return bus;
+  };
+
+  /**
+   * Validate branch existance once expense transaction creating.
+   * @param {ISaleEstimateCreatedPayload} payload
+   */
+  private validateBranchExistanceOnExpenseCreating = async ({
+    tenantId,
+    expenseDTO,
+  }: IExpenseCreatingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      expenseDTO.branchId
+    );
+  };
+
+  /**
+   * Validate branch existance once expense transaction editing.
+   * @param {ISaleEstimateEditingPayload} payload
+   */
+  private validateBranchExistanceOnExpenseEditing = async ({
+    expenseDTO,
+    tenantId,
+  }: IExpenseEventEditingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      expenseDTO.branchId
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/InventoryAdjustmentBranchValidatorSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Validators/InventoryAdjustmentBranchValidatorSubscriber.ts
new file mode 100644
index 000000000..f2d8ae206
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/InventoryAdjustmentBranchValidatorSubscriber.ts
@@ -0,0 +1,35 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import { IInventoryAdjustmentCreatingPayload } from '@/interfaces';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+
+@Service()
+export class InventoryAdjustmentBranchValidateSubscriber {
+  @Inject()
+  private validateBranchExistance: ValidateBranchExistance;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.inventoryAdjustment.onQuickCreating,
+      this.validateBranchExistanceOnInventoryCreating
+    );
+    return bus;
+  };
+
+  /**
+   * Validate branch existance on invoice creating.
+   * @param {ISaleInvoiceCreatingPaylaod} payload
+   */
+  private validateBranchExistanceOnInventoryCreating = async ({
+    tenantId,
+    quickAdjustmentDTO,
+  }: IInventoryAdjustmentCreatingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      quickAdjustmentDTO.branchId
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/InvoiceBranchValidatorSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Validators/InvoiceBranchValidatorSubscriber.ts
new file mode 100644
index 000000000..4dc4d9368
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/InvoiceBranchValidatorSubscriber.ts
@@ -0,0 +1,56 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  ISaleInvoiceCreatingPaylaod,
+  ISaleInvoiceEditingPayload,
+} from '@/interfaces';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+
+@Service()
+export class InvoiceBranchValidateSubscriber {
+  @Inject()
+  private validateBranchExistance: ValidateBranchExistance;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.saleInvoice.onCreating,
+      this.validateBranchExistanceOnInvoiceCreating
+    );
+    bus.subscribe(
+      events.saleInvoice.onEditing,
+      this.validateBranchExistanceOnInvoiceEditing
+    );
+    return bus;
+  };
+
+  /**
+   * Validate branch existance on invoice creating.
+   * @param {ISaleInvoiceCreatingPaylaod} payload
+   */
+  private validateBranchExistanceOnInvoiceCreating = async ({
+    tenantId,
+    saleInvoiceDTO,
+  }: ISaleInvoiceCreatingPaylaod) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      saleInvoiceDTO.branchId
+    );
+  };
+
+  /**
+   * Validate branch existance once invoice editing.
+   * @param {ISaleInvoiceEditingPayload} payload
+   */
+  private validateBranchExistanceOnInvoiceEditing = async ({
+    saleInvoiceDTO,
+    tenantId,
+  }: ISaleInvoiceEditingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      saleInvoiceDTO.branchId
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/ManualJournalBranchSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Validators/ManualJournalBranchSubscriber.ts
new file mode 100644
index 000000000..dbfab37d1
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/ManualJournalBranchSubscriber.ts
@@ -0,0 +1,76 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  Features,
+  IManualJournalCreatingPayload,
+  IManualJournalEditingPayload,
+} from '@/interfaces';
+import { ManualJournalBranchesValidator } from '../../Integrations/ManualJournals/ManualJournalsBranchesValidator';
+import { FeaturesManager } from '@/services/Features/FeaturesManager';
+
+@Service()
+export class ManualJournalBranchValidateSubscriber {
+  @Inject()
+  private validateManualJournalBranch: ManualJournalBranchesValidator;
+
+  @Inject()
+  private featuresManager: FeaturesManager;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.manualJournals.onCreating,
+      this.validateBranchExistanceOnBillCreating
+    );
+    bus.subscribe(
+      events.manualJournals.onEditing,
+      this.validateBranchExistanceOnBillEditing
+    );
+    return bus;
+  };
+
+  /**
+   * Validate branch existance on estimate creating.
+   * @param {IManualJournalCreatingPayload} payload
+   */
+  private validateBranchExistanceOnBillCreating = async ({
+    manualJournalDTO,
+    tenantId,
+  }: IManualJournalCreatingPayload) => {
+    // Detarmines whether the multi-branches is accessible by tenant.
+    const isAccessible = await this.featuresManager.accessible(
+      tenantId,
+      Features.BRANCHES
+    );
+    // Can't continue if the multi-branches feature is inactive.
+    if (!isAccessible) return;
+
+    // Validates the entries whether have branch id.
+    await this.validateManualJournalBranch.validateEntriesHasBranchId(
+      manualJournalDTO
+    );
+  };
+
+  /**
+   * Validate branch existance once estimate editing.
+   * @param {ISaleEstimateEditingPayload} payload
+   */
+  private validateBranchExistanceOnBillEditing = async ({
+    tenantId,
+    manualJournalDTO,
+  }: IManualJournalEditingPayload) => {
+    // Detarmines whether the multi-branches is accessible by tenant.
+    const isAccessible = await this.featuresManager.accessible(
+      tenantId,
+      Features.BRANCHES
+    );
+    // Can't continue if the multi-branches feature is inactive.
+    if (!isAccessible) return;
+
+    await this.validateManualJournalBranch.validateEntriesHasBranchId(
+      manualJournalDTO
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/PaymentMadeBranchSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Validators/PaymentMadeBranchSubscriber.ts
new file mode 100644
index 000000000..ef76dc320
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/PaymentMadeBranchSubscriber.ts
@@ -0,0 +1,56 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  IBillPaymentCreatingPayload,
+  IBillPaymentEditingPayload,
+} from '@/interfaces';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+
+@Service()
+export class PaymentMadeBranchValidateSubscriber {
+  @Inject()
+  private validateBranchExistance: ValidateBranchExistance;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.billPayment.onCreating,
+      this.validateBranchExistanceOnPaymentCreating
+    );
+    bus.subscribe(
+      events.billPayment.onEditing,
+      this.validateBranchExistanceOnPaymentEditing
+    );
+    return bus;
+  };
+
+  /**
+   * Validate branch existance on estimate creating.
+   * @param {ISaleEstimateCreatedPayload} payload
+   */
+  private validateBranchExistanceOnPaymentCreating = async ({
+    tenantId,
+    billPaymentDTO,
+  }: IBillPaymentCreatingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      billPaymentDTO.branchId
+    );
+  };
+
+  /**
+   * Validate branch existance once estimate editing.
+   * @param {ISaleEstimateEditingPayload} payload
+   */
+  private validateBranchExistanceOnPaymentEditing = async ({
+    billPaymentDTO,
+    tenantId,
+  }: IBillPaymentEditingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      billPaymentDTO.branchId
+    );
+  };
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/PaymentReceiveBranchSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Validators/PaymentReceiveBranchSubscriber.ts
new file mode 100644
index 000000000..e08b78489
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/PaymentReceiveBranchSubscriber.ts
@@ -0,0 +1,56 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  IPaymentReceiveCreatingPayload,
+  IPaymentReceiveEditingPayload,
+} from '@/interfaces';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+
+@Service()
+export class PaymentReceiveBranchValidateSubscriber {
+  @Inject()
+  private validateBranchExistance: ValidateBranchExistance;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.paymentReceive.onCreating,
+      this.validateBranchExistanceOnPaymentCreating
+    );
+    bus.subscribe(
+      events.paymentReceive.onEditing,
+      this.validateBranchExistanceOnPaymentEditing
+    );
+    return bus;
+  };
+
+  /**
+   * Validate branch existance on estimate creating.
+   * @param {IPaymentReceiveCreatingPayload} payload
+   */
+  private validateBranchExistanceOnPaymentCreating = async ({
+    tenantId,
+    paymentReceiveDTO,
+  }: IPaymentReceiveCreatingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      paymentReceiveDTO.branchId
+    );
+  };
+
+  /**
+   * Validate branch existance once estimate editing.
+   * @param {IPaymentReceiveEditingPayload} payload
+   */
+  private validateBranchExistanceOnPaymentEditing = async ({
+    paymentReceiveDTO,
+    tenantId,
+  }: IPaymentReceiveEditingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      paymentReceiveDTO.branchId
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/SaleEstimateMultiBranchesSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Validators/SaleEstimateMultiBranchesSubscriber.ts
new file mode 100644
index 000000000..0513ba755
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/SaleEstimateMultiBranchesSubscriber.ts
@@ -0,0 +1,56 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  ISaleEstimateCreatingPayload,
+  ISaleEstimateEditingPayload,
+} from '@/interfaces';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+
+@Service()
+export class SaleEstimateBranchValidateSubscriber {
+  @Inject()
+  private validateBranchExistance: ValidateBranchExistance;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.saleEstimate.onCreating,
+      this.validateBranchExistanceOnEstimateCreating
+    );
+    bus.subscribe(
+      events.saleEstimate.onEditing,
+      this.validateBranchExistanceOnEstimateEditing
+    );
+    return bus;
+  };
+
+  /**
+   * Validate branch existance on estimate creating.
+   * @param {ISaleEstimateCreatedPayload} payload
+   */
+  private validateBranchExistanceOnEstimateCreating = async ({
+    tenantId,
+    estimateDTO,
+  }: ISaleEstimateCreatingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      estimateDTO.branchId
+    );
+  };
+
+  /**
+   * Validate branch existance once estimate editing.
+   * @param {ISaleEstimateEditingPayload} payload
+   */
+  private validateBranchExistanceOnEstimateEditing = async ({
+    estimateDTO,
+    tenantId,
+  }: ISaleEstimateEditingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      estimateDTO.branchId
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/SaleReceiptBranchesSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Validators/SaleReceiptBranchesSubscriber.ts
new file mode 100644
index 000000000..0cee5987f
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/SaleReceiptBranchesSubscriber.ts
@@ -0,0 +1,56 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  ISaleReceiptCreatingPayload,
+  ISaleReceiptEditingPayload,
+} from '@/interfaces';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+
+@Service()
+export class SaleReceiptBranchValidateSubscriber {
+  @Inject()
+  private validateBranchExistance: ValidateBranchExistance;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.saleReceipt.onCreating,
+      this.validateBranchExistanceOnInvoiceCreating
+    );
+    bus.subscribe(
+      events.saleReceipt.onEditing,
+      this.validateBranchExistanceOnInvoiceEditing
+    );
+    return bus;
+  };
+
+  /**
+   * Validate branch existance on estimate creating.
+   * @param {ISaleReceiptCreatingPayload} payload
+   */
+  private validateBranchExistanceOnInvoiceCreating = async ({
+    tenantId,
+    saleReceiptDTO,
+  }: ISaleReceiptCreatingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      saleReceiptDTO.branchId
+    );
+  };
+
+  /**
+   * Validate branch existance once estimate editing.
+   * @param {ISaleReceiptEditingPayload} payload
+   */
+  private validateBranchExistanceOnInvoiceEditing = async ({
+    saleReceiptDTO,
+    tenantId,
+  }: ISaleReceiptEditingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      saleReceiptDTO.branchId
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/VendorCreditBranchSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Validators/VendorCreditBranchSubscriber.ts
new file mode 100644
index 000000000..daea8bc93
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/VendorCreditBranchSubscriber.ts
@@ -0,0 +1,56 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  IVendorCreditCreatingPayload,
+  IVendorCreditEditingPayload,
+} from '@/interfaces';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+
+@Service()
+export class VendorCreditBranchValidateSubscriber {
+  @Inject()
+  private validateBranchExistance: ValidateBranchExistance;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.vendorCredit.onCreating,
+      this.validateBranchExistanceOnCreditCreating
+    );
+    bus.subscribe(
+      events.vendorCredit.onEditing,
+      this.validateBranchExistanceOnCreditEditing
+    );
+    return bus;
+  };
+
+  /**
+   * Validate branch existance on estimate creating.
+   * @param {ISaleEstimateCreatedPayload} payload
+   */
+  private validateBranchExistanceOnCreditCreating = async ({
+    tenantId,
+    vendorCreditCreateDTO,
+  }: IVendorCreditCreatingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      vendorCreditCreateDTO.branchId
+    );
+  };
+
+  /**
+   * Validate branch existance once estimate editing.
+   * @param {ISaleEstimateEditingPayload} payload
+   */
+  private validateBranchExistanceOnCreditEditing = async ({
+    vendorCreditDTO,
+    tenantId,
+  }: IVendorCreditEditingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      vendorCreditDTO.branchId
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/VendorCreditRefundBranchSubscriber.ts b/packages/server/src/services/Branches/Subscribers/Validators/VendorCreditRefundBranchSubscriber.ts
new file mode 100644
index 000000000..d191f0353
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/VendorCreditRefundBranchSubscriber.ts
@@ -0,0 +1,35 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import { IRefundVendorCreditCreatingPayload } from '@/interfaces';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+
+@Service()
+export class VendorCreditRefundBranchValidateSubscriber {
+  @Inject()
+  private validateBranchExistance: ValidateBranchExistance;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.vendorCredit.onRefundCreating,
+      this.validateBranchExistanceOnCreditRefundCreating
+    );
+    return bus;
+  };
+
+  /**
+   * Validate branch existance on refund credit note creating.
+   * @param {IRefundVendorCreditCreatingPayload} payload
+   */
+  private validateBranchExistanceOnCreditRefundCreating = async ({
+    tenantId,
+    refundVendorCreditDTO,
+  }: IRefundVendorCreditCreatingPayload) => {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      tenantId,
+      refundVendorCreditDTO.branchId
+    );
+  };
+}
diff --git a/packages/server/src/services/Branches/Subscribers/Validators/index.ts b/packages/server/src/services/Branches/Subscribers/Validators/index.ts
new file mode 100644
index 000000000..8865dbfcb
--- /dev/null
+++ b/packages/server/src/services/Branches/Subscribers/Validators/index.ts
@@ -0,0 +1,15 @@
+export * from './BillBranchSubscriber';
+export * from './CashflowBranchDTOValidatorSubscriber';
+export * from './CreditNoteBranchesSubscriber';
+export * from './CreditNoteRefundBranchSubscriber';
+export * from './ExpenseBranchSubscriber';
+export * from './ManualJournalBranchSubscriber';
+export * from './PaymentMadeBranchSubscriber';
+export * from './PaymentReceiveBranchSubscriber';
+export * from './SaleEstimateMultiBranchesSubscriber';
+export * from './SaleReceiptBranchesSubscriber';
+export * from './VendorCreditBranchSubscriber';
+export * from './VendorCreditRefundBranchSubscriber';
+export * from './InvoiceBranchValidatorSubscriber';
+export * from './ContactOpeningBalanceBranchSubscriber';
+export * from './InventoryAdjustmentBranchValidatorSubscriber';
\ No newline at end of file
diff --git a/packages/server/src/services/Branches/constants.ts b/packages/server/src/services/Branches/constants.ts
new file mode 100644
index 000000000..e0d80f876
--- /dev/null
+++ b/packages/server/src/services/Branches/constants.ts
@@ -0,0 +1,7 @@
+export const ERRORS = {
+  BRANCH_NOT_FOUND: 'BRANCH_NOT_FOUND',
+  MUTLI_BRANCHES_ALREADY_ACTIVATED: 'MUTLI_BRANCHES_ALREADY_ACTIVATED',
+  COULD_NOT_DELETE_ONLY_BRANCH: 'COULD_NOT_DELETE_ONLY_BRANCH',
+  BRANCH_CODE_NOT_UNIQUE: 'BRANCH_CODE_NOT_UNIQUE',
+  BRANCH_HAS_ASSOCIATED_TRANSACTIONS: 'BRANCH_HAS_ASSOCIATED_TRANSACTIONS'
+};
diff --git a/packages/server/src/services/Cache/index.ts b/packages/server/src/services/Cache/index.ts
new file mode 100644
index 000000000..31c3355f0
--- /dev/null
+++ b/packages/server/src/services/Cache/index.ts
@@ -0,0 +1,49 @@
+import NodeCache from 'node-cache';
+
+export default class Cache {
+  cache: NodeCache;
+
+  constructor(config?: object) {
+    this.cache = new NodeCache({
+      useClones: false,
+      ...config,
+    });
+  }
+
+  get(key: string, storeFunction: () => Promise<any>) {
+    const value = this.cache.get(key);
+
+    if (value) {
+      return Promise.resolve(value);
+    }
+    return storeFunction().then((result) => {
+      this.cache.set(key, result);
+      return result;
+    });
+  }
+
+  set(key: string, results: any) {
+    this.cache.set(key, results);
+  }
+
+  del(keys: string) {
+    this.cache.del(keys);
+  }
+
+  delStartWith(startStr = '') {
+    if (!startStr) {
+      return;
+    }
+
+    const keys = this.cache.keys();
+    for (const key of keys) {
+      if (key.indexOf(startStr) === 0) {
+        this.del(key);
+      }
+    }
+  }
+
+  flush() {
+    this.cache.flushAll();
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Cashflow/CashflowAccountTransformer.ts b/packages/server/src/services/Cashflow/CashflowAccountTransformer.ts
new file mode 100644
index 000000000..e89104655
--- /dev/null
+++ b/packages/server/src/services/Cashflow/CashflowAccountTransformer.ts
@@ -0,0 +1,40 @@
+import { IAccount } from '@/interfaces';
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class CashflowAccountTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {string[]}
+   */
+  public includeAttributes = (): string[] => {
+    return ['formattedAmount'];
+  };
+
+  /**
+   * Exclude these attributes to sale invoice object.
+   * @returns {string[]}
+   */
+  public excludeAttributes = (): string[] => {
+    return [
+      'predefined',
+      'index',
+      'accountRootType',
+      'accountTypeLabel',
+      'accountParentType',
+      'isBalanceSheetAccount',
+      'isPlSheet',
+    ];
+  };
+
+  /**
+   * Retrieve formatted account amount.
+   * @param   {IAccount} invoice
+   * @returns {string}
+   */
+  protected formattedAmount = (account: IAccount): string => {
+    return formatNumber(account.amount, {
+      currencyCode: account.currencyCode,
+    });
+  };
+}
diff --git a/packages/server/src/services/Cashflow/CashflowDeleteAccount.ts b/packages/server/src/services/Cashflow/CashflowDeleteAccount.ts
new file mode 100644
index 000000000..1c15672c7
--- /dev/null
+++ b/packages/server/src/services/Cashflow/CashflowDeleteAccount.ts
@@ -0,0 +1,30 @@
+import { Service, Inject } from 'typedi';
+import { ServiceError } from '@/exceptions';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ERRORS } from './constants';
+
+@Service()
+export default class CashflowDeleteAccount {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Validate the account has no associated cashflow transactions.
+   * @param {number} tenantId 
+   * @param {number} accountId 
+   */
+  public validateAccountHasNoCashflowEntries = async (
+    tenantId: number,
+    accountId: number
+  ) => {
+    const { CashflowTransactionLine } = this.tenancy.models(tenantId);
+
+    const associatedLines = await CashflowTransactionLine.query()
+      .where('creditAccountId', accountId)
+      .orWhere('cashflowAccountId', accountId);
+
+    if (associatedLines.length > 0) {
+      throw new ServiceError(ERRORS.ACCOUNT_HAS_ASSOCIATED_TRANSACTIONS)
+    }
+  };
+}
diff --git a/packages/server/src/services/Cashflow/CashflowTransactionAutoIncrement.ts b/packages/server/src/services/Cashflow/CashflowTransactionAutoIncrement.ts
new file mode 100644
index 000000000..58eef54bd
--- /dev/null
+++ b/packages/server/src/services/Cashflow/CashflowTransactionAutoIncrement.ts
@@ -0,0 +1,31 @@
+import { Service, Inject } from 'typedi';
+import AutoIncrementOrdersService from '@/services/Sales/AutoIncrementOrdersService';
+
+@Service()
+export class CashflowTransactionAutoIncrement {
+  @Inject()
+  private autoIncrementOrdersService: AutoIncrementOrdersService;
+
+  /**
+   * Retrieve the next unique invoice number.
+   * @param  {number} tenantId - Tenant id.
+   * @return {string}
+   */
+  public getNextTransactionNumber = (tenantId: number): string => {
+    return this.autoIncrementOrdersService.getNextTransactionNumber(
+      tenantId,
+      'cashflow'
+    );
+  };
+
+  /**
+   * Increment the invoice next number.
+   * @param {number} tenantId -
+   */
+  public incrementNextTransactionNumber = (tenantId: number) => {
+    return this.autoIncrementOrdersService.incrementSettingsNextNumber(
+      tenantId,
+      'cashflow'
+    );
+  };
+}
diff --git a/packages/server/src/services/Cashflow/CashflowTransactionJournalEntries.ts b/packages/server/src/services/Cashflow/CashflowTransactionJournalEntries.ts
new file mode 100644
index 000000000..93d23e3b1
--- /dev/null
+++ b/packages/server/src/services/Cashflow/CashflowTransactionJournalEntries.ts
@@ -0,0 +1,171 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import * as R from 'ramda';
+import {
+  ILedgerEntry,
+  ICashflowTransaction,
+  AccountNormal,
+  ICashflowTransactionLine,
+} from '../../interfaces';
+import {
+  transformCashflowTransactionType,
+  getCashflowAccountTransactionsTypes,
+} from './utils';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import Ledger from '@/services/Accounting/Ledger';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export default class CashflowTransactionJournalEntries {
+  @Inject()
+  private ledgerStorage: LedgerStorageService;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Retrieves the common entry of cashflow transaction.
+   * @param   {ICashflowTransaction} cashflowTransaction
+   * @returns {}
+   */
+  private getCommonEntry = (cashflowTransaction: ICashflowTransaction) => {
+    const { entries, ...transaction } = cashflowTransaction;
+
+    return {
+      date: transaction.date,
+      currencyCode: transaction.currencyCode,
+      exchangeRate: transaction.exchangeRate,
+
+      transactionType: transformCashflowTransactionType(
+        transaction.transactionType
+      ),
+      transactionId: transaction.id,
+      transactionNumber: transaction.transactionNumber,
+      referenceNo: transaction.referenceNo,
+
+      branchId: cashflowTransaction.branchId,
+      userId: cashflowTransaction.userId,
+    };
+  };
+
+  /**
+   * Retrieves the cashflow debit GL entry.
+   * @param {ICashflowTransaction} cashflowTransaction
+   * @param {ICashflowTransactionLine} entry
+   * @param {number} index
+   * @returns {ILedgerEntry}
+   */
+  private getCashflowDebitGLEntry = (
+    cashflowTransaction: ICashflowTransaction
+  ): ILedgerEntry => {
+    const commonEntry = this.getCommonEntry(cashflowTransaction);
+
+    return {
+      ...commonEntry,
+      accountId: cashflowTransaction.cashflowAccountId,
+      credit: cashflowTransaction.isCashCredit
+        ? cashflowTransaction.localAmount
+        : 0,
+      debit: cashflowTransaction.isCashDebit
+        ? cashflowTransaction.localAmount
+        : 0,
+      accountNormal: AccountNormal.DEBIT,
+      index: 1,
+    };
+  };
+
+  /**
+   * Retrieves the cashflow credit GL entry.
+   * @param   {ICashflowTransaction} cashflowTransaction
+   * @param   {ICashflowTransactionLine} entry
+   * @param   {number} index
+   * @returns {ILedgerEntry}
+   */
+  private getCashflowCreditGLEntry = (
+    cashflowTransaction: ICashflowTransaction
+  ): ILedgerEntry => {
+    const commonEntry = this.getCommonEntry(cashflowTransaction);
+
+    return {
+      ...commonEntry,
+      credit: cashflowTransaction.isCashDebit
+        ? cashflowTransaction.localAmount
+        : 0,
+      debit: cashflowTransaction.isCashCredit
+        ? cashflowTransaction.localAmount
+        : 0,
+      accountId: cashflowTransaction.creditAccountId,
+      accountNormal: cashflowTransaction.creditAccount.accountNormal,
+      index: 2,
+    };
+  };
+
+  /**
+   * Retrieves the cashflow transaction GL entry.
+   * @param   {ICashflowTransaction} cashflowTransaction
+   * @param   {ICashflowTransactionLine} entry
+   * @param   {number} index
+   * @returns
+   */
+  private getJournalEntries = (
+    cashflowTransaction: ICashflowTransaction
+  ): ILedgerEntry[] => {
+    const debitEntry = this.getCashflowDebitGLEntry(cashflowTransaction);
+    const creditEntry = this.getCashflowCreditGLEntry(cashflowTransaction);
+
+    return [debitEntry, creditEntry];
+  };
+
+  /**
+   * Retrieves the cashflow GL ledger.
+   * @param   {ICashflowTransaction} cashflowTransaction
+   * @returns {Ledger}
+   */
+  private getCashflowLedger = (cashflowTransaction: ICashflowTransaction) => {
+    const entries = this.getJournalEntries(cashflowTransaction);
+    return new Ledger(entries);
+  };
+
+  /**
+   * Write the journal entries of the given cashflow transaction.
+   * @param {number} tenantId
+   * @param {ICashflowTransaction} cashflowTransaction
+   */
+  public writeJournalEntries = async (
+    tenantId: number,
+    cashflowTransactionId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { CashflowTransaction } = this.tenancy.models(tenantId);
+
+    // Retrieves the cashflow transactions with associated entries.
+    const transaction = await CashflowTransaction.query(trx)
+      .findById(cashflowTransactionId)
+      .withGraphFetched('creditAccount');
+
+    // Retrieves the cashflow transaction ledger.
+    const ledger = this.getCashflowLedger(transaction);
+
+    await this.ledgerStorage.commit(tenantId, ledger, trx);
+  };
+
+  /**
+   * Delete the journal entries.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} cashflowTransactionId - Cashflow transaction id.
+   */
+  public revertJournalEntries = async (
+    tenantId: number,
+    cashflowTransactionId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const transactionTypes = getCashflowAccountTransactionsTypes();
+
+    await this.ledgerStorage.deleteByReference(
+      tenantId,
+      cashflowTransactionId,
+      transactionTypes,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Cashflow/CashflowTransactionSubscriber.ts b/packages/server/src/services/Cashflow/CashflowTransactionSubscriber.ts
new file mode 100644
index 000000000..91adb30ea
--- /dev/null
+++ b/packages/server/src/services/Cashflow/CashflowTransactionSubscriber.ts
@@ -0,0 +1,83 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import CashflowTransactionJournalEntries from './CashflowTransactionJournalEntries';
+import {
+  ICommandCashflowCreatedPayload,
+  ICommandCashflowDeletedPayload,
+} from '@/interfaces';
+import { CashflowTransactionAutoIncrement } from './CashflowTransactionAutoIncrement';
+
+@Service()
+export default class CashflowTransactionSubscriber {
+  @Inject()
+  private cashflowTransactionEntries: CashflowTransactionJournalEntries;
+
+  @Inject()
+  private cashflowTransactionAutoIncrement: CashflowTransactionAutoIncrement;
+
+  /**
+   * Attaches events with handles.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.cashflow.onTransactionCreated,
+      this.writeJournalEntriesOnceTransactionCreated
+    );
+    bus.subscribe(
+      events.cashflow.onTransactionCreated,
+      this.incrementTransactionNumberOnceTransactionCreated
+    );
+    bus.subscribe(
+      events.cashflow.onTransactionDeleted,
+      this.revertGLEntriesOnceTransactionDeleted
+    );
+    return bus;
+  }
+
+  /**
+   * Writes the journal entries once the cashflow transaction create.
+   * @param {ICommandCashflowCreatedPayload} payload -
+   */
+  private writeJournalEntriesOnceTransactionCreated = async ({
+    tenantId,
+    cashflowTransaction,
+    trx,
+  }: ICommandCashflowCreatedPayload) => {
+    // Can't write GL entries if the transaction not published yet.
+    if (!cashflowTransaction.isPublished) return;
+
+    await this.cashflowTransactionEntries.writeJournalEntries(
+      tenantId,
+      cashflowTransaction.id,
+      trx
+    );
+  };
+
+  /**
+   * Increment the cashflow transaction number once the transaction created.
+   * @param {ICommandCashflowCreatedPayload} payload -
+   */
+  private incrementTransactionNumberOnceTransactionCreated = async ({
+    tenantId,
+  }: ICommandCashflowCreatedPayload) => {
+    this.cashflowTransactionAutoIncrement.incrementNextTransactionNumber(
+      tenantId
+    );
+  };
+
+  /**
+   * Deletes the GL entries once the cashflow transaction deleted.
+   * @param {ICommandCashflowDeletedPayload} payload -
+   */
+  private revertGLEntriesOnceTransactionDeleted = async ({
+    tenantId,
+    cashflowTransactionId,
+    trx,
+  }: ICommandCashflowDeletedPayload) => {
+    await this.cashflowTransactionEntries.revertJournalEntries(
+      tenantId,
+      cashflowTransactionId,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Cashflow/CashflowTransactionTransformer.ts b/packages/server/src/services/Cashflow/CashflowTransactionTransformer.ts
new file mode 100644
index 000000000..797d847dd
--- /dev/null
+++ b/packages/server/src/services/Cashflow/CashflowTransactionTransformer.ts
@@ -0,0 +1,33 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class CashflowTransactionTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {string[]}
+   */
+  public includeAttributes = (): string[] => {
+    return ['formattedAmount', 'transactionTypeFormatted'];
+  };
+
+  /**
+   * Formatted amount.
+   * @param {} transaction
+   * @returns {string}
+   */
+  protected formattedAmount = (transaction) => {
+    return formatNumber(transaction.amount, {
+      currencyCode: transaction.currencyCode,
+      excerptZero: true,
+    });
+  };
+
+  /**
+   * Formatted transaction type.
+   * @param transaction 
+   * @returns {string}
+   */
+  protected transactionTypeFormatted = (transaction) => {
+    return this.context.i18n.__(transaction.transactionTypeFormatted);
+  }
+}
diff --git a/packages/server/src/services/Cashflow/CashflowTransactionsTransformer.ts b/packages/server/src/services/Cashflow/CashflowTransactionsTransformer.ts
new file mode 100644
index 000000000..a95d79588
--- /dev/null
+++ b/packages/server/src/services/Cashflow/CashflowTransactionsTransformer.ts
@@ -0,0 +1,71 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class CashflowTransactionTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {string[]}
+   */
+  protected includeAttributes = (): string[] => {
+    return ['deposit', 'withdrawal', 'formattedDeposit', 'formattedWithdrawal'];
+  };
+
+  /**
+   * Exclude these attributes.
+   * @returns {string[]}
+   */
+  protected excludeAttributes = (): string[] => {
+    return [
+      'credit',
+      'debit',
+      'index',
+      'index_group',
+      'item_id',
+      'item_quantity',
+      'contact_type',
+      'contact_id',
+    ];
+  };
+
+  /**
+   * Deposit amount attribute.
+   * @param transaction
+   * @returns
+   */
+  protected deposit = (transaction) => {
+    return transaction.debit;
+  };
+
+  /**
+   * Withdrawal amount attribute.
+   * @param transaction
+   * @returns
+   */
+  protected withdrawal = (transaction) => {
+    return transaction.credit;
+  };
+
+  /**
+   * Formatted withdrawal amount.
+   * @param transaction
+   * @returns
+   */
+  protected formattedWithdrawal = (transaction) => {
+    return formatNumber(transaction.credit, {
+      currencyCode: transaction.currencyCode,
+      excerptZero: true,
+    });
+  };
+
+  /**
+   * Formatted deposit account.
+   * @param transaction
+   * @returns
+   */
+  protected formattedDeposit = (transaction) => {
+    return formatNumber(transaction.debit, {
+      currencyCode: transaction.currencyCode,
+      excerptZero: true,
+    });
+  };
+}
diff --git a/packages/server/src/services/Cashflow/CashflowWithAccountSubscriber.ts b/packages/server/src/services/Cashflow/CashflowWithAccountSubscriber.ts
new file mode 100644
index 000000000..efa5100d1
--- /dev/null
+++ b/packages/server/src/services/Cashflow/CashflowWithAccountSubscriber.ts
@@ -0,0 +1,34 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { IAccountEventDeletePayload } from '@/interfaces';
+import CashflowDeleteAccount from './CashflowDeleteAccount';
+
+@Service()
+export default class CashflowWithAccountSubscriber {
+  @Inject()
+  cashflowDeleteAccount: CashflowDeleteAccount;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.accounts.onDelete,
+      this.validateAccountHasNoCashflowTransactionsOnDelete
+    );
+  };
+
+  /**
+   * Validate chart account has no associated cashflow transactions on delete.
+   * @param {IAccountEventDeletePayload} payload -
+   */
+  private validateAccountHasNoCashflowTransactionsOnDelete = async ({
+    tenantId,
+    oldAccount,
+  }: IAccountEventDeletePayload) => {
+    await this.cashflowDeleteAccount.validateAccountHasNoCashflowEntries(
+      tenantId,
+      oldAccount.id
+    );
+  };
+}
diff --git a/packages/server/src/services/Cashflow/CommandCasflowValidator.ts b/packages/server/src/services/Cashflow/CommandCasflowValidator.ts
new file mode 100644
index 000000000..81c0aaffb
--- /dev/null
+++ b/packages/server/src/services/Cashflow/CommandCasflowValidator.ts
@@ -0,0 +1,54 @@
+import { Service, Inject } from 'typedi';
+import { includes, difference, camelCase, upperFirst } from 'lodash';
+import { ACCOUNT_TYPE } from '@/data/AccountTypes';
+import { IAccount, ICashflowTransactionLine } from '@/interfaces';
+import { getCashflowTransactionType } from './utils';
+import { ServiceError } from '@/exceptions';
+import { CASHFLOW_TRANSACTION_TYPE, ERRORS } from './constants';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class CommandCashflowValidator {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Validates the lines accounts type should be cash or bank account.
+   * @param {IAccount} accounts -
+   */
+  public validateCreditAccountWithCashflowType = (
+    creditAccount: IAccount,
+    cashflowTransactionType: CASHFLOW_TRANSACTION_TYPE
+  ): void => {
+    const transactionTypeMeta = getCashflowTransactionType(
+      cashflowTransactionType
+    );
+    const noneCashflowAccount = !includes(
+      transactionTypeMeta.creditType,
+      creditAccount.accountType
+    );
+    if (noneCashflowAccount) {
+      throw new ServiceError(ERRORS.CREDIT_ACCOUNTS_HAS_INVALID_TYPE);
+    }
+  };
+
+  /**
+   * Validates the cashflow transaction type.
+   * @param   {string} transactionType
+   * @returns {string}
+   */
+  public validateCashflowTransactionType = (transactionType: string) => {
+    const transformedType = upperFirst(
+      camelCase(transactionType)
+    ) as CASHFLOW_TRANSACTION_TYPE;
+
+    // Retrieve the given transaction type meta.
+    const transactionTypeMeta = getCashflowTransactionType(transformedType);
+
+    // Throw service error in case not the found the given transaction type.
+    if (!transactionTypeMeta) {
+      throw new ServiceError(ERRORS.CASHFLOW_TRANSACTION_TYPE_INVALID);
+    }
+    return transformedType;
+  };
+}
diff --git a/packages/server/src/services/Cashflow/CommandCashflowTransaction.ts b/packages/server/src/services/Cashflow/CommandCashflowTransaction.ts
new file mode 100644
index 000000000..9a562e404
--- /dev/null
+++ b/packages/server/src/services/Cashflow/CommandCashflowTransaction.ts
@@ -0,0 +1,14 @@
+import { difference, includes } from 'lodash';
+import { ICashflowTransactionLine } from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import { Inject, Service } from 'typedi';
+import { CASHFLOW_TRANSACTION_TYPE, ERRORS } from './constants';
+import { IAccount } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export default class CommandCashflowTransaction {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+}
diff --git a/packages/server/src/services/Cashflow/DeleteCashflowTransactionService.ts b/packages/server/src/services/Cashflow/DeleteCashflowTransactionService.ts
new file mode 100644
index 000000000..e07073c3d
--- /dev/null
+++ b/packages/server/src/services/Cashflow/DeleteCashflowTransactionService.ts
@@ -0,0 +1,85 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import events from '@/subscribers/events';
+import {
+  ICashflowTransaction,
+  ICommandCashflowDeletedPayload,
+  ICommandCashflowDeletingPayload,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+@Service()
+export default class CommandCashflowTransactionService {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  /**
+   * Deletes the cashflow transaction with associated journal entries.
+   * @param {number} tenantId -
+   * @param {number} userId - User id.
+   */
+  public deleteCashflowTransaction = async (
+    tenantId: number,
+    cashflowTransactionId: number
+  ): Promise<{ oldCashflowTransaction: ICashflowTransaction }> => {
+    const { CashflowTransaction, CashflowTransactionLine } =
+      this.tenancy.models(tenantId);
+
+    // Retrieve the cashflow transaction.
+    const oldCashflowTransaction = await CashflowTransaction.query().findById(
+      cashflowTransactionId
+    );
+    // Throw not found error if the given transaction id not found.
+    this.throwErrorIfTransactionNotFound(oldCashflowTransaction);
+
+    // Starting database transaction.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onCashflowTransactionDelete` event.
+      await this.eventPublisher.emitAsync(events.cashflow.onTransactionDeleting, {
+        trx,
+        tenantId,
+        oldCashflowTransaction,
+      } as ICommandCashflowDeletingPayload);
+
+      // Delete cashflow transaction associated lines first.
+      await CashflowTransactionLine.query(trx)
+        .where('cashflow_transaction_id', cashflowTransactionId)
+        .delete();
+
+      // Delete cashflow transaction.
+      await CashflowTransaction.query(trx)
+        .findById(cashflowTransactionId)
+        .delete();
+
+      // Triggers `onCashflowTransactionDeleted` event.
+      await this.eventPublisher.emitAsync(events.cashflow.onTransactionDeleted, {
+        trx,
+        tenantId,
+        cashflowTransactionId,
+        oldCashflowTransaction,
+      } as ICommandCashflowDeletedPayload);
+
+      return { oldCashflowTransaction };
+    });
+  };
+
+  /**
+   * Throw not found error if the given transaction id not found.
+   * @param transaction
+   */
+  private throwErrorIfTransactionNotFound(transaction) {
+    if (!transaction) {
+      throw new ServiceError(ERRORS.CASHFLOW_TRANSACTION_NOT_FOUND);
+    }
+  }
+}
diff --git a/packages/server/src/services/Cashflow/GetCashflowAccountsService.ts b/packages/server/src/services/Cashflow/GetCashflowAccountsService.ts
new file mode 100644
index 000000000..65b3c50a1
--- /dev/null
+++ b/packages/server/src/services/Cashflow/GetCashflowAccountsService.ts
@@ -0,0 +1,54 @@
+import { Service, Inject } from 'typedi';
+import { ICashflowAccount, ICashflowAccountsFilter } from '@/interfaces';
+import { CashflowAccountTransformer } from './CashflowAccountTransformer';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export default class GetCashflowAccountsService {
+  @Inject()
+  private tenancy: TenancyService;
+
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the cash flow accounts.
+   * @param {number} tenantId - Tenant id.
+   * @param {ICashflowAccountsFilter} filterDTO - Filter DTO.
+   * @returns {ICashflowAccount[]}
+   */
+  public async getCashflowAccounts(
+    tenantId: number,
+    filterDTO: ICashflowAccountsFilter
+  ): Promise<{ cashflowAccounts: ICashflowAccount[] }> {
+    const { CashflowAccount } = this.tenancy.models(tenantId);
+
+    // Parsees accounts list filter DTO.
+    const filter = this.dynamicListService.parseStringifiedFilter(filterDTO);
+
+    // Dynamic list service.
+    const dynamicList = await this.dynamicListService.dynamicList(
+      tenantId,
+      CashflowAccount,
+      filter
+    );
+    // Retrieve accounts model based on the given query.
+    const accounts = await CashflowAccount.query().onBuild((builder) => {
+      dynamicList.buildQuery()(builder);
+
+      builder.whereIn('account_type', ['bank', 'cash']);
+      builder.modify('inactiveMode', filter.inactiveMode);
+    });
+    // Retrieves the transformed accounts.
+    return this.transformer.transform(
+      tenantId,
+      accounts,
+      new CashflowAccountTransformer()
+    );
+  }
+}
diff --git a/packages/server/src/services/Cashflow/GetCashflowTransactionsService.ts b/packages/server/src/services/Cashflow/GetCashflowTransactionsService.ts
new file mode 100644
index 000000000..eb22dd305
--- /dev/null
+++ b/packages/server/src/services/Cashflow/GetCashflowTransactionsService.ts
@@ -0,0 +1,61 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { CashflowTransactionTransformer } from './CashflowTransactionTransformer';
+import { ERRORS } from './constants';
+import { ICashflowTransaction } from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import I18nService from '@/services/I18n/I18nService';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export default class GetCashflowTransactionsService {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private i18nService: I18nService;
+
+  @Inject()
+  private transfromer: TransformerInjectable;
+
+  /**
+   * Retrieve the given cashflow transaction.
+   * @param {number} tenantId
+   * @param {number} cashflowTransactionId
+   * @returns
+   */
+  public getCashflowTransaction = async (
+    tenantId: number,
+    cashflowTransactionId: number
+  ) => {
+    const { CashflowTransaction } = this.tenancy.models(tenantId);
+
+    const cashflowTransaction = await CashflowTransaction.query()
+      .findById(cashflowTransactionId)
+      .withGraphFetched('entries.cashflowAccount')
+      .withGraphFetched('entries.creditAccount')
+      .withGraphFetched('transactions.account')
+      .throwIfNotFound();
+
+    this.throwErrorCashflowTranscationNotFound(cashflowTransaction);
+
+    // Transformes the cashflow transaction model to POJO.
+    return this.transfromer.transform(
+      tenantId,
+      cashflowTransaction,
+      new CashflowTransactionTransformer()
+    );
+  };
+
+  /**
+   * Throw not found error if the given cashflow undefined.
+   * @param {ICashflowTransaction} cashflowTransaction -
+   */
+  private throwErrorCashflowTranscationNotFound = (
+    cashflowTransaction: ICashflowTransaction
+  ) => {
+    if (!cashflowTransaction) {
+      throw new ServiceError(ERRORS.CASHFLOW_TRANSACTION_NOT_FOUND);
+    }
+  };
+}
diff --git a/packages/server/src/services/Cashflow/NewCashflowTransactionService.ts b/packages/server/src/services/Cashflow/NewCashflowTransactionService.ts
new file mode 100644
index 000000000..7c1c39d6f
--- /dev/null
+++ b/packages/server/src/services/Cashflow/NewCashflowTransactionService.ts
@@ -0,0 +1,180 @@
+import { Service, Inject } from 'typedi';
+import { isEmpty, pick } from 'lodash';
+import { Knex } from 'knex';
+import * as R from 'ramda';
+import {
+  ICashflowNewCommandDTO,
+  ICashflowTransaction,
+  ICashflowTransactionLine,
+  ICommandCashflowCreatedPayload,
+  ICommandCashflowCreatingPayload,
+  ICashflowTransactionInput,
+  IAccount,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { CASHFLOW_TRANSACTION_TYPE } from './constants';
+import { transformCashflowTransactionType } from './utils';
+import events from '@/subscribers/events';
+import { CommandCashflowValidator } from './CommandCasflowValidator';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import { CashflowTransactionAutoIncrement } from './CashflowTransactionAutoIncrement';
+import { BranchTransactionDTOTransform } from '@/services/Branches/Integrations/BranchTransactionDTOTransform';
+
+@Service()
+export default class NewCashflowTransactionService {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private validator: CommandCashflowValidator;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private autoIncrement: CashflowTransactionAutoIncrement;
+
+  @Inject()
+  private branchDTOTransform: BranchTransactionDTOTransform;
+
+  /**
+   * Authorize the cashflow creating transaction.
+   * @param {number} tenantId
+   * @param {ICashflowNewCommandDTO} newCashflowTransactionDTO
+   */
+  public authorize = async (
+    tenantId: number,
+    newCashflowTransactionDTO: ICashflowNewCommandDTO,
+    creditAccount: IAccount
+  ) => {
+    const transactionType = transformCashflowTransactionType(
+      newCashflowTransactionDTO.transactionType
+    );
+    // Validates the cashflow transaction type.
+    this.validator.validateCashflowTransactionType(transactionType);
+
+    // Retrieve accounts of the cashflow lines object.
+    this.validator.validateCreditAccountWithCashflowType(
+      creditAccount,
+      transactionType as CASHFLOW_TRANSACTION_TYPE
+    );
+  };
+
+  /**
+   * Transformes owner contribution DTO to cashflow transaction.
+   * @param {ICashflowNewCommandDTO} newCashflowTransactionDTO - New transaction DTO.
+   * @returns {ICashflowTransaction} - Cashflow transaction object.
+   */
+  private transformCashflowTransactionDTO = (
+    tenantId: number,
+    newCashflowTransactionDTO: ICashflowNewCommandDTO,
+    cashflowAccount: IAccount,
+    userId: number
+  ): ICashflowTransactionInput => {
+    const amount = newCashflowTransactionDTO.amount;
+
+    const fromDTO = pick(newCashflowTransactionDTO, [
+      'date',
+      'referenceNo',
+      'description',
+      'transactionType',
+      'exchangeRate',
+      'cashflowAccountId',
+      'creditAccountId',
+      'branchId',
+    ]);
+    // Retreive the next invoice number.
+    const autoNextNumber =
+      this.autoIncrement.getNextTransactionNumber(tenantId);
+
+    // Retrieve the transaction number.
+    const transactionNumber =
+      newCashflowTransactionDTO.transactionNumber || autoNextNumber;
+
+    const initialDTO = {
+      amount,
+      ...fromDTO,
+      transactionNumber,
+      currencyCode: cashflowAccount.currencyCode,
+      transactionType: transformCashflowTransactionType(
+        fromDTO.transactionType
+      ),
+      userId,
+      ...(newCashflowTransactionDTO.publish
+        ? {
+            publishedAt: new Date(),
+          }
+        : {}),
+    };
+    return R.compose(
+      this.branchDTOTransform.transformDTO<ICashflowTransactionInput>(tenantId)
+    )(initialDTO);
+  };
+
+  /**
+   * Owner contribution money in.
+   * @param {number} tenantId -
+   * @param {ICashflowOwnerContributionDTO} ownerContributionDTO
+   * @param {number} userId - User id.
+   */
+  public newCashflowTransaction = async (
+    tenantId: number,
+    newTransactionDTO: ICashflowNewCommandDTO,
+    userId: number
+  ): Promise<{ cashflowTransaction: ICashflowTransaction }> => {
+    const { CashflowTransaction, Account } = this.tenancy.models(tenantId);
+
+    // Retrieves the cashflow account or throw not found error.
+    const cashflowAccount = await Account.query()
+      .findById(newTransactionDTO.cashflowAccountId)
+      .throwIfNotFound();
+
+    // Retrieves the credit account or throw not found error.
+    const creditAccount = await Account.query()
+      .findById(newTransactionDTO.creditAccountId)
+      .throwIfNotFound();
+
+    // Authorize before creating cashflow transaction.
+    await this.authorize(tenantId, newTransactionDTO, creditAccount);
+
+    // Transformes owner contribution DTO to cashflow transaction.
+    const cashflowTransactionObj = this.transformCashflowTransactionDTO(
+      tenantId,
+      newTransactionDTO,
+      cashflowAccount,
+      userId
+    );
+    // Creates a new cashflow transaction under UOW envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onCashflowTransactionCreate` event.
+      await this.eventPublisher.emitAsync(
+        events.cashflow.onTransactionCreating,
+        {
+          trx,
+          tenantId,
+          newTransactionDTO,
+        } as ICommandCashflowCreatingPayload
+      );
+      // Inserts cashflow owner contribution transaction.
+      const cashflowTransaction = await CashflowTransaction.query(
+        trx
+      ).upsertGraph(cashflowTransactionObj);
+
+      // Triggers `onCashflowTransactionCreated` event.
+      await this.eventPublisher.emitAsync(
+        events.cashflow.onTransactionCreated,
+        {
+          tenantId,
+          newTransactionDTO,
+          cashflowTransaction,
+          trx,
+        } as ICommandCashflowCreatedPayload
+      );
+      return { cashflowTransaction };
+    });
+  };
+}
diff --git a/packages/server/src/services/Cashflow/constants.ts b/packages/server/src/services/Cashflow/constants.ts
new file mode 100644
index 000000000..2e664a519
--- /dev/null
+++ b/packages/server/src/services/Cashflow/constants.ts
@@ -0,0 +1,73 @@
+import { ACCOUNT_TYPE } from '@/data/AccountTypes';
+
+export const ERRORS = {
+  CASHFLOW_TRANSACTION_TYPE_INVALID: 'CASHFLOW_TRANSACTION_TYPE_INVALID',
+  CASHFLOW_ACCOUNTS_HAS_INVALID_TYPE: 'CASHFLOW_ACCOUNTS_HAS_INVALID_TYPE',
+  CASHFLOW_TRANSACTION_NOT_FOUND: 'CASHFLOW_TRANSACTION_NOT_FOUND',
+  CASHFLOW_ACCOUNTS_IDS_NOT_FOUND: 'CASHFLOW_ACCOUNTS_IDS_NOT_FOUND',
+  CREDIT_ACCOUNTS_IDS_NOT_FOUND: 'CREDIT_ACCOUNTS_IDS_NOT_FOUND',
+  CREDIT_ACCOUNTS_HAS_INVALID_TYPE: 'CREDIT_ACCOUNTS_HAS_INVALID_TYPE',
+  ACCOUNT_ID_HAS_INVALID_TYPE: 'ACCOUNT_ID_HAS_INVALID_TYPE',
+  ACCOUNT_HAS_ASSOCIATED_TRANSACTIONS: 'account_has_associated_transactions'
+};
+
+export enum CASHFLOW_DIRECTION {
+  IN = 'In',
+  OUT = 'Out',
+}
+
+export enum CASHFLOW_TRANSACTION_TYPE {
+  ONWERS_DRAWING = 'OwnerDrawing',
+  OWNER_CONTRIBUTION = 'OwnerContribution',
+  OTHER_INCOME = 'OtherIncome',
+  TRANSFER_FROM_ACCOUNT = 'TransferFromAccount',
+  TRANSFER_TO_ACCOUNT = 'TransferToAccount',
+  OTHER_EXPENSE = 'OtherExpense',
+}
+
+export const CASHFLOW_TRANSACTION_TYPE_META = {
+  [`${CASHFLOW_TRANSACTION_TYPE.ONWERS_DRAWING}`]: {
+    type: 'OwnerDrawing',
+    direction: CASHFLOW_DIRECTION.OUT,
+    creditType: [ACCOUNT_TYPE.EQUITY],
+  },
+  [`${CASHFLOW_TRANSACTION_TYPE.OWNER_CONTRIBUTION}`]: {
+    type: 'OwnerContribution',
+    direction: CASHFLOW_DIRECTION.IN,
+    creditType: [ACCOUNT_TYPE.EQUITY],
+  },
+  [`${CASHFLOW_TRANSACTION_TYPE.OTHER_INCOME}`]: {
+    type: 'OtherIncome',
+    direction: CASHFLOW_DIRECTION.IN,
+    creditType: [ACCOUNT_TYPE.INCOME, ACCOUNT_TYPE.OTHER_INCOME],
+  },
+  [`${CASHFLOW_TRANSACTION_TYPE.TRANSFER_FROM_ACCOUNT}`]: {
+    type: 'TransferFromAccount',
+    direction: CASHFLOW_DIRECTION.IN,
+    creditType: [
+      ACCOUNT_TYPE.CASH,
+      ACCOUNT_TYPE.BANK,
+      ACCOUNT_TYPE.CREDIT_CARD,
+    ],
+  },
+  [`${CASHFLOW_TRANSACTION_TYPE.TRANSFER_TO_ACCOUNT}`]: {
+    type: 'TransferToAccount',
+    direction: CASHFLOW_DIRECTION.OUT,
+    creditType: [
+      ACCOUNT_TYPE.CASH,
+      ACCOUNT_TYPE.BANK,
+      ACCOUNT_TYPE.CREDIT_CARD,
+    ],
+  },
+  [`${CASHFLOW_TRANSACTION_TYPE.OTHER_EXPENSE}`]: {
+    type: 'OtherExpense',
+    direction: CASHFLOW_DIRECTION.OUT,
+    creditType: [ACCOUNT_TYPE.EXPENSE, ACCOUNT_TYPE.OTHER_EXPENSE],
+  },
+};
+
+export interface ICashflowTransactionTypeMeta {
+  type: string;
+  direction: CASHFLOW_DIRECTION;
+  creditType: string[];
+}
diff --git a/packages/server/src/services/Cashflow/utils.ts b/packages/server/src/services/Cashflow/utils.ts
new file mode 100644
index 000000000..f9cb1ad6b
--- /dev/null
+++ b/packages/server/src/services/Cashflow/utils.ts
@@ -0,0 +1,34 @@
+import { upperFirst, camelCase } from 'lodash';
+import {
+  CASHFLOW_TRANSACTION_TYPE,
+  CASHFLOW_TRANSACTION_TYPE_META,
+  ICashflowTransactionTypeMeta,
+} from './constants';
+
+/**
+ * Ensures the given transaction type to transformed to properiate format.
+ * @param {string} type 
+ * @returns {string}
+ */
+export const transformCashflowTransactionType = (type) => {
+  return upperFirst(camelCase(type));
+};
+
+/**
+ * Retrieve the cashflow transaction type meta.
+ * @param {CASHFLOW_TRANSACTION_TYPE} transactionType
+ * @returns {ICashflowTransactionTypeMeta}
+ */
+export function getCashflowTransactionType(
+  transactionType: CASHFLOW_TRANSACTION_TYPE
+): ICashflowTransactionTypeMeta {
+  return CASHFLOW_TRANSACTION_TYPE_META[transactionType];
+}
+
+/**
+ * Retrieve cashflow accounts transactions types
+ * @returns {string}
+ */
+export const getCashflowAccountTransactionsTypes = () => {
+  return Object.values(CASHFLOW_TRANSACTION_TYPE_META).map((meta) => meta.type);
+};
diff --git a/packages/server/src/services/Contacts/ContactTransformer.ts b/packages/server/src/services/Contacts/ContactTransformer.ts
new file mode 100644
index 000000000..ceaeeec6c
--- /dev/null
+++ b/packages/server/src/services/Contacts/ContactTransformer.ts
@@ -0,0 +1,41 @@
+import { isNull } from 'lodash';
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+import { IContact } from '@/interfaces';
+
+export default class ContactTransfromer extends Transformer {
+  /**
+   * Retrieve formatted expense amount.
+   * @param {IExpense} expense
+   * @returns {string}
+   */
+  protected formattedBalance = (contact: IContact): string => {
+    return formatNumber(contact.balance, {
+      currencyCode: contact.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve formatted expense landed cost amount.
+   * @param {IExpense} expense
+   * @returns {string}
+   */
+  protected formattedOpeningBalance = (contact: IContact): string => {
+    return !isNull(contact.openingBalance)
+      ? formatNumber(contact.openingBalance, {
+          currencyCode: contact.currencyCode,
+        })
+      : '';
+  };
+
+  /**
+   * Retriecve fromatted date.
+   * @param {IExpense} expense
+   * @returns {string}
+   */
+  protected formattedOpeningBalanceAt = (contact: IContact): string => {
+    return !isNull(contact.openingBalanceAt)
+      ? this.formatDate(contact.openingBalanceAt)
+      : '';
+  };
+}
diff --git a/packages/server/src/services/Contacts/ContactsService.ts b/packages/server/src/services/Contacts/ContactsService.ts
new file mode 100644
index 000000000..a71d57b5b
--- /dev/null
+++ b/packages/server/src/services/Contacts/ContactsService.ts
@@ -0,0 +1,378 @@
+import { Inject, Service } from 'typedi';
+import { difference, upperFirst, omit } from 'lodash';
+import moment from 'moment';
+import * as R from 'ramda';
+import { Knex } from 'knex';
+import { ServiceError } from '@/exceptions';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import {
+  IContact,
+  IContactNewDTO,
+  IContactEditDTO,
+  IContactsAutoCompleteFilter,
+} from '@/interfaces';
+import JournalPoster from '../Accounting/JournalPoster';
+import { ERRORS } from './constants';
+
+type TContactService = 'customer' | 'vendor';
+
+@Service()
+export default class ContactsService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  @Inject('logger')
+  logger: any;
+
+  /**
+   * Get the given contact or throw not found contact.
+   * @param {number} tenantId
+   * @param {number} contactId
+   * @param {TContactService} contactService
+   * @return {Promise<IContact>}
+   */
+  public async getContactByIdOrThrowError(
+    tenantId: number,
+    contactId: number,
+    contactService?: TContactService
+  ) {
+    const { contactRepository } = this.tenancy.repositories(tenantId);
+
+    const contact = await contactRepository.findOne({
+      id: contactId,
+      ...(contactService && { contactService }),
+    });
+
+    if (!contact) {
+      throw new ServiceError('contact_not_found');
+    }
+    return contact;
+  }
+
+  /**
+   * Converts contact DTO object to model object attributes to insert or update.
+   * @param {IContactNewDTO | IContactEditDTO} contactDTO
+   */
+  private commonTransformContactObj(
+    contactDTO: IContactNewDTO | IContactEditDTO
+  ) {
+    return {
+      ...omit(contactDTO, [
+        'billingAddress1',
+        'billingAddress2',
+        'shippingAddress1',
+        'shippingAddress2',
+      ]),
+      billing_address_1: contactDTO?.billingAddress1,
+      billing_address_2: contactDTO?.billingAddress2,
+      shipping_address_1: contactDTO?.shippingAddress1,
+      shipping_address_2: contactDTO?.shippingAddress2,
+    };
+  }
+
+  /**
+   * Transforms contact new DTO object to model object to insert to the storage.
+   * @param {IContactNewDTO} contactDTO
+   */
+  private transformNewContactDTO(contactDTO: IContactNewDTO) {
+    const baseCurrency = 'USD';
+    const currencyCode =
+      typeof contactDTO.currencyCode !== 'undefined'
+        ? contactDTO.currencyCode
+        : baseCurrency;
+
+    return {
+      ...this.commonTransformContactObj(contactDTO),
+      ...(currencyCode ? { currencyCode } : {}),
+    };
+  }
+
+  /**
+   * Transforms contact edit DTO object to model object to update to the storage.
+   * @param {IContactEditDTO} contactDTO
+   */
+  private transformEditContactDTO(contactDTO: IContactEditDTO) {
+    return {
+      ...this.commonTransformContactObj(contactDTO),
+    };
+  }
+
+  /**
+   * Creates a new contact on the storage.
+   * @param {number} tenantId
+   * @param {TContactService} contactService
+   * @param {IContactDTO} contactDTO
+   */
+  async newContact(
+    tenantId: number,
+    contactDTO: IContactNewDTO,
+    contactService: TContactService,
+    trx?: Knex.Transaction
+  ) {
+    const { contactRepository } = this.tenancy.repositories(tenantId);
+    const contactObj = this.transformNewContactDTO(contactDTO);
+
+    const contact = await contactRepository.create(
+      {
+        contactService,
+        ...contactObj,
+      },
+      trx
+    );
+    return contact;
+  }
+
+  /**
+   * Edit details of the given on the storage.
+   * @param {number} tenantId
+   * @param {number} contactId
+   * @param {TContactService} contactService
+   * @param {IContactDTO} contactDTO
+   */
+  async editContact(
+    tenantId: number,
+    contactId: number,
+    contactDTO: IContactEditDTO,
+    contactService: TContactService,
+    trx?: Knex.Transaction
+  ) {
+    const { contactRepository } = this.tenancy.repositories(tenantId);
+    const contactObj = this.transformEditContactDTO(contactDTO);
+
+    // Retrieve the given contact by id or throw not found service error.
+    const contact = await this.getContactByIdOrThrowError(
+      tenantId,
+      contactId,
+      contactService
+    );
+    return contactRepository.update({ ...contactObj }, { id: contactId }, trx);
+  }
+
+  /**
+   * Deletes the given contact from the storage.
+   * @param {number} tenantId
+   * @param {number} contactId
+   * @param {TContactService} contactService
+   * @return {Promise<void>}
+   */
+  async deleteContact(
+    tenantId: number,
+    contactId: number,
+    contactService: TContactService,
+    trx?: Knex.Transaction
+  ) {
+    const { contactRepository } = this.tenancy.repositories(tenantId);
+
+    const contact = await this.getContactByIdOrThrowError(
+      tenantId,
+      contactId,
+      contactService
+    );
+    // Deletes contact of the given id.
+    await contactRepository.deleteById(contactId, trx);
+  }
+
+  /**
+   * Get contact details of the given contact id.
+   * @param {number} tenantId
+   * @param {number} contactId
+   * @param {TContactService} contactService
+   * @returns {Promise<IContact>}
+   */
+  async getContact(
+    tenantId: number,
+    contactId: number,
+    contactService?: TContactService
+  ) {
+    return this.getContactByIdOrThrowError(tenantId, contactId, contactService);
+  }
+
+  /**
+   * Parsees accounts list filter DTO.
+   * @param filterDTO
+   */
+  private parseAutocompleteListFilterDTO(filterDTO) {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  }
+
+  /**
+   * Retrieve auto-complete contacts list.
+   * @param {number} tenantId -
+   * @param {IContactsAutoCompleteFilter} contactsFilter -
+   * @return {IContactAutoCompleteItem}
+   */
+  async autocompleteContacts(
+    tenantId: number,
+    query: IContactsAutoCompleteFilter
+  ) {
+    const { Contact } = this.tenancy.models(tenantId);
+
+    // Parses auto-complete list filter DTO.
+    const filter = this.parseAutocompleteListFilterDTO(query);
+
+    // Dynamic list.
+    // const dynamicList = await this.dynamicListService.dynamicList(
+    //   tenantId,
+    //   Contact,
+    //   filter
+    // );
+    // Retrieve contacts list by the given query.
+    const contacts = await Contact.query().onBuild((builder) => {
+      if (filter.keyword) {
+        builder.where('display_name', 'LIKE', `%${filter.keyword}%`);
+      }
+      // dynamicList.buildQuery()(builder);
+      builder.limit(filter.limit);
+    });
+    return contacts;
+  }
+
+  /**
+   * Retrieve contacts or throw not found error if one of ids were not found
+   * on the storage.
+   * @param {number} tenantId
+   * @param {number[]} contactsIds
+   * @param {TContactService} contactService
+   * @return {Promise<IContact>}
+   */
+  async getContactsOrThrowErrorNotFound(
+    tenantId: number,
+    contactsIds: number[],
+    contactService: TContactService
+  ) {
+    const { Contact } = this.tenancy.models(tenantId);
+    const contacts = await Contact.query()
+      .whereIn('id', contactsIds)
+      .where('contact_service', contactService);
+
+    const storedContactsIds = contacts.map((contact: IContact) => contact.id);
+    const notFoundCustomers = difference(contactsIds, storedContactsIds);
+
+    if (notFoundCustomers.length > 0) {
+      throw new ServiceError('contacts_not_found');
+    }
+    return contacts;
+  }
+
+  /**
+   * Deletes the given contacts in bulk.
+   * @param  {number} tenantId
+   * @param  {number[]} contactsIds
+   * @param  {TContactService} contactService
+   * @return {Promise<void>}
+   */
+  async deleteBulkContacts(
+    tenantId: number,
+    contactsIds: number[],
+    contactService: TContactService
+  ) {
+    const { contactRepository } = this.tenancy.repositories(tenantId);
+
+    // Retrieve the given contacts or throw not found service error.
+    this.getContactsOrThrowErrorNotFound(tenantId, contactsIds, contactService);
+
+    await contactRepository.deleteWhereIdIn(contactsIds);
+  }
+
+  /**
+   * Reverts journal entries of the given contacts.
+   * @param {number} tenantId
+   * @param {number[]} contactsIds
+   * @param {TContactService} contactService
+   */
+  async revertJEntriesContactsOpeningBalance(
+    tenantId: number,
+    contactsIds: number[],
+    contactService: TContactService,
+    trx?: Knex.Transaction
+  ) {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+    const journal = new JournalPoster(tenantId, null, trx);
+
+    // Loads the contact opening balance journal transactions.
+    const contactsTransactions = await AccountTransaction.query()
+      .whereIn('reference_id', contactsIds)
+      .where('reference_type', `${upperFirst(contactService)}OpeningBalance`);
+
+    journal.fromTransactions(contactsTransactions);
+    journal.removeEntries();
+
+    await Promise.all([journal.saveBalance(), journal.deleteEntries()]);
+  }
+
+  /**
+   * Chanages the opening balance of the given contact.
+   * @param {number} tenantId
+   * @param {number} contactId
+   * @param {ICustomerChangeOpeningBalanceDTO} changeOpeningBalance
+   * @return {Promise<void>}
+   */
+  public async changeOpeningBalance(
+    tenantId: number,
+    contactId: number,
+    contactService: string,
+    openingBalance: number,
+    openingBalanceAt?: Date | string
+  ): Promise<void> {
+    const { contactRepository } = this.tenancy.repositories(tenantId);
+
+    // Retrieve the given contact details or throw not found service error.
+    const contact = await this.getContactByIdOrThrowError(
+      tenantId,
+      contactId,
+      contactService
+    );
+    // Should the opening balance date be required.
+    if (!contact.openingBalanceAt && !openingBalanceAt) {
+      throw new ServiceError(ERRORS.OPENING_BALANCE_DATE_REQUIRED);
+    }
+    // Changes the customer the opening balance and opening balance date.
+    await contactRepository.update(
+      {
+        openingBalance: openingBalance,
+
+        ...(openingBalanceAt && {
+          openingBalanceAt: moment(openingBalanceAt).toMySqlDateTime(),
+        }),
+      },
+      {
+        id: contactId,
+        contactService,
+      }
+    );
+  }
+
+  /**
+   * Inactive the given contact.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} contactId - Contact id.
+   */
+  async inactivateContact(tenantId: number, contactId: number): Promise<void> {
+    const { Contact } = this.tenancy.models(tenantId);
+    const contact = await this.getContactByIdOrThrowError(tenantId, contactId);
+
+    if (!contact.active) {
+      throw new ServiceError(ERRORS.CONTACT_ALREADY_INACTIVE);
+    }
+    await Contact.query().findById(contactId).update({ active: false });
+  }
+
+  /**
+   * Inactive the given contact.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} contactId - Contact id.
+   */
+  async activateContact(tenantId: number, contactId: number): Promise<void> {
+    const { Contact } = this.tenancy.models(tenantId);
+    const contact = await this.getContactByIdOrThrowError(tenantId, contactId);
+
+    if (contact.active) {
+      throw new ServiceError(ERRORS.CONTACT_ALREADY_ACTIVE);
+    }
+    await Contact.query().findById(contactId).update({ active: true });
+  }
+}
diff --git a/packages/server/src/services/Contacts/Customers/CRUD/ActivateCustomer.ts b/packages/server/src/services/Contacts/Customers/CRUD/ActivateCustomer.ts
new file mode 100644
index 000000000..d87ef42cf
--- /dev/null
+++ b/packages/server/src/services/Contacts/Customers/CRUD/ActivateCustomer.ts
@@ -0,0 +1,70 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import { CustomerValidators } from './CustomerValidators';
+import {
+  ICustomerActivatingPayload,
+  ICustomerActivatedPayload,
+} from '@/interfaces';
+
+@Service()
+export class ActivateCustomer {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private validators: CustomerValidators;
+
+  /**
+   * Inactive the given contact.
+   * @param   {number} tenantId - Tenant id.
+   * @param   {number} contactId - Contact id.
+   * @returns {Promise<void>}
+   */
+  public async activateCustomer(
+    tenantId: number,
+    customerId: number
+  ): Promise<void> {
+    const { Contact } = this.tenancy.models(tenantId);
+
+    // Retrieves the customer or throw not found error.
+    const oldCustomer = await Contact.query()
+      .findById(customerId)
+      .modify('customer')
+      .throwIfNotFound();
+
+    this.validators.validateNotAlreadyPublished(oldCustomer);
+
+    // Edits the given customer with associated transactions on unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onCustomerActivating` event.
+      await this.eventPublisher.emitAsync(events.customers.onActivating, {
+        tenantId,
+        trx,
+        oldCustomer,
+      } as ICustomerActivatingPayload);
+
+      // Update the given customer details.
+      const customer = await Contact.query(trx)
+        .findById(customerId)
+        .update({ active: true });
+
+      // Triggers `onCustomerActivated` event.
+      await this.eventPublisher.emitAsync(events.customers.onActivated, {
+        tenantId,
+        trx,
+        oldCustomer,
+        customer,
+      } as ICustomerActivatedPayload);
+    });
+  }
+}
diff --git a/packages/server/src/services/Contacts/Customers/CRUD/CreateCustomer.ts b/packages/server/src/services/Contacts/Customers/CRUD/CreateCustomer.ts
new file mode 100644
index 000000000..0465ecd5f
--- /dev/null
+++ b/packages/server/src/services/Contacts/Customers/CRUD/CreateCustomer.ts
@@ -0,0 +1,73 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import {
+  ICustomer,
+  ICustomerEventCreatedPayload,
+  ICustomerEventCreatingPayload,
+  ICustomerNewDTO,
+  ISystemUser,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import { CreateEditCustomerDTO } from './CreateEditCustomerDTO';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class CreateCustomer {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private customerDTO: CreateEditCustomerDTO;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Creates a new customer.
+   * @param  {number} tenantId
+   * @param  {ICustomerNewDTO} customerDTO
+   * @return {Promise<ICustomer>}
+   */
+  public async createCustomer(
+    tenantId: number,
+    customerDTO: ICustomerNewDTO,
+    authorizedUser: ISystemUser
+  ): Promise<ICustomer> {
+    const { Contact } = this.tenancy.models(tenantId);
+
+    // Transformes the customer DTO to customer object.
+    const customerObj = await this.customerDTO.transformCreateDTO(
+      tenantId,
+      customerDTO
+    );
+    // Creates a new customer under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onCustomerCreating` event.
+      await this.eventPublisher.emitAsync(events.customers.onCreating, {
+        tenantId,
+        customerDTO,
+        trx,
+      } as ICustomerEventCreatingPayload);
+
+      // Creates a new contact as customer.
+      const customer = await Contact.query().insertAndFetch({
+        ...customerObj,
+      });
+      // Triggers `onCustomerCreated` event.
+      await this.eventPublisher.emitAsync(events.customers.onCreated, {
+        customer,
+        tenantId,
+        customerId: customer.id,
+        authorizedUser,
+        trx,
+      } as ICustomerEventCreatedPayload);
+
+      return customer;
+    });
+  }
+}
diff --git a/packages/server/src/services/Contacts/Customers/CRUD/CreateEditCustomerDTO.ts b/packages/server/src/services/Contacts/Customers/CRUD/CreateEditCustomerDTO.ts
new file mode 100644
index 000000000..cdf8f8639
--- /dev/null
+++ b/packages/server/src/services/Contacts/Customers/CRUD/CreateEditCustomerDTO.ts
@@ -0,0 +1,69 @@
+import moment from 'moment';
+import { defaultTo, omit, isEmpty } from 'lodash';
+import { Service, Inject } from 'typedi';
+import {
+  ContactService,
+  ICustomer,
+  ICustomerEditDTO,
+  ICustomerNewDTO,
+} from '@/interfaces';
+import { TenantMetadata } from '@/system/models';
+
+@Service()
+export class CreateEditCustomerDTO {
+  /**
+   * Transformes the create/edit DTO.
+   * @param   {ICustomerNewDTO | ICustomerEditDTO} customerDTO
+   * @returns
+   */
+  private transformCommonDTO = (
+    customerDTO: ICustomerNewDTO | ICustomerEditDTO
+  ): Partial<ICustomer> => {
+    return {
+      ...omit(customerDTO, ['customerType']),
+      contactType: customerDTO.customerType,
+    };
+  };
+
+  /**
+   * Transformes the create DTO.
+   * @param   {ICustomerNewDTO} customerDTO
+   * @returns {}
+   */
+  public transformCreateDTO = async (
+    tenantId: number,
+    customerDTO: ICustomerNewDTO
+  ) => {
+    const commonDTO = this.transformCommonDTO(customerDTO);
+
+    // Retrieves the tenant metadata.
+    const tenantMeta = await TenantMetadata.query().findOne({ tenantId });
+
+    return {
+      ...commonDTO,
+      currencyCode: commonDTO.currencyCode || tenantMeta?.baseCurrency,
+      active: defaultTo(customerDTO.active, true),
+      contactService: ContactService.Customer,
+      ...(!isEmpty(customerDTO.openingBalanceAt)
+        ? {
+            openingBalanceAt: moment(
+              customerDTO?.openingBalanceAt
+            ).toMySqlDateTime(),
+          }
+        : {}),
+    };
+  };
+
+  /**
+   * Transformes the edit DTO.
+   * @param   {ICustomerEditDTO} customerDTO
+   * @returns
+   */
+  public transformEditDTO = (customerDTO: ICustomerEditDTO) => {
+    const commonDTO = this.transformCommonDTO(customerDTO);
+
+    return {
+      ...commonDTO,
+    };
+  };
+}
diff --git a/packages/server/src/services/Contacts/Customers/CRUD/CustomerValidators.ts b/packages/server/src/services/Contacts/Customers/CRUD/CustomerValidators.ts
new file mode 100644
index 000000000..81bde6ebb
--- /dev/null
+++ b/packages/server/src/services/Contacts/Customers/CRUD/CustomerValidators.ts
@@ -0,0 +1,16 @@
+import { ServiceError } from '@/exceptions';
+import { Service, Inject } from 'typedi';
+import { ERRORS } from '../constants';
+
+@Service()
+export class CustomerValidators {
+  /**
+   * Validates the given customer is not already published.
+   * @param {ICustomer} customer
+   */
+  public validateNotAlreadyPublished = (customer) => {
+    if (customer.active) {
+      throw new ServiceError(ERRORS.CUSTOMER_ALREADY_ACTIVE);
+    }
+  };
+}
diff --git a/packages/server/src/services/Contacts/Customers/CRUD/DeleteCustomer.ts b/packages/server/src/services/Contacts/Customers/CRUD/DeleteCustomer.ts
new file mode 100644
index 000000000..ad4f197de
--- /dev/null
+++ b/packages/server/src/services/Contacts/Customers/CRUD/DeleteCustomer.ts
@@ -0,0 +1,69 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import {
+  ICustomerDeletingPayload,
+  ICustomerEventDeletedPayload,
+  ISystemUser,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ERRORS } from '../constants';
+
+@Service()
+export class DeleteCustomer {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Deletes the given customer from the storage.
+   * @param {number} tenantId
+   * @param {number} customerId
+   * @return {Promise<void>}
+   */
+  public async deleteCustomer(
+    tenantId: number,
+    customerId: number,
+    authorizedUser: ISystemUser
+  ): Promise<void> {
+    const { Contact } = this.tenancy.models(tenantId);
+
+    // Retrieve the customer of throw not found service error.
+    const oldCustomer = await Contact.query()
+      .findById(customerId)
+      .modify('customer')
+      .throwIfNotFound()
+      .queryAndThrowIfHasRelations({
+        type: ERRORS.CUSTOMER_HAS_TRANSACTIONS,
+      });
+
+    // Triggers `onCustomerDeleting` event.
+    await this.eventPublisher.emitAsync(events.customers.onDeleting, {
+      tenantId,
+      customerId,
+      oldCustomer,
+    } as ICustomerDeletingPayload);
+
+    // Deletes the customer and associated entities under UOW transaction.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Delete the customer from the storage.
+      await Contact.query(trx).findById(customerId).delete();
+
+      // Throws `onCustomerDeleted` event.
+      await this.eventPublisher.emitAsync(events.customers.onDeleted, {
+        tenantId,
+        customerId,
+        oldCustomer,
+        authorizedUser,
+        trx,
+      } as ICustomerEventDeletedPayload);
+    });
+  }
+}
diff --git a/packages/server/src/services/Contacts/Customers/CRUD/EditCustomer.ts b/packages/server/src/services/Contacts/Customers/CRUD/EditCustomer.ts
new file mode 100644
index 000000000..0b46936e1
--- /dev/null
+++ b/packages/server/src/services/Contacts/Customers/CRUD/EditCustomer.ts
@@ -0,0 +1,77 @@
+import { Knex } from 'knex';
+import {
+  ICustomer,
+  ICustomerEditDTO,
+  ICustomerEventEditedPayload,
+  ICustomerEventEditingPayload,
+  ISystemUser,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { CreateEditCustomerDTO } from './CreateEditCustomerDTO';
+
+@Service()
+export class EditCustomer {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private customerDTO: CreateEditCustomerDTO;
+
+  /**
+   * Edits details of the given customer.
+   * @param {number} tenantId
+   * @param {number} customerId
+   * @param {ICustomerEditDTO} customerDTO
+   * @return {Promise<ICustomer>}
+   */
+  public async editCustomer(
+    tenantId: number,
+    customerId: number,
+    customerDTO: ICustomerEditDTO
+  ): Promise<ICustomer> {
+    const { Contact } = this.tenancy.models(tenantId);
+
+    // Retrieve the vendor or throw not found error.
+    const oldCustomer = await Contact.query()
+      .findById(customerId)
+      .modify('customer')
+      .throwIfNotFound();
+
+    // Transformes the given customer DTO to object.
+    const customerObj = this.customerDTO.transformEditDTO(customerDTO);
+
+    // Edits the given customer under unit-of-work evnirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onCustomerEditing` event.
+      await this.eventPublisher.emitAsync(events.customers.onEditing, {
+        tenantId,
+        customerDTO,
+        customerId,
+        trx,
+      } as ICustomerEventEditingPayload);
+
+      // Edits the customer details on the storage.
+      const customer = await Contact.query().updateAndFetchById(customerId, {
+        ...customerObj,
+      });
+      // Triggers `onCustomerEdited` event.
+      await this.eventPublisher.emitAsync(events.customers.onEdited, {
+        customerId,
+        customer,
+        trx,
+      } as ICustomerEventEditedPayload);
+
+      return customer;
+    });
+  }
+}
diff --git a/packages/server/src/services/Contacts/Customers/CRUD/EditOpeningBalanceCustomer.ts b/packages/server/src/services/Contacts/Customers/CRUD/EditOpeningBalanceCustomer.ts
new file mode 100644
index 000000000..c8145d6c9
--- /dev/null
+++ b/packages/server/src/services/Contacts/Customers/CRUD/EditOpeningBalanceCustomer.ts
@@ -0,0 +1,74 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import {
+  ICustomer,
+  ICustomerOpeningBalanceEditDTO,
+  ICustomerOpeningBalanceEditedPayload,
+  ICustomerOpeningBalanceEditingPayload,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+
+@Service()
+export class EditOpeningBalanceCustomer {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  /**
+   * Changes the opening balance of the given customer.
+   * @param {number} tenantId
+   * @param {number} customerId
+   * @param {number} openingBalance
+   * @param {string|Date} openingBalanceAt
+   */
+  public async changeOpeningBalance(
+    tenantId: number,
+    customerId: number,
+    openingBalanceEditDTO: ICustomerOpeningBalanceEditDTO
+  ): Promise<ICustomer> {
+    const { Customer } = this.tenancy.models(tenantId);
+
+    // Retrieves the old customer or throw not found error.
+    const oldCustomer = await Customer.query()
+      .findById(customerId)
+      .throwIfNotFound();
+
+    // Mutates the customer opening balance under unit-of-work.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onCustomerOpeningBalanceChanging` event.
+      await this.eventPublisher.emitAsync(
+        events.customers.onOpeningBalanceChanging,
+        {
+          tenantId,
+          oldCustomer,
+          openingBalanceEditDTO,
+          trx,
+        } as ICustomerOpeningBalanceEditingPayload
+      );
+      // Mutates the customer on the storage.
+      const customer = await Customer.query().patchAndFetchById(customerId, {
+        ...openingBalanceEditDTO,
+      });
+      // Triggers `onCustomerOpeingBalanceChanged` event.
+      await this.eventPublisher.emitAsync(
+        events.customers.onOpeningBalanceChanged,
+        {
+          tenantId,
+          customer,
+          oldCustomer,
+          openingBalanceEditDTO,
+          trx,
+        } as ICustomerOpeningBalanceEditedPayload
+      );
+      return customer;
+    });
+  }
+}
diff --git a/packages/server/src/services/Contacts/Customers/CRUD/GetCustomer.ts b/packages/server/src/services/Contacts/Customers/CRUD/GetCustomer.ts
new file mode 100644
index 000000000..47d7e08c8
--- /dev/null
+++ b/packages/server/src/services/Contacts/Customers/CRUD/GetCustomer.ts
@@ -0,0 +1,36 @@
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import I18nService from '@/services/I18n/I18nService';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Service, Inject } from 'typedi';
+import CustomerTransfromer from '../CustomerTransformer';
+
+@Service()
+export class GetCustomer {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the given customer details.
+   * @param {number} tenantId
+   * @param {number} customerId
+   */
+  public async getCustomer(tenantId: number, customerId: number) {
+    const { Contact } = this.tenancy.models(tenantId);
+
+    // Retrieve the customer model or throw not found error.
+    const customer = await Contact.query()
+      .modify('customer')
+      .findById(customerId)
+      .throwIfNotFound();
+
+    // Retrieves the transformered customers.
+    return this.transformer.transform(
+      tenantId,
+      customer,
+      new CustomerTransfromer()
+    );
+  }
+}
diff --git a/packages/server/src/services/Contacts/Customers/CRUD/GetCustomers.ts b/packages/server/src/services/Contacts/Customers/CRUD/GetCustomers.ts
new file mode 100644
index 000000000..569207871
--- /dev/null
+++ b/packages/server/src/services/Contacts/Customers/CRUD/GetCustomers.ts
@@ -0,0 +1,77 @@
+import { Inject, Service } from 'typedi';
+import * as R from 'ramda';
+import {
+  ICustomer,
+  ICustomersFilter,
+  IFilterMeta,
+  IPaginationMeta,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import CustomerTransfromer from '../CustomerTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export class GetCustomers {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Parses customers list filter DTO.
+   * @param filterDTO -
+   */
+  private parseCustomersListFilterDTO(filterDTO) {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  }
+
+  /**
+   * Retrieve customers paginated list.
+   * @param {number} tenantId - Tenant id.
+   * @param {ICustomersFilter} filter - Cusotmers filter.
+   */
+  public async getCustomersList(
+    tenantId: number,
+    filterDTO: ICustomersFilter
+  ): Promise<{
+    customers: ICustomer[];
+    pagination: IPaginationMeta;
+    filterMeta: IFilterMeta;
+  }> {
+    const { Customer } = this.tenancy.models(tenantId);
+
+    // Parses customers list filter DTO.
+    const filter = this.parseCustomersListFilterDTO(filterDTO);
+
+    // Dynamic list.
+    const dynamicList = await this.dynamicListService.dynamicList(
+      tenantId,
+      Customer,
+      filter
+    );
+    // Customers.
+    const { results, pagination } = await Customer.query()
+      .onBuild((builder) => {
+        dynamicList.buildQuery()(builder);
+        builder.modify('inactiveMode', filter.inactiveMode);
+      })
+      .pagination(filter.page - 1, filter.pageSize);
+
+    // Retrieves the transformed customers.
+    const customers = await this.transformer.transform(
+      tenantId,
+      results,
+      new CustomerTransfromer()
+    );
+    return {
+      customers,
+      pagination,
+      filterMeta: dynamicList.getResponseMeta(),
+    };
+  }
+}
diff --git a/packages/server/src/services/Contacts/Customers/CustomerGLEntries.ts b/packages/server/src/services/Contacts/Customers/CustomerGLEntries.ts
new file mode 100644
index 000000000..f5c382f94
--- /dev/null
+++ b/packages/server/src/services/Contacts/Customers/CustomerGLEntries.ts
@@ -0,0 +1,117 @@
+import { Service, Inject } from 'typedi';
+import { AccountNormal, ICustomer, ILedgerEntry } from '@/interfaces';
+import Ledger from '@/services/Accounting/Ledger';
+
+@Service()
+export class CustomerGLEntries {
+  /**
+   * Retrieves the customer opening balance common entry attributes.
+   * @param {ICustomer} customer
+   */
+  private getCustomerOpeningGLCommonEntry = (customer: ICustomer) => {
+    return {
+      exchangeRate: customer.openingBalanceExchangeRate,
+      currencyCode: customer.currencyCode,
+
+      transactionType: 'CustomerOpeningBalance',
+      transactionId: customer.id,
+
+      date: customer.openingBalanceAt,
+      userId: customer.userId,
+      contactId: customer.id,
+
+      credit: 0,
+      debit: 0,
+
+      branchId: customer.openingBalanceBranchId,
+    };
+  };
+
+  /**
+   * Retrieves the customer opening GL credit entry.
+   * @param   {number} ARAccountId
+   * @param   {ICustomer} customer
+   * @returns {ILedgerEntry}
+   */
+  private getCustomerOpeningGLCreditEntry = (
+    ARAccountId: number,
+    customer: ICustomer
+  ): ILedgerEntry => {
+    const commonEntry = this.getCustomerOpeningGLCommonEntry(customer);
+
+    return {
+      ...commonEntry,
+      credit: 0,
+      debit: customer.localOpeningBalance,
+      accountId: ARAccountId,
+      accountNormal: AccountNormal.DEBIT,
+      index: 1,
+    };
+  };
+
+  /**
+   * Retrieves the customer opening GL debit entry.
+   * @param   {number} incomeAccountId
+   * @param   {ICustomer} customer
+   * @returns {ILedgerEntry}
+   */
+  private getCustomerOpeningGLDebitEntry = (
+    incomeAccountId: number,
+    customer: ICustomer
+  ): ILedgerEntry => {
+    const commonEntry = this.getCustomerOpeningGLCommonEntry(customer);
+
+    return {
+      ...commonEntry,
+      credit: customer.localOpeningBalance,
+      debit: 0,
+      accountId: incomeAccountId,
+      accountNormal: AccountNormal.CREDIT,
+
+      index: 2,
+    };
+  };
+
+  /**
+   * Retrieves the customer opening GL entries.
+   * @param   {number} ARAccountId
+   * @param   {number} incomeAccountId
+   * @param   {ICustomer} customer
+   * @returns {ILedgerEntry[]}
+   */
+  public getCustomerOpeningGLEntries = (
+    ARAccountId: number,
+    incomeAccountId: number,
+    customer: ICustomer
+  ) => {
+    const debitEntry = this.getCustomerOpeningGLDebitEntry(
+      incomeAccountId,
+      customer
+    );
+    const creditEntry = this.getCustomerOpeningGLCreditEntry(
+      ARAccountId,
+      customer
+    );
+    return [debitEntry, creditEntry];
+  };
+
+  /**
+   * Retrieves the customer opening balance ledger.
+   * @param   {number} ARAccountId
+   * @param   {number} incomeAccountId
+   * @param   {ICustomer} customer
+   * @returns {ILedger}
+   */
+  public getCustomerOpeningLedger = (
+    ARAccountId: number,
+    incomeAccountId: number,
+    customer: ICustomer
+  ) => {
+    const entries = this.getCustomerOpeningGLEntries(
+      ARAccountId,
+      incomeAccountId,
+      customer
+    );
+    return new Ledger(entries);
+  };
+}
diff --git a/packages/server/src/services/Contacts/Customers/CustomerGLEntriesStorage.ts b/packages/server/src/services/Contacts/Customers/CustomerGLEntriesStorage.ts
new file mode 100644
index 000000000..b2f2aef8c
--- /dev/null
+++ b/packages/server/src/services/Contacts/Customers/CustomerGLEntriesStorage.ts
@@ -0,0 +1,90 @@
+import { Knex } from 'knex';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Service, Inject } from 'typedi';
+import { CustomerGLEntries } from './CustomerGLEntries';
+
+@Service()
+export class CustomerGLEntriesStorage {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private ledegrRepository: LedgerStorageService;
+
+  @Inject()
+  private customerGLEntries: CustomerGLEntries;
+
+  /**
+   * Customer opening balance journals.
+   * @param {number} tenantId
+   * @param {number} customerId
+   * @param {Knex.Transaction} trx
+   */
+  public writeCustomerOpeningBalance = async (
+    tenantId: number,
+    customerId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { Customer } = this.tenancy.models(tenantId);
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    const customer = await Customer.query(trx).findById(customerId);
+
+    // Finds the income account.
+    const incomeAccount = await accountRepository.findOne({
+      slug: 'other-income',
+    });
+    // Find or create the A/R account.
+    const ARAccount = await accountRepository.findOrCreateAccountReceivable(
+      customer.currencyCode,
+      {},
+      trx
+    );
+    // Retrieves the customer opening balance ledger.
+    const ledger = this.customerGLEntries.getCustomerOpeningLedger(
+      ARAccount.id,
+      incomeAccount.id,
+      customer
+    );
+    // Commits the ledger entries to the storage.
+    await this.ledegrRepository.commit(tenantId, ledger, trx);
+  };
+
+  /**
+   * Reverts the customer opening balance GL entries.
+   * @param {number} tenantId
+   * @param {number} customerId
+   * @param {Knex.Transaction} trx
+   */
+  public revertCustomerOpeningBalance = async (
+    tenantId: number,
+    customerId: number,
+    trx?: Knex.Transaction
+  ) => {
+    await this.ledegrRepository.deleteByReference(
+      tenantId,
+      customerId,
+      'CustomerOpeningBalance',
+      trx
+    );
+  };
+
+  /**
+   * Writes the customer opening balance GL entries.
+   * @param {number} tenantId
+   * @param {number} customerId
+   * @param {Knex.Transaction} trx
+   */
+  public rewriteCustomerOpeningBalance = async (
+    tenantId: number,
+    customerId: number,
+    trx?: Knex.Transaction
+  ) => {
+    // Reverts the customer opening balance entries.
+    await this.revertCustomerOpeningBalance(tenantId, customerId, trx);
+
+    // Write the customer opening balance entries.
+    await this.writeCustomerOpeningBalance(tenantId, customerId, trx);    
+  };
+}
diff --git a/packages/server/src/services/Contacts/Customers/CustomerTransformer.ts b/packages/server/src/services/Contacts/Customers/CustomerTransformer.ts
new file mode 100644
index 000000000..497430c0e
--- /dev/null
+++ b/packages/server/src/services/Contacts/Customers/CustomerTransformer.ts
@@ -0,0 +1,38 @@
+import ContactTransfromer from '../ContactTransformer';
+
+export default class CustomerTransfromer extends ContactTransfromer {
+  /**
+   * Include these attributes to expense object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedBalance',
+      'formattedOpeningBalance',
+      'formattedOpeningBalanceAt',
+      'customerType',
+      'formattedCustomerType',
+    ];
+  };
+
+  /**
+   * Retrieve customer type.
+   * @returns {string}
+   */
+  protected customerType = (customer): string => {
+    return customer.contactType;
+  };
+
+  /**
+   * Retrieve the formatted customer type.
+   * @param customer
+   * @returns {string}
+   */
+  protected formattedCustomerType = (customer): string => {
+    const keywords = {
+      individual: 'customer.type.individual',
+      business: 'customer.type.business',
+    };
+    return this.context.i18n.__(keywords[customer.contactType] || '');
+  };
+}
diff --git a/packages/server/src/services/Contacts/Customers/CustomersApplication.ts b/packages/server/src/services/Contacts/Customers/CustomersApplication.ts
new file mode 100644
index 000000000..0bb080351
--- /dev/null
+++ b/packages/server/src/services/Contacts/Customers/CustomersApplication.ts
@@ -0,0 +1,130 @@
+import {
+  ICustomer,
+  ICustomerEditDTO,
+  ICustomerNewDTO,
+  ICustomerOpeningBalanceEditDTO,
+  ICustomersFilter,
+  ISystemUser,
+} from '@/interfaces';
+import { Inject, Service } from 'typedi';
+import { CreateCustomer } from './CRUD/CreateCustomer';
+import { DeleteCustomer } from './CRUD/DeleteCustomer';
+import { EditCustomer } from './CRUD/EditCustomer';
+import { EditOpeningBalanceCustomer } from './CRUD/EditOpeningBalanceCustomer';
+import { GetCustomer } from './CRUD/GetCustomer';
+import { GetCustomers } from './CRUD/GetCustomers';
+
+@Service()
+export class CustomersApplication {
+  @Inject()
+  private getCustomerService: GetCustomer;
+
+  @Inject()
+  private createCustomerService: CreateCustomer;
+
+  @Inject()
+  private editCustomerService: EditCustomer;
+
+  @Inject()
+  private deleteCustomerService: DeleteCustomer;
+
+  @Inject()
+  private editOpeningBalanceService: EditOpeningBalanceCustomer;
+
+  @Inject()
+  private getCustomersService: GetCustomers;
+
+  /**
+   * Retrieves the given customer details.
+   * @param {number} tenantId
+   * @param {number} customerId
+   */
+  public getCustomer = (tenantId: number, customerId: number) => {
+    return this.getCustomerService.getCustomer(tenantId, customerId);
+  };
+
+  /**
+   * Creates a new customer.
+   * @param   {number} tenantId
+   * @param   {ICustomerNewDTO} customerDTO
+   * @param   {ISystemUser} authorizedUser
+   * @returns {Promise<ICustomer>}
+   */
+  public createCustomer = (
+    tenantId: number,
+    customerDTO: ICustomerNewDTO,
+    authorizedUser: ISystemUser
+  ) => {
+    return this.createCustomerService.createCustomer(
+      tenantId,
+      customerDTO,
+      authorizedUser
+    );
+  };
+
+  /**
+   * Edits details of the given customer.
+   * @param  {number} tenantId
+   * @param  {number} customerId
+   * @param  {ICustomerEditDTO} customerDTO
+   * @return {Promise<ICustomer>}
+   */
+  public editCustomer = (
+    tenantId: number,
+    customerId: number,
+    customerDTO: ICustomerEditDTO
+  ) => {
+    return this.editCustomerService.editCustomer(
+      tenantId,
+      customerId,
+      customerDTO
+    );
+  };
+
+  /**
+   * Deletes the given customer and associated transactions.
+   * @param   {number} tenantId
+   * @param   {number} customerId
+   * @param   {ISystemUser} authorizedUser
+   * @returns {Promise<void>}
+   */
+  public deleteCustomer = (
+    tenantId: number,
+    customerId: number,
+    authorizedUser: ISystemUser
+  ) => {
+    return this.deleteCustomerService.deleteCustomer(
+      tenantId,
+      customerId,
+      authorizedUser
+    );
+  };
+
+  /**
+   * Changes the opening balance of the given customer.
+   * @param   {number} tenantId
+   * @param   {number} customerId
+   * @param   {Date|string} openingBalanceEditDTO
+   * @returns {Promise<ICustomer>}
+   */
+  public editOpeningBalance = (
+    tenantId: number,
+    customerId: number,
+    openingBalanceEditDTO: ICustomerOpeningBalanceEditDTO
+  ): Promise<ICustomer> => {
+    return this.editOpeningBalanceService.changeOpeningBalance(
+      tenantId,
+      customerId,
+      openingBalanceEditDTO
+    );
+  };
+
+  /**
+   * Retrieve customers paginated list.
+   * @param {number} tenantId - Tenant id.
+   * @param {ICustomersFilter} filter - Cusotmers filter.
+   */
+  public getCustomers = (tenantId: number, filterDTO: ICustomersFilter) => {
+    return this.getCustomersService.getCustomersList(tenantId, filterDTO);
+  };
+}
diff --git a/packages/server/src/services/Contacts/Customers/Subscribers/CustomerGLEntriesSubscriber.ts b/packages/server/src/services/Contacts/Customers/Subscribers/CustomerGLEntriesSubscriber.ts
new file mode 100644
index 000000000..825b10dc6
--- /dev/null
+++ b/packages/server/src/services/Contacts/Customers/Subscribers/CustomerGLEntriesSubscriber.ts
@@ -0,0 +1,91 @@
+import { Service, Inject } from 'typedi';
+import {
+  ICustomerEventCreatedPayload,
+  ICustomerEventDeletedPayload,
+  ICustomerOpeningBalanceEditedPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import { CustomerGLEntriesStorage } from '../CustomerGLEntriesStorage';
+
+@Service()
+export class CustomerWriteGLOpeningBalanceSubscriber {
+  @Inject()
+  private customerGLEntries: CustomerGLEntriesStorage;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.customers.onCreated,
+      this.handleWriteOpenBalanceEntries
+    );
+    bus.subscribe(
+      events.customers.onDeleted,
+      this.handleRevertOpeningBalanceEntries
+    );
+    bus.subscribe(
+      events.customers.onOpeningBalanceChanged,
+      this.handleRewriteOpeningEntriesOnChanged
+    );
+  }
+
+  /**
+   * Handles the writing opening balance journal entries once the customer created.
+   * @param {ICustomerEventCreatedPayload} payload -
+   */
+  private handleWriteOpenBalanceEntries = async ({
+    tenantId,
+    customer,
+    trx,
+  }: ICustomerEventCreatedPayload) => {
+    // Writes the customer opening balance journal entries.
+    if (customer.openingBalance) {
+      await this.customerGLEntries.writeCustomerOpeningBalance(
+        tenantId,
+        customer.id,
+        trx
+      );
+    }
+  };
+
+  /**
+   * Handles the deleting opeing balance journal entrise once the customer deleted.
+   * @param {ICustomerEventDeletedPayload} payload -
+   */
+  private handleRevertOpeningBalanceEntries = async ({
+    tenantId,
+    customerId,
+    trx,
+  }: ICustomerEventDeletedPayload) => {
+    await this.customerGLEntries.revertCustomerOpeningBalance(
+      tenantId,
+      customerId,
+      trx
+    );
+  };
+
+  /**
+   * Handles the rewrite opening balance entries once opening balnace changed.
+   * @param {ICustomerOpeningBalanceEditedPayload} payload -
+   */
+  private handleRewriteOpeningEntriesOnChanged = async ({
+    tenantId,
+    customer,
+    trx,
+  }: ICustomerOpeningBalanceEditedPayload) => {
+    if (customer.openingBalance) {
+      await this.customerGLEntries.rewriteCustomerOpeningBalance(
+        tenantId,
+        customer.id,
+        trx
+      );
+    } else {
+      await this.customerGLEntries.revertCustomerOpeningBalance(
+        tenantId,
+        customer.id,
+        trx
+      );
+    }
+  };
+}
diff --git a/packages/server/src/services/Contacts/Customers/constants.ts b/packages/server/src/services/Contacts/Customers/constants.ts
new file mode 100644
index 000000000..d14770903
--- /dev/null
+++ b/packages/server/src/services/Contacts/Customers/constants.ts
@@ -0,0 +1,27 @@
+export const DEFAULT_VIEW_COLUMNS = [];
+
+export const DEFAULT_VIEWS = [
+  {
+    name: 'Overdue',
+    slug: 'overdue',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'overdue' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Unpaid',
+    slug: 'unpaid',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'unpaid' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+];
+
+export const ERRORS = {
+  CUSTOMER_HAS_TRANSACTIONS: 'CUSTOMER_HAS_TRANSACTIONS',
+  CUSTOMER_ALREADY_ACTIVE: 'CUSTOMER_ALREADY_ACTIVE',
+};
diff --git a/packages/server/src/services/Contacts/Vendors/CRUD/ActivateVendor.ts b/packages/server/src/services/Contacts/Vendors/CRUD/ActivateVendor.ts
new file mode 100644
index 000000000..19dea6ee2
--- /dev/null
+++ b/packages/server/src/services/Contacts/Vendors/CRUD/ActivateVendor.ts
@@ -0,0 +1,67 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import { VendorValidators } from './VendorValidators';
+import { IVendorActivatedPayload } from '@/interfaces';
+
+@Service()
+export class ActivateVendor {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private validators: VendorValidators;
+
+  /**
+   * Inactive the given contact.
+   * @param   {number} tenantId - Tenant id.
+   * @param   {number} contactId - Contact id.
+   * @returns {Promise<void>}
+   */
+  public async activateVendor(
+    tenantId: number,
+    vendorId: number
+  ): Promise<void> {
+    const { Contact } = this.tenancy.models(tenantId);
+
+    // Retrieves the old vendor or throw not found error.
+    const oldVendor = await Contact.query()
+      .findById(vendorId)
+      .modify('vendor')
+      .throwIfNotFound();
+
+    // Validate whether the vendor is already published.
+    this.validators.validateNotAlreadyPublished(oldVendor);
+
+    // Edits the vendor with associated transactions on unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onVendorActivating` event.
+      await this.eventPublisher.emitAsync(events.vendors.onActivating, {
+        tenantId,
+        trx,
+        oldVendor,
+      } as IVendorActivatedPayload);
+
+      // Updates the vendor on the storage.
+      const vendor = await Contact.query(trx).updateAndFetchById(vendorId, {
+        active: true,
+      });
+      // Triggers `onVendorActivated` event.
+      await this.eventPublisher.emitAsync(events.vendors.onActivated, {
+        tenantId,
+        trx,
+        oldVendor,
+        vendor,
+      } as IVendorActivatedPayload);
+    });
+  }
+}
diff --git a/packages/server/src/services/Contacts/Vendors/CRUD/CreateEditVendorDTO.ts b/packages/server/src/services/Contacts/Vendors/CRUD/CreateEditVendorDTO.ts
new file mode 100644
index 000000000..b7a176b5b
--- /dev/null
+++ b/packages/server/src/services/Contacts/Vendors/CRUD/CreateEditVendorDTO.ts
@@ -0,0 +1,67 @@
+import moment from 'moment';
+import { defaultTo, isEmpty } from 'lodash';
+import { Service } from 'typedi';
+import {
+  ContactService,
+  IVendor,
+  IVendorEditDTO,
+  IVendorNewDTO,
+} from '@/interfaces';
+import { TenantMetadata } from '@/system/models';
+
+@Service()
+export class CreateEditVendorDTO {
+  /**
+   *
+   * @param {IVendorNewDTO | IVendorEditDTO} vendorDTO
+   * @returns
+   */
+  private transformCommonDTO = (vendorDTO: IVendorNewDTO | IVendorEditDTO) => {
+    return {
+      ...vendorDTO,
+    };
+  };
+
+  /**
+   * Transformes the create vendor DTO.
+   * @param   {IVendorNewDTO} vendorDTO -
+   * @returns {}
+   */
+  public transformCreateDTO = async (
+    tenantId: number,
+    vendorDTO: IVendorNewDTO
+  ) => {
+    const commonDTO = this.transformCommonDTO(vendorDTO);
+
+    // Retrieves the tenant metadata.
+    const tenantMeta = await TenantMetadata.query().findOne({ tenantId });
+
+    return {
+      ...commonDTO,
+      currencyCode: vendorDTO.currencyCode || tenantMeta.baseCurrency,
+      active: defaultTo(vendorDTO.active, true),
+      contactService: ContactService.Vendor,
+
+      ...(!isEmpty(vendorDTO.openingBalanceAt)
+        ? {
+            openingBalanceAt: moment(
+              vendorDTO?.openingBalanceAt
+            ).toMySqlDateTime(),
+          }
+        : {}),
+    };
+  };
+
+  /**
+   * Transformes the edit vendor DTO.
+   * @param  {IVendorEditDTO} vendorDTO
+   * @returns
+   */
+  public transformEditDTO = (vendorDTO: IVendorEditDTO) => {
+    const commonDTO = this.transformCommonDTO(vendorDTO);
+
+    return {
+      ...commonDTO,
+    };
+  };
+}
diff --git a/packages/server/src/services/Contacts/Vendors/CRUD/CreateVendor.ts b/packages/server/src/services/Contacts/Vendors/CRUD/CreateVendor.ts
new file mode 100644
index 000000000..c720732aa
--- /dev/null
+++ b/packages/server/src/services/Contacts/Vendors/CRUD/CreateVendor.ts
@@ -0,0 +1,72 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import {
+  ISystemUser,
+  IVendorEventCreatedPayload,
+  IVendorEventCreatingPayload,
+  IVendorNewDTO,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { CreateEditVendorDTO } from './CreateEditVendorDTO';
+
+@Service()
+export class CreateVendor {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformDTO: CreateEditVendorDTO;
+
+  /**
+   * Creates a new vendor.
+   * @param  {number} tenantId
+   * @param  {IVendorNewDTO} vendorDTO
+   * @return {Promise<void>}
+   */
+  public async createVendor(
+    tenantId: number,
+    vendorDTO: IVendorNewDTO,
+    authorizedUser: ISystemUser
+  ) {
+    const { Contact } = this.tenancy.models(tenantId);
+
+    // Transformes create DTO to customer object.
+    const vendorObject = await this.transformDTO.transformCreateDTO(
+      tenantId,
+      vendorDTO
+    );
+    // Creates vendor contact under unit-of-work evnirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onVendorCreating` event.
+      await this.eventPublisher.emitAsync(events.vendors.onCreating, {
+        tenantId,
+        vendorDTO,
+        trx,
+      } as IVendorEventCreatingPayload);
+
+      // Creates a new contact as vendor.
+      const vendor = await Contact.query(trx).insertAndFetch({
+        ...vendorObject,
+      });
+      // Triggers `onVendorCreated` event.
+      await this.eventPublisher.emitAsync(events.vendors.onCreated, {
+        tenantId,
+        vendorId: vendor.id,
+        vendor,
+        authorizedUser,
+        trx,
+      } as IVendorEventCreatedPayload);
+
+      return vendor;
+    });
+  }
+}
diff --git a/packages/server/src/services/Contacts/Vendors/CRUD/DeleteVendor.ts b/packages/server/src/services/Contacts/Vendors/CRUD/DeleteVendor.ts
new file mode 100644
index 000000000..b2e212883
--- /dev/null
+++ b/packages/server/src/services/Contacts/Vendors/CRUD/DeleteVendor.ts
@@ -0,0 +1,68 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import {
+  ISystemUser,
+  IVendorEventDeletedPayload,
+  IVendorEventDeletingPayload,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+import UnitOfWork from '@/services/UnitOfWork';
+import { ERRORS } from '../constants';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class DeleteVendor {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  /**
+   * Deletes the given vendor.
+   * @param  {number} tenantId
+   * @param  {number} vendorId
+   * @return {Promise<void>}
+   */
+  public async deleteVendor(
+    tenantId: number,
+    vendorId: number,
+    authorizedUser: ISystemUser
+  ) {
+    const { Contact } = this.tenancy.models(tenantId);
+
+    // Retrieves the old vendor or throw not found service error.
+    const oldVendor = await Contact.query()
+      .modify('vendor')
+      .findById(vendorId)
+      .throwIfNotFound()
+      .queryAndThrowIfHasRelations({
+        type: ERRORS.VENDOR_HAS_TRANSACTIONS,
+      });
+    // Triggers `onVendorDeleting` event.
+    await this.eventPublisher.emitAsync(events.vendors.onDeleting, {
+      tenantId,
+      vendorId,
+      oldVendor,
+    } as IVendorEventDeletingPayload);
+
+    // Deletes vendor contact under unit-of-work.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Deletes the vendor contact from the storage.
+      await Contact.query(trx).findById(vendorId).delete();
+
+      // Triggers `onVendorDeleted` event.
+      await this.eventPublisher.emitAsync(events.vendors.onDeleted, {
+        tenantId,
+        vendorId,
+        authorizedUser,
+        oldVendor,
+        trx,
+      } as IVendorEventDeletedPayload);
+    });
+  }
+}
diff --git a/packages/server/src/services/Contacts/Vendors/CRUD/EditOpeningBalanceVendor.ts b/packages/server/src/services/Contacts/Vendors/CRUD/EditOpeningBalanceVendor.ts
new file mode 100644
index 000000000..3767470fa
--- /dev/null
+++ b/packages/server/src/services/Contacts/Vendors/CRUD/EditOpeningBalanceVendor.ts
@@ -0,0 +1,72 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import {
+  IVendorOpeningBalanceEditDTO,
+  IVendorOpeningBalanceEditedPayload,
+  IVendorOpeningBalanceEditingPayload,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class EditOpeningBalanceVendor {
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Changes the opening balance of the given customer.
+   * @param   {number} tenantId
+   * @param   {number} customerId
+   * @param   {number} openingBalance
+   * @param   {string|Date} openingBalanceAt
+   * @returns {Promise<IVendor>}
+   */
+  public async editOpeningBalance(
+    tenantId: number,
+    vendorId: number,
+    openingBalanceEditDTO: IVendorOpeningBalanceEditDTO
+  ) {
+    const { Vendor } = this.tenancy.models(tenantId);
+
+    // Retrieves the old vendor or throw not found error.
+    const oldVendor = await Vendor.query().findById(vendorId).throwIfNotFound();
+
+    // Mutates the customer opening balance under unit-of-work.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onVendorOpeingBalanceChanging` event.
+      await this.eventPublisher.emitAsync(
+        events.vendors.onOpeningBalanceChanging,
+        {
+          tenantId,
+          oldVendor,
+          openingBalanceEditDTO,
+          trx,
+        } as IVendorOpeningBalanceEditingPayload
+      );
+      // Mutates the vendor on the storage.
+      const vendor = await Vendor.query().patchAndFetchById(vendorId, {
+        ...openingBalanceEditDTO,
+      });
+      // Triggers `onVendorOpeingBalanceChanged` event.
+      await this.eventPublisher.emitAsync(
+        events.vendors.onOpeningBalanceChanged,
+        {
+          tenantId,
+          vendor,
+          oldVendor,
+          openingBalanceEditDTO,
+          trx,
+        } as IVendorOpeningBalanceEditedPayload
+      );
+      return vendor;
+    });
+  }
+}
diff --git a/packages/server/src/services/Contacts/Vendors/CRUD/EditVendor.ts b/packages/server/src/services/Contacts/Vendors/CRUD/EditVendor.ts
new file mode 100644
index 000000000..398bed078
--- /dev/null
+++ b/packages/server/src/services/Contacts/Vendors/CRUD/EditVendor.ts
@@ -0,0 +1,78 @@
+import {
+  ISystemUser,
+  IVendorEditDTO,
+  IVendorEventEditedPayload,
+  IVendorEventEditingPayload,
+} from '@/interfaces';
+import { Knex } from 'knex';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import { Inject, Service } from 'typedi';
+import { CreateEditVendorDTO } from './CreateEditVendorDTO';
+
+@Service()
+export class EditVendor {
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private transformDTO: CreateEditVendorDTO;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Edits details of the given vendor.
+   * @param   {number} tenantId -
+   * @param   {number} vendorId -
+   * @param   {IVendorEditDTO} vendorDTO -
+   * @returns {Promise<IVendor>}
+   */
+  public async editVendor(
+    tenantId: number,
+    vendorId: number,
+    vendorDTO: IVendorEditDTO,
+    authorizedUser: ISystemUser
+  ) {
+    const { Contact } = this.tenancy.models(tenantId);
+
+    // Retrieve the vendor or throw not found error.
+    const oldVendor = await Contact.query()
+      .findById(vendorId)
+      .modify('vendor')
+      .throwIfNotFound();
+
+    // Transformes vendor DTO to object.
+    const vendorObj = this.transformDTO.transformEditDTO(vendorDTO);
+
+    // Edits vendor contact under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onVendorEditing` event.
+      await this.eventPublisher.emitAsync(events.vendors.onEditing, {
+        trx,
+        tenantId,
+        vendorDTO,
+      } as IVendorEventEditingPayload);
+
+      // Edits the vendor contact.
+      const vendor = await Contact.query().updateAndFetchById(vendorId, {
+        ...vendorObj,
+      });
+      // Triggers `onVendorEdited` event.
+      await this.eventPublisher.emitAsync(events.vendors.onEdited, {
+        tenantId,
+        vendorId,
+        vendor,
+        authorizedUser,
+        trx,
+      } as IVendorEventEditedPayload);
+
+      return vendor;
+    });
+  }
+}
diff --git a/packages/server/src/services/Contacts/Vendors/CRUD/GetVendor.ts b/packages/server/src/services/Contacts/Vendors/CRUD/GetVendor.ts
new file mode 100644
index 000000000..c90de4616
--- /dev/null
+++ b/packages/server/src/services/Contacts/Vendors/CRUD/GetVendor.ts
@@ -0,0 +1,34 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import VendorTransfromer from '../VendorTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export class GetVendor {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the given vendor details.
+   * @param {number} tenantId
+   * @param {number} vendorId
+   */
+  public async getVendor(tenantId: number, vendorId: number) {
+    const { Contact } = this.tenancy.models(tenantId);
+
+    const vendor = await Contact.query()
+      .findById(vendorId)
+      .modify('vendor')
+      .throwIfNotFound();
+
+    // Transformes the vendor.
+    return this.transformer.transform(
+      tenantId,
+      vendor,
+      new VendorTransfromer()
+    );
+  }
+}
diff --git a/packages/server/src/services/Contacts/Vendors/CRUD/GetVendors.ts b/packages/server/src/services/Contacts/Vendors/CRUD/GetVendors.ts
new file mode 100644
index 000000000..ec5f124d9
--- /dev/null
+++ b/packages/server/src/services/Contacts/Vendors/CRUD/GetVendors.ts
@@ -0,0 +1,80 @@
+import * as R from 'ramda';
+import { Service, Inject } from 'typedi';
+import {
+  IFilterMeta,
+  IPaginationMeta,
+  IVendor,
+  IVendorsFilter,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import VendorTransfromer from '../VendorTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export class GetVendors {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve vendors datatable list.
+   * @param {number} tenantId - Tenant id.
+   * @param {IVendorsFilter} vendorsFilter - Vendors filter.
+   */
+  public async getVendorsList(
+    tenantId: number,
+    filterDTO: IVendorsFilter
+  ): Promise<{
+    vendors: IVendor[];
+    pagination: IPaginationMeta;
+    filterMeta: IFilterMeta;
+  }> {
+    const { Vendor } = this.tenancy.models(tenantId);
+
+    // Parses vendors list filter DTO.
+    const filter = this.parseVendorsListFilterDTO(filterDTO);
+
+    // Dynamic list service.
+    const dynamicList = await this.dynamicListService.dynamicList(
+      tenantId,
+      Vendor,
+      filter
+    );
+    // Vendors list.
+    const { results, pagination } = await Vendor.query()
+      .onBuild((builder) => {
+        dynamicList.buildQuery()(builder);
+
+        // Switches between active/inactive modes.
+        builder.modify('inactiveMode', filter.inactiveMode);
+      })
+      .pagination(filter.page - 1, filter.pageSize);
+
+    // Transform the vendors.
+    const transformedVendors = await this.transformer.transform(
+      tenantId,
+      results,
+      new VendorTransfromer()
+    );
+    return {
+      vendors: transformedVendors,
+      pagination,
+      filterMeta: dynamicList.getResponseMeta(),
+    };
+  }
+
+  /**
+   *
+   * @param filterDTO
+   * @returns
+   */
+  private parseVendorsListFilterDTO(filterDTO) {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  }
+}
diff --git a/packages/server/src/services/Contacts/Vendors/CRUD/VendorValidators.ts b/packages/server/src/services/Contacts/Vendors/CRUD/VendorValidators.ts
new file mode 100644
index 000000000..739af10ed
--- /dev/null
+++ b/packages/server/src/services/Contacts/Vendors/CRUD/VendorValidators.ts
@@ -0,0 +1,16 @@
+import { ServiceError } from '@/exceptions';
+import { Service, Inject } from 'typedi';
+import { ERRORS } from '../constants';
+
+@Service()
+export class VendorValidators {
+  /**
+   * Validates the given vendor is not already activated.
+   * @param {IVendor} vendor
+   */
+  public validateNotAlreadyPublished = (vendor) => {
+    if (vendor.active) {
+      throw new ServiceError(ERRORS.VENDOR_ALREADY_ACTIVE);
+    }
+  };
+}
diff --git a/packages/server/src/services/Contacts/Vendors/Subscribers/VendorGLEntriesSubscriber.ts b/packages/server/src/services/Contacts/Vendors/Subscribers/VendorGLEntriesSubscriber.ts
new file mode 100644
index 000000000..ad50b7387
--- /dev/null
+++ b/packages/server/src/services/Contacts/Vendors/Subscribers/VendorGLEntriesSubscriber.ts
@@ -0,0 +1,91 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import { VendorGLEntriesStorage } from '../VendorGLEntriesStorage';
+import {
+  IVendorEventCreatedPayload,
+  IVendorEventDeletedPayload,
+  IVendorOpeningBalanceEditedPayload,
+} from '@/interfaces';
+
+@Service()
+export class VendorsWriteGLOpeningSubscriber {
+  @Inject()
+  private vendorGLEntriesStorage: VendorGLEntriesStorage;
+
+  /**
+   * Constructor method.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.vendors.onCreated,
+      this.handleWriteOpeningBalanceEntries
+    );
+    bus.subscribe(
+      events.vendors.onDeleted,
+      this.handleRevertOpeningBalanceEntries
+    );
+    bus.subscribe(
+      events.vendors.onOpeningBalanceChanged,
+      this.handleRewriteOpeningEntriesOnChanged
+    );
+  }
+
+  /**
+   * Writes the open balance journal entries once the vendor created.
+   * @param {IVendorEventCreatedPayload} payload -
+   */
+  private handleWriteOpeningBalanceEntries = async ({
+    tenantId,
+    vendor,
+    trx,
+  }: IVendorEventCreatedPayload) => {
+    // Writes the vendor opening balance journal entries.
+    if (vendor.openingBalance) {
+      await this.vendorGLEntriesStorage.writeVendorOpeningBalance(
+        tenantId,
+        vendor.id,
+        trx
+      );
+    }
+  };
+
+  /**
+   * Revert the opening balance journal entries once the vendor deleted.
+   * @param {IVendorEventDeletedPayload} payload -
+   */
+  private handleRevertOpeningBalanceEntries = async ({
+    tenantId,
+    vendorId,
+    trx,
+  }: IVendorEventDeletedPayload) => {
+    await this.vendorGLEntriesStorage.revertVendorOpeningBalance(
+      tenantId,
+      vendorId,
+      trx
+    );
+  };
+
+  /**
+   * Handles the rewrite opening balance entries once opening balnace changed.
+   * @param {ICustomerOpeningBalanceEditedPayload} payload -
+   */
+  private handleRewriteOpeningEntriesOnChanged = async ({
+    tenantId,
+    vendor,
+    trx,
+  }: IVendorOpeningBalanceEditedPayload) => {
+    if (vendor.openingBalance) {
+      await this.vendorGLEntriesStorage.rewriteVendorOpeningBalance(
+        tenantId,
+        vendor.id,
+        trx
+      );
+    } else {
+      await this.vendorGLEntriesStorage.revertVendorOpeningBalance(
+        tenantId,
+        vendor.id,
+        trx
+      );
+    }
+  };
+}
diff --git a/packages/server/src/services/Contacts/Vendors/VendorGLEntries.ts b/packages/server/src/services/Contacts/Vendors/VendorGLEntries.ts
new file mode 100644
index 000000000..f238fde20
--- /dev/null
+++ b/packages/server/src/services/Contacts/Vendors/VendorGLEntries.ts
@@ -0,0 +1,115 @@
+import { Service } from 'typedi';
+import { IVendor, AccountNormal, ILedgerEntry } from '@/interfaces';
+import Ledger from '@/services/Accounting/Ledger';
+
+@Service()
+export class VendorGLEntries {
+  /**
+   * Retrieves the opening balance GL common entry.
+   * @param {IVendor} vendor -
+   */
+  private getOpeningBalanceGLCommonEntry = (vendor: IVendor) => {
+    return {
+      exchangeRate: vendor.openingBalanceExchangeRate,
+      currencyCode: vendor.currencyCode,
+
+      transactionType: 'VendorOpeningBalance',
+      transactionId: vendor.id,
+
+      date: vendor.openingBalanceAt,
+      userId: vendor.userId,
+      contactId: vendor.id,
+
+      credit: 0,
+      debit: 0,
+
+      branchId: vendor.openingBalanceBranchId,
+    };
+  };
+
+  /**
+   * Retrieves the opening balance GL debit entry.
+   * @param   {number} costAccountId -
+   * @param   {IVendor} vendor
+   * @returns {ILedgerEntry}
+   */
+  private getOpeningBalanceGLDebitEntry = (
+    costAccountId: number,
+    vendor: IVendor
+  ): ILedgerEntry => {
+    const commonEntry = this.getOpeningBalanceGLCommonEntry(vendor);
+
+    return {
+      ...commonEntry,
+      accountId: costAccountId,
+      accountNormal: AccountNormal.DEBIT,
+      debit: vendor.localOpeningBalance,
+      credit: 0,
+      index: 2,
+    };
+  };
+
+  /**
+   * Retrieves the opening balance GL credit entry.
+   * @param   {number} APAccountId
+   * @param   {IVendor} vendor
+   * @returns {ILedgerEntry}
+   */
+  private getOpeningBalanceGLCreditEntry = (
+    APAccountId: number,
+    vendor: IVendor
+  ): ILedgerEntry => {
+    const commonEntry = this.getOpeningBalanceGLCommonEntry(vendor);
+
+    return {
+      ...commonEntry,
+      accountId: APAccountId,
+      accountNormal: AccountNormal.CREDIT,
+      credit: vendor.localOpeningBalance,
+      index: 1,
+    };
+  };
+
+  /**
+   * Retrieves the opening balance GL entries.
+   * @param   {number} APAccountId
+   * @param   {number} costAccountId -
+   * @param   {IVendor} vendor
+   * @returns {ILedgerEntry[]}
+   */
+  public getOpeningBalanceGLEntries = (
+    APAccountId: number,
+    costAccountId: number,
+    vendor: IVendor
+  ): ILedgerEntry[] => {
+    const debitEntry = this.getOpeningBalanceGLDebitEntry(
+      costAccountId,
+      vendor
+    );
+    const creditEntry = this.getOpeningBalanceGLCreditEntry(
+      APAccountId,
+      vendor
+    );
+    return [debitEntry, creditEntry];
+  };
+
+  /**
+   * Retrieves the opening balance ledger.
+   * @param   {number} APAccountId
+   * @param   {number} costAccountId -
+   * @param   {IVendor} vendor
+   * @returns {Ledger}
+   */
+  public getOpeningBalanceLedger = (
+    APAccountId: number,
+    costAccountId: number,
+    vendor: IVendor
+  ) => {
+    const entries = this.getOpeningBalanceGLEntries(
+      APAccountId,
+      costAccountId,
+      vendor
+    );
+    return new Ledger(entries);
+  };
+}
diff --git a/packages/server/src/services/Contacts/Vendors/VendorGLEntriesStorage.ts b/packages/server/src/services/Contacts/Vendors/VendorGLEntriesStorage.ts
new file mode 100644
index 000000000..a8bde60fe
--- /dev/null
+++ b/packages/server/src/services/Contacts/Vendors/VendorGLEntriesStorage.ts
@@ -0,0 +1,88 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { VendorGLEntries } from './VendorGLEntries';
+
+@Service()
+export class VendorGLEntriesStorage {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private ledegrRepository: LedgerStorageService;
+
+  @Inject()
+  private vendorGLEntries: VendorGLEntries;
+
+  /**
+   * Vendor opening balance journals.
+   * @param {number} tenantId
+   * @param {number} vendorId
+   * @param {Knex.Transaction} trx
+   */
+  public writeVendorOpeningBalance = async (
+    tenantId: number,
+    vendorId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { Vendor } = this.tenancy.models(tenantId);
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    const vendor = await Vendor.query(trx).findById(vendorId);
+
+    // Finds the expense account.
+    const expenseAccount = await accountRepository.findOne({
+      slug: 'other-expenses',
+    });
+    // Find or create the A/P account.
+    const APAccount = await accountRepository.findOrCreateAccountsPayable(
+      vendor.currencyCode,
+      {},
+      trx
+    );
+    // Retrieves the vendor opening balance ledger.
+    const ledger = this.vendorGLEntries.getOpeningBalanceLedger(
+      APAccount.id,
+      expenseAccount.id,
+      vendor
+    );
+    // Commits the ledger entries to the storage.
+    await this.ledegrRepository.commit(tenantId, ledger, trx);
+  };
+
+  /**
+   * Reverts the vendor opening balance GL entries.
+   * @param {number} tenantId
+   * @param {number} vendorId
+   * @param {Knex.Transaction} trx
+   */
+  public revertVendorOpeningBalance = async (
+    tenantId: number,
+    vendorId: number,
+    trx?: Knex.Transaction
+  ) => {
+    await this.ledegrRepository.deleteByReference(
+      tenantId,
+      vendorId,
+      'VendorOpeningBalance',
+      trx
+    );
+  };
+
+  /**
+   * Writes the vendor opening balance GL entries.
+   * @param {number} tenantId
+   * @param {number} vendorId
+   * @param {Knex.Transaction} trx
+   */
+  public rewriteVendorOpeningBalance = async (
+    tenantId: number,
+    vendorId: number,
+    trx?: Knex.Transaction
+  ) => {
+    await this.writeVendorOpeningBalance(tenantId, vendorId, trx);
+
+    await this.revertVendorOpeningBalance(tenantId, vendorId, trx);
+  };
+}
diff --git a/packages/server/src/services/Contacts/Vendors/VendorTransformer.ts b/packages/server/src/services/Contacts/Vendors/VendorTransformer.ts
new file mode 100644
index 000000000..0514392a8
--- /dev/null
+++ b/packages/server/src/services/Contacts/Vendors/VendorTransformer.ts
@@ -0,0 +1,16 @@
+import { Service } from 'typedi';
+import ContactTransfromer from '../ContactTransformer';
+
+export default class VendorTransfromer extends ContactTransfromer {
+  /**
+   * Include these attributes to expense object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedBalance',
+      'formattedOpeningBalance',
+      'formattedOpeningBalanceAt'
+    ];
+  };
+}
diff --git a/packages/server/src/services/Contacts/Vendors/VendorsApplication.ts b/packages/server/src/services/Contacts/Vendors/VendorsApplication.ts
new file mode 100644
index 000000000..e4101acab
--- /dev/null
+++ b/packages/server/src/services/Contacts/Vendors/VendorsApplication.ts
@@ -0,0 +1,132 @@
+import { Inject, Service } from 'typedi';
+import {
+  ISystemUser,
+  IVendorEditDTO,
+  IVendorNewDTO,
+  IVendorOpeningBalanceEditDTO,
+  IVendorsFilter,
+} from '@/interfaces';
+import { CreateVendor } from './CRUD/CreateVendor';
+import { DeleteVendor } from './CRUD/DeleteVendor';
+import { EditOpeningBalanceVendor } from './CRUD/EditOpeningBalanceVendor';
+import { EditVendor } from './CRUD/EditVendor';
+import { GetVendor } from './CRUD/GetVendor';
+import { GetVendors } from './CRUD/GetVendors';
+
+@Service()
+export class VendorsApplication {
+  @Inject()
+  private createVendorService: CreateVendor;
+
+  @Inject()
+  private editVendorService: EditVendor;
+
+  @Inject()
+  private deleteVendorService: DeleteVendor;
+
+  @Inject()
+  private editOpeningBalanceService: EditOpeningBalanceVendor;
+
+  @Inject()
+  private getVendorService: GetVendor;
+
+  @Inject()
+  private getVendorsService: GetVendors;
+
+  /**
+   * Creates a new vendor.
+   * @param  {number} tenantId
+   * @param  {IVendorNewDTO} vendorDTO
+   * @return {Promise<void>}
+   */
+  public createVendor = (
+    tenantId: number,
+    vendorDTO: IVendorNewDTO,
+    authorizedUser: ISystemUser
+  ) => {
+    return this.createVendorService.createVendor(
+      tenantId,
+      vendorDTO,
+      authorizedUser
+    );
+  };
+
+  /**
+   * Edits details of the given vendor.
+   * @param   {number} tenantId -
+   * @param   {number} vendorId -
+   * @param   {IVendorEditDTO} vendorDTO -
+   * @returns {Promise<IVendor>}
+   */
+  public editVendor = (
+    tenantId: number,
+    vendorId: number,
+    vendorDTO: IVendorEditDTO,
+    authorizedUser: ISystemUser
+  ) => {
+    return this.editVendorService.editVendor(
+      tenantId,
+      vendorId,
+      vendorDTO,
+      authorizedUser
+    );
+  };
+
+  /**
+   * Deletes the given vendor.
+   * @param  {number} tenantId
+   * @param  {number} vendorId
+   * @return {Promise<void>}
+   */
+  public deleteVendor = (
+    tenantId: number,
+    vendorId: number,
+    authorizedUser: ISystemUser
+  ) => {
+    return this.deleteVendorService.deleteVendor(
+      tenantId,
+      vendorId,
+      authorizedUser
+    );
+  };
+
+  /**
+   * Changes the opening balance of the given customer.
+   * @param   {number} tenantId
+   * @param   {number} customerId
+   * @param   {number} openingBalance
+   * @param   {string|Date} openingBalanceAt
+   * @returns {Promise<IVendor>}
+   */
+  public editOpeningBalance = (
+    tenantId: number,
+    vendorId: number,
+    openingBalanceEditDTO: IVendorOpeningBalanceEditDTO
+  ) => {
+    return this.editOpeningBalanceService.editOpeningBalance(
+      tenantId,
+      vendorId,
+      openingBalanceEditDTO
+    );
+  };
+
+  /**
+   * Retrieves the vendor details.
+   * @param   {number} tenantId
+   * @param   {number} vendorId
+   * @returns
+   */
+  public getVendor = (tenantId: number, vendorId: number) => {
+    return this.getVendorService.getVendor(tenantId, vendorId);
+  };
+
+  /**
+   * Retrieves the vendors paginated list.
+   * @param   {number} tenantId
+   * @param   {IVendorsFilter} filterDTO
+   * @returns
+   */
+  public getVendors = (tenantId: number, filterDTO: IVendorsFilter) => {
+    return this.getVendorsService.getVendorsList(tenantId, filterDTO);
+  };
+}
diff --git a/packages/server/src/services/Contacts/Vendors/constants.ts b/packages/server/src/services/Contacts/Vendors/constants.ts
new file mode 100644
index 000000000..25f31f36a
--- /dev/null
+++ b/packages/server/src/services/Contacts/Vendors/constants.ts
@@ -0,0 +1,27 @@
+export const DEFAULT_VIEW_COLUMNS = [];
+
+export const DEFAULT_VIEWS = [
+  {
+    name: 'Overdue',
+    slug: 'overdue',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'overdue' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Unpaid',
+    slug: 'unpaid',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'unpaid' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+];
+
+export const ERRORS = {
+  VENDOR_HAS_TRANSACTIONS: 'VENDOR_HAS_TRANSACTIONS',
+  VENDOR_ALREADY_ACTIVE: 'VENDOR_ALREADY_ACTIVE',
+};
diff --git a/packages/server/src/services/Contacts/constants.ts b/packages/server/src/services/Contacts/constants.ts
new file mode 100644
index 000000000..3bfb8771e
--- /dev/null
+++ b/packages/server/src/services/Contacts/constants.ts
@@ -0,0 +1,29 @@
+export const DEFAULT_VIEW_COLUMNS = [];
+
+export const DEFAULT_VIEWS = [
+  {
+    name: 'Overdue',
+    slug: 'overdue',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'overdue' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Unpaid',
+    slug: 'unpaid',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'unpaid' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+];
+
+
+export const ERRORS = {
+  OPENING_BALANCE_DATE_REQUIRED: 'OPENING_BALANCE_DATE_REQUIRED',
+  CONTACT_ALREADY_INACTIVE: 'CONTACT_ALREADY_INACTIVE',
+  CONTACT_ALREADY_ACTIVE: 'CONTACT_ALREADY_ACTIVE'
+};
diff --git a/packages/server/src/services/CreditNotes/CreateCreditNote.ts b/packages/server/src/services/CreditNotes/CreateCreditNote.ts
new file mode 100644
index 000000000..2c4c0d58f
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreateCreditNote.ts
@@ -0,0 +1,93 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import {
+  ICreditNoteCreatedPayload,
+  ICreditNoteCreatingPayload,
+  ICreditNoteNewDTO,
+  ISystemUser,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+import BaseCreditNotes from './CreditNotes';
+
+@Service()
+export default class CreateCreditNote extends BaseCreditNotes {
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  itemsEntriesService: ItemsEntriesService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  /**
+   * Creates a new credit note.
+   * @param creditNoteDTO
+   */
+  public newCreditNote = async (
+    tenantId: number,
+    creditNoteDTO: ICreditNoteNewDTO,
+    authorizedUser: ISystemUser
+  ) => {
+    const { CreditNote, Contact } = this.tenancy.models(tenantId);
+
+    // Triggers `onCreditNoteCreate` event.
+    await this.eventPublisher.emitAsync(events.creditNote.onCreate, {
+      tenantId,
+      creditNoteDTO,
+    });
+    // Validate customer existance.
+    const customer = await Contact.query()
+      .modify('customer')
+      .findById(creditNoteDTO.customerId)
+      .throwIfNotFound();
+
+    // Validate items ids existance.
+    await this.itemsEntriesService.validateItemsIdsExistance(
+      tenantId,
+      creditNoteDTO.entries
+    );
+    // Validate items should be sellable items.
+    await this.itemsEntriesService.validateNonSellableEntriesItems(
+      tenantId,
+      creditNoteDTO.entries
+    );
+    // Transformes the given DTO to storage layer data.
+    const creditNoteModel = this.transformCreateEditDTOToModel(
+      tenantId,
+      creditNoteDTO,
+      customer.currencyCode
+    );
+    // Creates a new credit card transactions under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onCreditNoteCreating` event.
+      await this.eventPublisher.emitAsync(events.creditNote.onCreating, {
+        tenantId,
+        creditNoteDTO,
+        trx,
+      } as ICreditNoteCreatingPayload);
+
+      // Upsert the credit note graph.
+      const creditNote = await CreditNote.query(trx).upsertGraph({
+        ...creditNoteModel,
+      });
+      // Triggers `onCreditNoteCreated` event.
+      await this.eventPublisher.emitAsync(events.creditNote.onCreated, {
+        tenantId,
+        creditNoteDTO,
+        creditNote,
+        creditNoteId: creditNote.id,
+        trx,
+      } as ICreditNoteCreatedPayload);
+
+      return creditNote;
+    });
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/CreateRefundCreditNote.ts b/packages/server/src/services/CreditNotes/CreateRefundCreditNote.ts
new file mode 100644
index 000000000..7e556ce41
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreateRefundCreditNote.ts
@@ -0,0 +1,101 @@
+import { Knex } from 'knex';
+import { Inject, Service } from 'typedi';
+import {
+  ICreditNote,
+  ICreditNoteRefundDTO,
+  IRefundCreditNote,
+  IRefundCreditNoteCreatedPayload,
+  IRefundCreditNoteCreatingPayload,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import RefundCreditNote from './RefundCreditNote';
+
+@Service()
+export default class CreateRefundCreditNote extends RefundCreditNote {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Retrieve the credit note graph.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @returns {Promise<IRefundCreditNote>}
+   */
+  public createCreditNoteRefund = async (
+    tenantId: number,
+    creditNoteId: number,
+    newCreditNoteDTO: ICreditNoteRefundDTO
+  ): Promise<IRefundCreditNote> => {
+    const { RefundCreditNote, Account } = this.tenancy.models(tenantId);
+
+    // Retrieve the credit note or throw not found service error.
+    const creditNote = await this.getCreditNoteOrThrowError(
+      tenantId,
+      creditNoteId
+    );
+    // Retrieve the withdrawal account or throw not found service error.
+    const fromAccount = await Account.query()
+      .findById(newCreditNoteDTO.fromAccountId)
+      .throwIfNotFound();
+
+    // Validate the credit note remaining amount.
+    this.validateCreditRemainingAmount(creditNote, newCreditNoteDTO.amount);
+
+    // Validate the refund withdrawal account type.
+    this.validateRefundWithdrawwalAccountType(fromAccount);
+
+    // Creates a refund credit note transaction.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onCreditNoteRefundCreating` event.
+      await this.eventPublisher.emitAsync(events.creditNote.onRefundCreating, {
+        trx,
+        creditNote,
+        tenantId,
+        newCreditNoteDTO,
+      } as IRefundCreditNoteCreatingPayload);
+
+      // Stores the refund credit note graph to the storage layer.
+      const refundCreditNote = await RefundCreditNote.query(trx).insertAndFetch(
+        {
+          ...this.transformDTOToModel(creditNote, newCreditNoteDTO),
+        }
+      );
+      // Triggers `onCreditNoteRefundCreated` event.
+      await this.eventPublisher.emitAsync(events.creditNote.onRefundCreated, {
+        trx,
+        refundCreditNote,
+        creditNote,
+        tenantId,
+      } as IRefundCreditNoteCreatedPayload);
+
+      return refundCreditNote;
+    });
+  };
+
+  /**
+   * Transformes the refund credit note DTO to model.
+   * @param {number} creditNoteId
+   * @param {ICreditNoteRefundDTO} creditNoteDTO
+   * @returns {ICreditNote}
+   */
+  private transformDTOToModel = (
+    creditNote: ICreditNote,
+    creditNoteDTO: ICreditNoteRefundDTO
+  ): IRefundCreditNote => {
+    return {
+      creditNoteId: creditNote.id,
+      currencyCode: creditNote.currencyCode,
+      ...creditNoteDTO,
+      exchangeRate: creditNoteDTO.exchangeRate || 1,
+    };
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/CreditNoteAppliedInvoiceTransformer.ts b/packages/server/src/services/CreditNotes/CreditNoteAppliedInvoiceTransformer.ts
new file mode 100644
index 000000000..0f3df3806
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreditNoteAppliedInvoiceTransformer.ts
@@ -0,0 +1,53 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class CreditNoteAppliedInvoiceTransformer extends Transformer {
+  /**
+   * Includeded attributes.
+   * @returns {string[]}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formttedAmount',
+      'creditNoteNumber',
+      'creditNoteDate',
+      'invoiceNumber',
+      'invoiceReferenceNo',
+      'formattedCreditNoteDate',
+    ];
+  };
+
+  /**
+   * Exclude attributes.
+   * @returns {string[]}
+   */
+  public excludeAttributes = (): string[] => {
+    return ['saleInvoice', 'creditNote'];
+  };
+
+  formttedAmount = (item) => {
+    return formatNumber(item.amount, {
+      currencyCode: item.creditNote.currencyCode,
+    });
+  };
+
+  creditNoteNumber = (item) => {
+    return item.creditNote.creditNoteNumber;
+  };
+
+  creditNoteDate = (item) => {
+    return item.creditNote.creditNoteDate;
+  };
+
+  invoiceNumber = (item) => {
+    return item.saleInvoice.invoiceNo;
+  };
+
+  invoiceReferenceNo = (item) => {
+    return item.saleInvoice.referenceNo;
+  };
+
+  formattedCreditNoteDate = (item) => {
+    return this.formatDate(item.creditNote.creditNoteDate);
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/CreditNoteApplySyncCredit.ts b/packages/server/src/services/CreditNotes/CreditNoteApplySyncCredit.ts
new file mode 100644
index 000000000..8444c7909
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreditNoteApplySyncCredit.ts
@@ -0,0 +1,47 @@
+import Knex from 'knex';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Service, Inject } from 'typedi';
+
+@Service()
+export default class CreditNoteApplySyncCredit {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Increment credit note invoiced amount.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @param {number} invoicesAppliedAmount
+   */
+  public incrementCreditNoteInvoicedAmount = async (
+    tenantId: number,
+    creditNoteId: number,
+    invoicesAppliedAmount: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { CreditNote } = this.tenancy.models(tenantId);
+
+    await CreditNote.query(trx)
+      .findById(creditNoteId)
+      .increment('invoicesAmount', invoicesAppliedAmount);
+  };
+
+  /**
+   * Decrement credit note invoiced amount.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @param {number} invoicesAppliedAmount
+   */
+  public decrementCreditNoteInvoicedAmount = async (
+    tenantId: number,
+    creditNoteId: number,
+    invoicesAppliedAmount: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { CreditNote } = this.tenancy.models(tenantId);
+
+    await CreditNote.query(trx)
+      .findById(creditNoteId)
+      .decrement('invoicesAmount', invoicesAppliedAmount);
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/CreditNoteApplySyncCreditSubscriber.ts b/packages/server/src/services/CreditNotes/CreditNoteApplySyncCreditSubscriber.ts
new file mode 100644
index 000000000..c2354e665
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreditNoteApplySyncCreditSubscriber.ts
@@ -0,0 +1,67 @@
+import { Service, Inject } from 'typedi';
+import { sumBy } from 'lodash';
+import events from '@/subscribers/events';
+import {
+  IApplyCreditToInvoicesCreatedPayload,
+  IApplyCreditToInvoicesDeletedPayload,
+} from '@/interfaces';
+import CreditNoteApplySyncCredit from './CreditNoteApplySyncCredit';
+
+@Service()
+export default class CreditNoteApplySyncCreditSubscriber {
+  @Inject()
+  syncInvoicedAmountWithCredit: CreditNoteApplySyncCredit;
+
+  /**
+   *
+   * @param bus
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.creditNote.onApplyToInvoicesCreated,
+      this.incrementCreditedAmountOnceApplyToInvoicesCreated
+    );
+    bus.subscribe(
+      events.creditNote.onApplyToInvoicesDeleted,
+      this.decrementCreditedAmountOnceApplyToInvoicesDeleted
+    );
+  }
+
+  /**
+   * Increment credited amount of credit note transaction once the transaction created.
+   * @param {IApplyCreditToInvoicesCreatedPayload} payload -
+   */
+  private incrementCreditedAmountOnceApplyToInvoicesCreated = async ({
+    trx,
+    creditNote,
+    tenantId,
+    creditNoteAppliedInvoices,
+  }: IApplyCreditToInvoicesCreatedPayload) => {
+    const totalCredited = sumBy(creditNoteAppliedInvoices, 'amount');
+
+    await this.syncInvoicedAmountWithCredit.incrementCreditNoteInvoicedAmount(
+      tenantId,
+      creditNote.id,
+      totalCredited,
+      trx
+    );
+  };
+
+  /**
+   * Decrement credited amount of credit note transaction once the transaction deleted.
+   * @param {IApplyCreditToInvoicesDeletedPayload} payload -
+   */
+  private decrementCreditedAmountOnceApplyToInvoicesDeleted = async ({
+    tenantId,
+    creditNote,
+    creditNoteAppliedToInvoice,
+    trx,
+  }: IApplyCreditToInvoicesDeletedPayload) => {
+    await this.syncInvoicedAmountWithCredit.decrementCreditNoteInvoicedAmount(
+      tenantId,
+      creditNote.id,
+      creditNoteAppliedToInvoice.amount,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/CreditNoteApplySyncInvoices.ts b/packages/server/src/services/CreditNotes/CreditNoteApplySyncInvoices.ts
new file mode 100644
index 000000000..13c5f8143
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreditNoteApplySyncInvoices.ts
@@ -0,0 +1,53 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import Knex from 'knex';
+import Bluebird from 'bluebird';
+import { ICreditNoteAppliedToInvoice } from '@/interfaces';
+
+@Service()
+export default class CreditNoteApplySyncInvoicesCreditedAmount {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Increment invoices credited amount.
+   * @param {number} tenantId -
+   * @param {ICreditNoteAppliedToInvoice[]} creditNoteAppliedInvoices -
+   * @param {Knex.Transaction} trx -
+   */
+  public incrementInvoicesCreditedAmount = async (
+    tenantId,
+    creditNoteAppliedInvoices: ICreditNoteAppliedToInvoice[],
+    trx?: Knex.Transaction
+  ) => {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    await Bluebird.each(
+      creditNoteAppliedInvoices,
+      (creditNoteAppliedInvoice: ICreditNoteAppliedToInvoice) => {
+        return SaleInvoice.query(trx)
+          .where('id', creditNoteAppliedInvoice.invoiceId)
+          .increment('creditedAmount', creditNoteAppliedInvoice.amount);
+      }
+    );
+  };
+
+  /**
+   *
+   * @param tenantId
+   * @param invoicesIds
+   * @param amount
+   */
+  public decrementInvoiceCreditedAmount = async (
+    tenantId: number,
+    invoiceId: number,
+    amount: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    await SaleInvoice.query(trx)
+      .findById(invoiceId)
+      .decrement('creditedAmount', amount);
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/CreditNoteApplySyncInvoicesSubscriber.ts b/packages/server/src/services/CreditNotes/CreditNoteApplySyncInvoicesSubscriber.ts
new file mode 100644
index 000000000..3a4e7f59b
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreditNoteApplySyncInvoicesSubscriber.ts
@@ -0,0 +1,65 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import {
+  IApplyCreditToInvoicesCreatedPayload,
+  IApplyCreditToInvoicesDeletedPayload,
+} from '@/interfaces';
+import CreditNoteApplySyncInvoicesCreditedAmount from './CreditNoteApplySyncInvoices';
+
+@Service()
+export default class CreditNoteApplySyncInvoicesCreditedAmountSubscriber {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  syncInvoicesWithCreditNote: CreditNoteApplySyncInvoicesCreditedAmount;
+
+  /**
+   * Attaches events with handlers.
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.creditNote.onApplyToInvoicesCreated,
+      this.incrementAppliedInvoicesOnceCreditCreated
+    );
+    bus.subscribe(
+      events.creditNote.onApplyToInvoicesDeleted,
+      this.decrementAppliedInvoicesOnceCreditDeleted
+    );
+  }
+
+  /**
+   * Increment invoices credited amount once the credit note apply to invoices transaction
+   * @param {IApplyCreditToInvoicesCreatedPayload} payload -
+   */
+  private incrementAppliedInvoicesOnceCreditCreated = async ({
+    trx,
+    tenantId,
+    creditNoteAppliedInvoices,
+  }: IApplyCreditToInvoicesCreatedPayload) => {
+    await this.syncInvoicesWithCreditNote.incrementInvoicesCreditedAmount(
+      tenantId,
+      creditNoteAppliedInvoices,
+      trx
+    );
+  };
+
+  /**
+   *
+   * @param {IApplyCreditToInvoicesDeletedPayload} payload -
+   */
+  private decrementAppliedInvoicesOnceCreditDeleted = async ({
+    trx,
+    creditNoteAppliedToInvoice,
+    tenantId,
+  }: IApplyCreditToInvoicesDeletedPayload) => {
+    // Decrement invoice credited amount.
+    await this.syncInvoicesWithCreditNote.decrementInvoiceCreditedAmount(
+      tenantId,
+      creditNoteAppliedToInvoice.invoiceId,
+      creditNoteAppliedToInvoice.amount,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/CreditNoteApplyToInvoices.ts b/packages/server/src/services/CreditNotes/CreditNoteApplyToInvoices.ts
new file mode 100644
index 000000000..bb951dcb2
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreditNoteApplyToInvoices.ts
@@ -0,0 +1,131 @@
+import { Service, Inject } from 'typedi';
+import Knex from 'knex';
+import { sumBy } from 'lodash';
+import {
+  ICreditNote,
+  ICreditNoteAppliedToInvoice,
+  ICreditNoteAppliedToInvoiceModel,
+  ISaleInvoice,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import PaymentReceiveService from '@/services/Sales/PaymentReceives/PaymentsReceives';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import BaseCreditNotes from './CreditNotes';
+import {
+  IApplyCreditToInvoicesDTO,
+  IApplyCreditToInvoicesCreatedPayload,
+} from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+
+@Service()
+export default class CreditNoteApplyToInvoices extends BaseCreditNotes {
+  @Inject('PaymentReceives')
+  paymentReceive: PaymentReceiveService;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  /**
+   * Apply credit note to the given invoices.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @param {IApplyCreditToInvoicesDTO} applyCreditToInvoicesDTO
+   */
+  public applyCreditNoteToInvoices = async (
+    tenantId: number,
+    creditNoteId: number,
+    applyCreditToInvoicesDTO: IApplyCreditToInvoicesDTO
+  ): Promise<ICreditNoteAppliedToInvoice[]> => {
+    const { CreditNoteAppliedInvoice } = this.tenancy.models(tenantId);
+
+    // Saves the credit note or throw not found service error.
+    const creditNote = await this.getCreditNoteOrThrowError(
+      tenantId,
+      creditNoteId
+    );
+    // Retrieve the applied invoices that associated to the credit note customer.
+    const appliedInvoicesEntries =
+      await this.paymentReceive.validateInvoicesIDsExistance(
+        tenantId,
+        creditNote.customerId,
+        applyCreditToInvoicesDTO.entries
+      );
+    // Transformes apply DTO to model.
+    const creditNoteAppliedModel = this.transformApplyDTOToModel(
+      applyCreditToInvoicesDTO,
+      creditNote
+    );
+    // Validate invoices has remaining amount to apply.
+    this.validateInvoicesRemainingAmount(
+      appliedInvoicesEntries,
+      creditNoteAppliedModel.amount
+    );
+    // Validate the credit note remaining amount.
+    this.validateCreditRemainingAmount(
+      creditNote,
+      creditNoteAppliedModel.amount
+    );
+    // Creates credit note apply to invoice transaction.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Saves the credit note apply to invoice graph to the storage layer.
+      const creditNoteAppliedInvoices =
+        await CreditNoteAppliedInvoice.query().insertGraph(
+          creditNoteAppliedModel.entries
+        );
+      // Triggers `onCreditNoteApplyToInvoiceCreated` event.
+      await this.eventPublisher.emitAsync(
+        events.creditNote.onApplyToInvoicesCreated,
+        {
+          tenantId,
+          creditNote,
+          creditNoteAppliedInvoices,
+          trx,
+        } as IApplyCreditToInvoicesCreatedPayload
+      );
+      return creditNoteAppliedInvoices;
+    });
+  };
+
+  /**
+   * Transformes apply DTO to model.
+   * @param {IApplyCreditToInvoicesDTO} applyDTO
+   * @param {ICreditNote} creditNote
+   * @returns
+   */
+  private transformApplyDTOToModel = (
+    applyDTO: IApplyCreditToInvoicesDTO,
+    creditNote: ICreditNote
+  ): ICreditNoteAppliedToInvoiceModel => {
+    const entries = applyDTO.entries.map((entry) => ({
+      invoiceId: entry.invoiceId,
+      amount: entry.amount,
+      creditNoteId: creditNote.id,
+    }));
+    return {
+      amount: sumBy(entries, 'amount'),
+      entries,
+    };
+  };
+
+  /**
+   * Validate the invoice remaining amount.
+   * @param {ISaleInvoice[]} invoices
+   * @param {number} amount
+   */
+  private validateInvoicesRemainingAmount = (
+    invoices: ISaleInvoice[],
+    amount: number
+  ) => {
+    const invalidInvoices = invoices.filter(
+      (invoice) => invoice.dueAmount < amount
+    );
+    if (invalidInvoices.length > 0) {
+      throw new ServiceError(ERRORS.INVOICES_HAS_NO_REMAINING_AMOUNT);
+    }
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/CreditNoteAutoSerialSubscriber.ts b/packages/server/src/services/CreditNotes/CreditNoteAutoSerialSubscriber.ts
new file mode 100644
index 000000000..64b69d40d
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreditNoteAutoSerialSubscriber.ts
@@ -0,0 +1,30 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import BaseCreditNotes from './CreditNotes';
+import { ICreditNoteCreatedPayload } from '@/interfaces';
+
+@Service()
+export default class CreditNoteAutoSerialSubscriber {
+  @Inject()
+  creditNotesService: BaseCreditNotes;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.creditNote.onCreated,
+      this.autoSerialIncrementOnceCreated
+    );
+  }
+
+  /**
+   * Auto serial increment once credit note created.
+   * @param {ICreditNoteCreatedPayload} payload - 
+   */
+  private autoSerialIncrementOnceCreated = async ({
+    tenantId,
+  }: ICreditNoteCreatedPayload) => {
+    await this.creditNotesService.incrementSerialNumber(tenantId);
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/CreditNoteGLEntries.ts b/packages/server/src/services/CreditNotes/CreditNoteGLEntries.ts
new file mode 100644
index 000000000..697072f3c
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreditNoteGLEntries.ts
@@ -0,0 +1,226 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import * as R from 'ramda';
+import {
+  AccountNormal,
+  IItemEntry,
+  ILedgerEntry,
+  ICreditNote,
+  ILedger,
+  ICreditNoteGLCommonEntry,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import Ledger from '@/services/Accounting/Ledger';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+
+@Service()
+export default class CreditNoteGLEntries {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private ledgerStorage: LedgerStorageService;
+
+  /**
+   * Retrieves the credit note GL.
+   * @param   {ICreditNote} creditNote
+   * @param   {number} receivableAccount
+   * @returns {Ledger}
+   */
+  private getCreditNoteGLedger = (
+    creditNote: ICreditNote,
+    receivableAccount: number
+  ): Ledger => {
+    const ledgerEntries = this.getCreditNoteGLEntries(
+      creditNote,
+      receivableAccount
+    );
+    return new Ledger(ledgerEntries);
+  };
+
+  /**
+   * Saves credit note GL entries.
+   * @param {number} tenantId -
+   * @param {ICreditNote} creditNote - Credit note model.
+   * @param {number} payableAccount - Payable account id.
+   * @param {Knex.Transaction} trx
+   */
+  public saveCreditNoteGLEntries = async (
+    tenantId: number,
+    creditNote: ICreditNote,
+    payableAccount: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const ledger = this.getCreditNoteGLedger(creditNote, payableAccount);
+
+    await this.ledgerStorage.commit(tenantId, ledger, trx);
+  };
+
+  /**
+   * Reverts the credit note associated GL entries.
+   * @param {number} tenantId
+   * @param {number} vendorCreditId
+   * @param {Knex.Transaction} trx
+   */
+  public revertVendorCreditGLEntries = async (
+    tenantId: number,
+    creditNoteId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    await this.ledgerStorage.deleteByReference(
+      tenantId,
+      creditNoteId,
+      'CreditNote',
+      trx
+    );
+  };
+
+  /**
+   * Writes vendor credit associated GL entries.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} creditNoteId - Credit note id.
+   * @param {Knex.Transaction} trx - Knex transactions.
+   */
+  public createVendorCreditGLEntries = async (
+    tenantId: number,
+    creditNoteId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { CreditNote } = this.tenancy.models(tenantId);
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    // Retrieve the credit note with associated entries and items.
+    const creditNoteWithItems = await CreditNote.query(trx)
+      .findById(creditNoteId)
+      .withGraphFetched('entries.item');
+
+    // Retreive the the `accounts receivable` account based on the given currency.
+    const ARAccount = await accountRepository.findOrCreateAccountReceivable(
+      creditNoteWithItems.currencyCode
+    );
+    // Saves the credit note GL entries.
+    await this.saveCreditNoteGLEntries(
+      tenantId,
+      creditNoteWithItems,
+      ARAccount.id,
+      trx
+    );
+  };
+
+  /**
+   * Edits vendor credit associated GL entries.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @param {Knex.Transaction} trx
+   */
+  public editVendorCreditGLEntries = async (
+    tenantId: number,
+    creditNoteId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    // Reverts vendor credit GL entries.
+    await this.revertVendorCreditGLEntries(tenantId, creditNoteId, trx);
+
+    // Creates vendor credit Gl entries.
+    await this.createVendorCreditGLEntries(tenantId, creditNoteId, trx);
+  };
+
+  /**
+   * Retrieve the credit note common entry.
+   * @param   {ICreditNote} creditNote -
+   * @returns {ICreditNoteGLCommonEntry}
+   */
+  private getCreditNoteCommonEntry = (
+    creditNote: ICreditNote
+  ): ICreditNoteGLCommonEntry => {
+    return {
+      date: creditNote.creditNoteDate,
+      userId: creditNote.userId,
+      currencyCode: creditNote.currencyCode,
+      exchangeRate: creditNote.exchangeRate,
+
+      transactionType: 'CreditNote',
+      transactionId: creditNote.id,
+
+      transactionNumber: creditNote.creditNoteNumber,
+      referenceNumber: creditNote.referenceNo,
+
+      createdAt: creditNote.createdAt,
+      indexGroup: 10,
+
+      credit: 0,
+      debit: 0,
+
+      branchId: creditNote.branchId,
+    };
+  };
+
+  /**
+   * Retrieves the creidt note A/R entry.
+   * @param   {ICreditNote} creditNote -
+   * @param   {number} ARAccountId -
+   * @returns {ILedgerEntry}
+   */
+  private getCreditNoteAREntry = (
+    creditNote: ICreditNote,
+    ARAccountId: number
+  ): ILedgerEntry => {
+    const commonEntry = this.getCreditNoteCommonEntry(creditNote);
+
+    return {
+      ...commonEntry,
+      credit: creditNote.localAmount,
+      accountId: ARAccountId,
+      contactId: creditNote.customerId,
+      index: 1,
+      accountNormal: AccountNormal.DEBIT,
+    };
+  };
+
+  /**
+   * Retrieve the credit note item entry.
+   * @param   {ICreditNote} creditNote
+   * @param   {IItemEntry} entry
+   * @param   {number} index
+   * @returns {ILedgerEntry}
+   */
+  private getCreditNoteItemEntry = R.curry(
+    (
+      creditNote: ICreditNote,
+      entry: IItemEntry,
+      index: number
+    ): ILedgerEntry => {
+      const commonEntry = this.getCreditNoteCommonEntry(creditNote);
+      const localAmount = entry.amount * creditNote.exchangeRate;
+
+      return {
+        ...commonEntry,
+        debit: localAmount,
+        accountId: entry.sellAccountId || entry.item.sellAccountId,
+        note: entry.description,
+        index: index + 2,
+        itemId: entry.itemId,
+        itemQuantity: entry.quantity,
+        accountNormal: AccountNormal.CREDIT,
+      };
+    }
+  );
+
+  /**
+   * Retrieve the credit note GL entries.
+   * @param   {ICreditNote} creditNote - Credit note.
+   * @param   {IAccount} receivableAccount - Receviable account.
+   * @returns {ILedgerEntry[]} - Ledger entries.
+   */
+  public getCreditNoteGLEntries = (
+    creditNote: ICreditNote,
+    ARAccountId: number
+  ): ILedgerEntry[] => {
+    const AREntry = this.getCreditNoteAREntry(creditNote, ARAccountId);
+
+    const getItemEntry = this.getCreditNoteItemEntry(creditNote);
+    const itemsEntries = creditNote.entries.map(getItemEntry);
+
+    return [AREntry, ...itemsEntries];
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/CreditNoteGLEntriesSubscriber.ts b/packages/server/src/services/CreditNotes/CreditNoteGLEntriesSubscriber.ts
new file mode 100644
index 000000000..6df5d0322
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreditNoteGLEntriesSubscriber.ts
@@ -0,0 +1,118 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  ICreditNoteCreatedPayload,
+  ICreditNoteDeletedPayload,
+  ICreditNoteEditedPayload,
+  ICreditNoteOpenedPayload,
+  IRefundCreditNoteOpenedPayload,
+} from '@/interfaces';
+import CreditNoteGLEntries from './CreditNoteGLEntries';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export default class CreditNoteGLEntriesSubscriber {
+  @Inject()
+  creditNoteGLEntries: CreditNoteGLEntries;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.creditNote.onCreated,
+      this.writeGlEntriesOnceCreditNoteCreated
+    );
+    bus.subscribe(
+      events.creditNote.onOpened,
+      this.writeGLEntriesOnceCreditNoteOpened
+    );
+    bus.subscribe(
+      events.creditNote.onEdited,
+      this.editVendorCreditGLEntriesOnceEdited
+    );
+    bus.subscribe(
+      events.creditNote.onDeleted,
+      this.revertGLEntriesOnceCreditNoteDeleted
+    );
+  }
+
+  /**
+   * Writes the GL entries once the credit note transaction created or open.
+   * @private
+   * @param {ICreditNoteCreatedPayload|ICreditNoteOpenedPayload} payload -
+   */
+  private writeGlEntriesOnceCreditNoteCreated = async ({
+    tenantId,
+    creditNote,
+    creditNoteId,
+    trx,
+  }: ICreditNoteCreatedPayload | ICreditNoteOpenedPayload) => {
+    // Can't continue if the credit note is not published yet.
+    if (!creditNote.isPublished) return;
+
+    await this.creditNoteGLEntries.createVendorCreditGLEntries(
+      tenantId,
+      creditNoteId,
+      trx
+    );
+  };
+
+  /**
+   * Writes the GL entries once the vendor credit transaction opened.
+   * @param {ICreditNoteOpenedPayload} payload
+   */
+  private writeGLEntriesOnceCreditNoteOpened = async ({
+    tenantId,
+    creditNoteId,
+    trx,
+  }: ICreditNoteOpenedPayload) => {
+    await this.creditNoteGLEntries.createVendorCreditGLEntries(
+      tenantId,
+      creditNoteId,
+      trx
+    );
+  };
+
+  /**
+   * Reverts GL entries once credit note deleted.
+   */
+  private revertGLEntriesOnceCreditNoteDeleted = async ({
+    tenantId,
+    oldCreditNote,
+    creditNoteId,
+    trx,
+  }: ICreditNoteDeletedPayload) => {
+    // Can't continue if the credit note is not published yet.
+    if (!oldCreditNote.isPublished) return;
+
+    await this.creditNoteGLEntries.revertVendorCreditGLEntries(
+      tenantId,
+      creditNoteId
+    );
+  };
+
+  /**
+   * Edits vendor credit associated GL entries once the transaction edited.
+   * @param {ICreditNoteEditedPayload} payload -
+   */
+  private editVendorCreditGLEntriesOnceEdited = async ({
+    tenantId,
+    creditNote,
+    creditNoteId,
+    trx,
+  }: ICreditNoteEditedPayload) => {
+    // Can't continue if the credit note is not published yet.
+    if (!creditNote.isPublished) return;
+
+    await this.creditNoteGLEntries.editVendorCreditGLEntries(
+      tenantId,
+      creditNoteId,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/CreditNoteInventoryTransactionsSubscriber.ts b/packages/server/src/services/CreditNotes/CreditNoteInventoryTransactionsSubscriber.ts
new file mode 100644
index 000000000..7b23d079d
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreditNoteInventoryTransactionsSubscriber.ts
@@ -0,0 +1,99 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import CreditNoteInventoryTransactions from './CreditNotesInventoryTransactions';
+import {
+  ICreditNoteCreatedPayload,
+  ICreditNoteDeletedPayload,
+  ICreditNoteEditedPayload,
+} from '@/interfaces';
+
+@Service()
+export default class CreditNoteInventoryTransactionsSubscriber {
+  @Inject()
+  inventoryTransactions: CreditNoteInventoryTransactions;
+
+  /**
+   * Attaches events with publisher.
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.creditNote.onCreated,
+      this.writeInventoryTranscationsOnceCreated
+    );
+    bus.subscribe(
+      events.creditNote.onEdited,
+      this.rewriteInventoryTransactionsOnceEdited
+    );
+    bus.subscribe(
+      events.creditNote.onDeleted,
+      this.revertInventoryTransactionsOnceDeleted
+    );
+    bus.subscribe(
+      events.creditNote.onOpened,
+      this.writeInventoryTranscationsOnceCreated
+    );
+  }
+
+  /**
+   * Writes inventory transactions once credit note created.
+   * @param {ICreditNoteCreatedPayload} payload -
+   */
+  public writeInventoryTranscationsOnceCreated = async ({
+    tenantId,
+    creditNote,
+    trx,
+  }: ICreditNoteCreatedPayload) => {
+    // Can't continue if the credit note is open yet.
+    if (!creditNote.isOpen) {
+      return;
+    }
+    await this.inventoryTransactions.createInventoryTransactions(
+      tenantId,
+      creditNote,
+      trx
+    );
+  };
+
+  /**
+   * Rewrites inventory transactions once credit note edited.
+   * @param {ICreditNoteEditedPayload} payload -
+   */
+  public rewriteInventoryTransactionsOnceEdited = async ({
+    tenantId,
+    creditNoteId,
+    creditNote,
+    trx,
+  }: ICreditNoteEditedPayload) => {
+    // Can't continue if the credit note is open yet.
+    if (!creditNote.isOpen) {
+      return;
+    }
+    await this.inventoryTransactions.editInventoryTransactions(
+      tenantId,
+      creditNoteId,
+      creditNote,
+      trx
+    );
+  };
+
+  /**
+   * Reverts inventory transactions once credit note deleted.
+   * @param {ICreditNoteDeletedPayload} payload -
+   */
+  public revertInventoryTransactionsOnceDeleted = async ({
+    tenantId,
+    creditNoteId,
+    oldCreditNote,
+    trx,
+  }: ICreditNoteDeletedPayload) => {
+    // Can't continue if the credit note is open yet.
+    if (!oldCreditNote.isOpen) {
+      return;
+    }
+    await this.inventoryTransactions.deleteInventoryTransactions(
+      tenantId,
+      creditNoteId,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/CreditNoteTransformer.ts b/packages/server/src/services/CreditNotes/CreditNoteTransformer.ts
new file mode 100644
index 000000000..79d731ce3
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreditNoteTransformer.ts
@@ -0,0 +1,59 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class CreditNoteTransformer extends Transformer {
+  /**
+   * Include these attributes to sale credit note object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedCreditsRemaining',
+      'formattedCreditNoteDate',
+      'formattedAmount',
+      'formattedCreditsUsed'
+    ];
+  };
+
+  /**
+   * Retrieve formatted credit note date.
+   * @param {ICreditNote} credit
+   * @returns {String}
+   */
+  protected formattedCreditNoteDate = (credit): string => {
+    return this.formatDate(credit.creditNoteDate);
+  };
+
+  /**
+   * Retrieve formatted invoice amount.
+   * @param {ICreditNote} credit
+   * @returns {string}
+   */
+  protected formattedAmount = (credit): string => {
+    return formatNumber(credit.amount, {
+      currencyCode: credit.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve formatted credits remaining.
+   * @param {ICreditNote} credit
+   * @returns {string}
+   */
+  protected formattedCreditsRemaining = (credit) => {
+    return formatNumber(credit.creditsRemaining, {
+      currencyCode: credit.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve formatted credits used.
+   * @param {ICreditNote} credit
+   * @returns {string}
+   */
+   protected formattedCreditsUsed = (credit) => {
+    return formatNumber(credit.creditsUsed, {
+      currencyCode: credit.currencyCode,
+    });
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/CreditNoteWithInvoicesToApplyTransformer.ts b/packages/server/src/services/CreditNotes/CreditNoteWithInvoicesToApplyTransformer.ts
new file mode 100644
index 000000000..9a2f5c222
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreditNoteWithInvoicesToApplyTransformer.ts
@@ -0,0 +1,69 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class CreditNoteWithInvoicesToApplyTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedInvoiceDate',
+      'formattedDueDate',
+      'formattedAmount',
+      'formattedDueAmount',
+      'formattedPaymentAmount',
+    ];
+  };
+
+  /**
+   * Retrieve formatted invoice date.
+   * @param {ISaleInvoice} invoice
+   * @returns {String}
+   */
+  protected formattedInvoiceDate = (invoice): string => {
+    return this.formatDate(invoice.invoiceDate);
+  };
+
+  /**
+   * Retrieve formatted due date.
+   * @param {ISaleInvoice} invoice
+   * @returns {string}
+   */
+  protected formattedDueDate = (invoice): string => {
+    return this.formatDate(invoice.dueDate);
+  };
+
+  /**
+   * Retrieve formatted invoice amount.
+   * @param {ISaleInvoice} invoice
+   * @returns {string}
+   */
+  protected formattedAmount = (invoice): string => {
+    return formatNumber(invoice.balance, {
+      currencyCode: invoice.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve formatted invoice due amount.
+   * @param {ISaleInvoice} invoice
+   * @returns {string}
+   */
+  protected formattedDueAmount = (invoice): string => {
+    return formatNumber(invoice.dueAmount, {
+      currencyCode: invoice.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve formatted payment amount.
+   * @param {ISaleInvoice} invoice
+   * @returns {string}
+   */
+  protected formattedPaymentAmount = (invoice): string => {
+    return formatNumber(invoice.paymentAmount, {
+      currencyCode: invoice.currencyCode,
+    });
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/CreditNotes.ts b/packages/server/src/services/CreditNotes/CreditNotes.ts
new file mode 100644
index 000000000..f5485ad08
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreditNotes.ts
@@ -0,0 +1,134 @@
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import { omit } from 'lodash';
+import * as R from 'ramda';
+import { ServiceError } from '@/exceptions';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ERRORS } from './constants';
+import { ICreditNote, ICreditNoteEditDTO, ICreditNoteNewDTO } from '@/interfaces';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+import AutoIncrementOrdersService from '@/services/Sales/AutoIncrementOrdersService';
+import { WarehouseTransactionDTOTransform } from '@/services/Warehouses/Integrations/WarehouseTransactionDTOTransform';
+import { BranchTransactionDTOTransform } from '@/services/Branches/Integrations/BranchTransactionDTOTransform';
+
+@Service()
+export default class BaseCreditNotes {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private itemsEntriesService: ItemsEntriesService;
+
+  @Inject()
+  private autoIncrementOrdersService: AutoIncrementOrdersService;
+
+  @Inject()
+  private branchDTOTransform: BranchTransactionDTOTransform;
+
+  @Inject()
+  private warehouseDTOTransform: WarehouseTransactionDTOTransform;
+
+  /**
+   * Transformes the credit/edit DTO to model.
+   * @param {ICreditNoteNewDTO | ICreditNoteEditDTO} creditNoteDTO
+   * @param {string} customerCurrencyCode -
+   */
+  protected transformCreateEditDTOToModel = (
+    tenantId: number,
+    creditNoteDTO: ICreditNoteNewDTO | ICreditNoteEditDTO,
+    customerCurrencyCode: string,
+    oldCreditNote?: ICreditNote
+  ): ICreditNote => {
+    // Retrieve the total amount of the given items entries.
+    const amount = this.itemsEntriesService.getTotalItemsEntries(
+      creditNoteDTO.entries
+    );
+    const entries = creditNoteDTO.entries.map((entry) => ({
+      ...entry,
+      referenceType: 'CreditNote',
+    }));
+    // Retreive the next credit note number.
+    const autoNextNumber = this.getNextCreditNumber(tenantId);
+
+    // Detarmines the credit note number.
+    const creditNoteNumber =
+      creditNoteDTO.creditNoteNumber ||
+      oldCreditNote?.creditNoteNumber ||
+      autoNextNumber;
+
+    const initialDTO = {
+      ...omit(creditNoteDTO, ['open']),
+      creditNoteNumber,
+      amount,
+      currencyCode: customerCurrencyCode,
+      exchangeRate: creditNoteDTO.exchangeRate || 1,
+      entries,
+      ...(creditNoteDTO.open &&
+        !oldCreditNote?.openedAt && {
+          openedAt: moment().toMySqlDateTime(),
+        }),
+      refundedAmount: 0,
+      invoicesAmount: 0,
+    };
+    return R.compose(
+      this.branchDTOTransform.transformDTO<ICreditNote>(tenantId),
+      this.warehouseDTOTransform.transformDTO<ICreditNote>(tenantId)
+    )(initialDTO);
+  };
+
+  /**
+   * Retrieve the given credit note or throw not found service error.
+   * @param {number} tenantId -
+   * @param {number} creditNoteId -
+   */
+  protected getCreditNoteOrThrowError = async (
+    tenantId: number,
+    creditNoteId: number
+  ) => {
+    const { CreditNote } = this.tenancy.models(tenantId);
+
+    const creditNote = await CreditNote.query().findById(creditNoteId);
+
+    if (!creditNote) {
+      throw new ServiceError(ERRORS.CREDIT_NOTE_NOT_FOUND);
+    }
+    return creditNote;
+  };
+
+  /**
+   * Retrieve the next unique credit number.
+   * @param  {number} tenantId - Tenant id.
+   * @return {string}
+   */
+  private getNextCreditNumber = (tenantId: number): string => {
+    return this.autoIncrementOrdersService.getNextTransactionNumber(
+      tenantId,
+      'credit_note'
+    );
+  };
+
+  /**
+   * Increment the credit note serial next number.
+   * @param {number} tenantId -
+   */
+  public incrementSerialNumber = (tenantId: number) => {
+    return this.autoIncrementOrdersService.incrementSettingsNextNumber(
+      tenantId,
+      'credit_note'
+    );
+  };
+
+  /**
+   * Validate the credit note remaining amount.
+   * @param {ICreditNote} creditNote
+   * @param {number} amount
+   */
+  public validateCreditRemainingAmount = (
+    creditNote: ICreditNote,
+    amount: number
+  ) => {
+    if (creditNote.creditsRemaining < amount) {
+      throw new ServiceError(ERRORS.CREDIT_NOTE_HAS_NO_REMAINING_AMOUNT);
+    }
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/CreditNotesInventoryTransactions.ts b/packages/server/src/services/CreditNotes/CreditNotesInventoryTransactions.ts
new file mode 100644
index 000000000..175b640b6
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/CreditNotesInventoryTransactions.ts
@@ -0,0 +1,90 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import { ICreditNote } from '@/interfaces';
+import InventoryService from '@/services/Inventory/Inventory';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+
+@Service()
+export default class CreditNoteInventoryTransactions {
+  @Inject()
+  inventoryService: InventoryService;
+
+  @Inject()
+  itemsEntriesService: ItemsEntriesService;
+
+  /**
+   * Creates credit note inventory transactions.
+   * @param {number} tenantId
+   * @param {ICreditNote} creditNote
+   */
+  public createInventoryTransactions = async (
+    tenantId: number,
+    creditNote: ICreditNote,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    // Loads the inventory items entries of the given sale invoice.
+    const inventoryEntries =
+      await this.itemsEntriesService.filterInventoryEntries(
+        tenantId,
+        creditNote.entries
+      );
+    const transaction = {
+      transactionId: creditNote.id,
+      transactionType: 'CreditNote',
+      transactionNumber: creditNote.creditNoteNumber,
+      exchangeRate: creditNote.exchangeRate,
+      date: creditNote.creditNoteDate,
+      direction: 'IN',
+      entries: inventoryEntries,
+      createdAt: creditNote.createdAt,
+      warehouseId: creditNote.warehouseId,
+    };
+    // Writes inventory tranactions.
+    await this.inventoryService.recordInventoryTransactionsFromItemsEntries(
+      tenantId,
+      transaction,
+      false,
+      trx
+    );
+  };
+
+  /**
+   * Edits vendor credit assocaited inventory transactions.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @param {ICreditNote} creditNote
+   * @param {Knex.Transactions} trx
+   */
+  public editInventoryTransactions = async (
+    tenantId: number,
+    creditNoteId: number,
+    creditNote: ICreditNote,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    // Deletes inventory transactions.
+    await this.deleteInventoryTransactions(tenantId, creditNoteId, trx);
+
+    // Re-write inventory transactions.
+    await this.createInventoryTransactions(tenantId, creditNote, trx);
+  };
+
+  /**
+   * Deletes credit note associated inventory transactions.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} creditNoteId - Credit note id.
+   * @param {Knex.Transaction} trx -
+   */
+  public deleteInventoryTransactions = async (
+    tenantId: number,
+    creditNoteId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    // Deletes the inventory transactions by the given reference id and type.
+    await this.inventoryService.deleteInventoryTransactions(
+      tenantId,
+      creditNoteId,
+      'CreditNote',
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/DeleteCreditNote.ts b/packages/server/src/services/CreditNotes/DeleteCreditNote.ts
new file mode 100644
index 000000000..db53474ca
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/DeleteCreditNote.ts
@@ -0,0 +1,119 @@
+import Knex from 'knex';
+import { Inject, Service } from 'typedi';
+import UnitOfWork from '@/services/UnitOfWork';
+import BaseCreditNotes from './CreditNotes';
+import { ICreditNoteDeletedPayload, ICreditNoteDeletingPayload } from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+import RefundCreditNote from './RefundCreditNote';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+
+@Service()
+export default class DeleteCreditNote extends BaseCreditNotes {
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  refundCreditNote: RefundCreditNote;
+
+  /**
+   * Deletes the given credit note transactions.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @returns {Promise<void>}
+   */
+  public deleteCreditNote = async (
+    tenantId: number,
+    creditNoteId: number
+  ): Promise<void> => {
+    const { CreditNote, ItemEntry } = this.tenancy.models(tenantId);
+
+    // Retrieve the credit note or throw not found service error.
+    const oldCreditNote = await this.getCreditNoteOrThrowError(
+      tenantId,
+      creditNoteId
+    );
+    // Validate credit note has no refund transactions.
+    await this.validateCreditNoteHasNoRefundTransactions(
+      tenantId,
+      creditNoteId
+    );
+    // Validate credit note has no applied invoices transactions.
+    await this.validateCreditNoteHasNoApplyInvoiceTransactions(
+      tenantId,
+      creditNoteId
+    );
+    // Deletes the credit note transactions under unit-of-work transaction.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onCreditNoteDeleting` event.
+      await this.eventPublisher.emitAsync(events.creditNote.onDeleting, {
+        trx,
+        tenantId,
+        oldCreditNote
+      } as ICreditNoteDeletingPayload);
+
+      // Delets the associated credit note entries.
+      await ItemEntry.query(trx)
+        .where('reference_id', creditNoteId)
+        .where('reference_type', 'CreditNote')
+        .delete();
+
+      // Deletes the credit note transaction.
+      await CreditNote.query(trx).findById(creditNoteId).delete();
+
+      // Triggers `onCreditNoteDeleted` event.
+      await this.eventPublisher.emitAsync(events.creditNote.onDeleted, {
+        tenantId,
+        oldCreditNote,
+        creditNoteId,
+        trx,
+      } as ICreditNoteDeletedPayload);
+    });
+  };
+
+  /**
+   * Validates credit note has no associated refund transactions.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @returns {Promise<void>}
+   */
+  private validateCreditNoteHasNoRefundTransactions = async (
+    tenantId: number,
+    creditNoteId: number
+  ): Promise<void> => {
+    const { RefundCreditNote } = this.tenancy.models(tenantId);
+
+    const refundTransactions = await RefundCreditNote.query().where(
+      'creditNoteId',
+      creditNoteId
+    );
+    if (refundTransactions.length > 0) {
+      throw new ServiceError(ERRORS.CREDIT_NOTE_HAS_REFUNDS_TRANSACTIONS);
+    }
+  };
+
+  /**
+   * Validate credit note has no associated applied invoices transactions.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} creditNoteId - Credit note id.
+   * @returns {Promise<void>}
+   */
+  private validateCreditNoteHasNoApplyInvoiceTransactions = async (
+    tenantId: number,
+    creditNoteId: number
+  ) => {
+    const { CreditNoteAppliedInvoice } = this.tenancy.models(tenantId);
+
+    const appliedTransactions = await CreditNoteAppliedInvoice.query().where(
+      'creditNoteId',
+      creditNoteId
+    );
+    if (appliedTransactions.length > 0) {
+      throw new ServiceError(ERRORS.CREDIT_NOTE_HAS_APPLIED_INVOICES);
+    }
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/DeleteCreditNoteApplyToInvoices.ts b/packages/server/src/services/CreditNotes/DeleteCreditNoteApplyToInvoices.ts
new file mode 100644
index 000000000..33b21c873
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/DeleteCreditNoteApplyToInvoices.ts
@@ -0,0 +1,65 @@
+import { Service, Inject } from 'typedi';
+import Knex from 'knex';
+import { IApplyCreditToInvoicesDeletedPayload } from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import PaymentReceiveService from '@/services/Sales/PaymentReceives/PaymentsReceives';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import BaseCreditNotes from './CreditNotes';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+
+@Service()
+export default class DeletreCreditNoteApplyToInvoices extends BaseCreditNotes {
+  @Inject('PaymentReceives')
+  paymentReceive: PaymentReceiveService;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  /**
+   * Apply credit note to the given invoices.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @param {IApplyCreditToInvoicesDTO} applyCreditToInvoicesDTO
+   */
+  public deleteApplyCreditNoteToInvoices = async (
+    tenantId: number,
+    applyCreditToInvoicesId: number
+  ): Promise<void> => {
+    const { CreditNoteAppliedInvoice } = this.tenancy.models(tenantId);
+
+    const creditNoteAppliedToInvoice =
+      await CreditNoteAppliedInvoice.query().findById(applyCreditToInvoicesId);
+
+    if (!creditNoteAppliedToInvoice) {
+      throw new ServiceError(ERRORS.CREDIT_NOTE_APPLY_TO_INVOICES_NOT_FOUND);
+    }
+    // Retrieve the credit note or throw not found service error.
+    const creditNote = await this.getCreditNoteOrThrowError(
+      tenantId,
+      creditNoteAppliedToInvoice.creditNoteId
+    );
+    // Creates credit note apply to invoice transaction.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Delete credit note applied to invoices.
+      await CreditNoteAppliedInvoice.query(trx)
+        .findById(applyCreditToInvoicesId)
+        .delete();
+
+      // Triggers `onCreditNoteApplyToInvoiceDeleted` event.
+      await this.eventPublisher.emitAsync(
+        events.creditNote.onApplyToInvoicesDeleted,
+        {
+          trx,
+          creditNote,
+          creditNoteAppliedToInvoice,
+          tenantId,
+        } as IApplyCreditToInvoicesDeletedPayload
+      );
+    });
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/DeleteCustomerLinkedCreditNote.ts b/packages/server/src/services/CreditNotes/DeleteCustomerLinkedCreditNote.ts
new file mode 100644
index 000000000..cb4d75007
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/DeleteCustomerLinkedCreditNote.ts
@@ -0,0 +1,30 @@
+import { Inject, Service } from 'typedi';
+import { ServiceError } from '@/exceptions';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import { ERRORS } from './constants';
+
+@Service()
+export default class DeleteCustomerLinkedCreidtNote {
+  @Inject()
+  tenancy: TenancyService;
+
+  /**
+   * Validate the given customer has no linked credit note transactions.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   */
+  public validateCustomerHasNoCreditTransaction = async (
+    tenantId: number,
+    customerId: number
+  ) => {
+    const { CreditNote } = this.tenancy.models(tenantId);
+
+    const associatedCredits = await CreditNote.query().where(
+      'customerId',
+      customerId
+    );
+    if (associatedCredits.length > 0) {
+      throw new ServiceError(ERRORS.CUSTOMER_HAS_LINKED_CREDIT_NOTES);
+    }
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/DeleteCustomerLinkedCreditSubscriber.ts b/packages/server/src/services/CreditNotes/DeleteCustomerLinkedCreditSubscriber.ts
new file mode 100644
index 000000000..4f1727c5c
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/DeleteCustomerLinkedCreditSubscriber.ts
@@ -0,0 +1,48 @@
+import { Inject, Service } from 'typedi';
+import { ServiceError } from '@/exceptions';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import { ICustomerDeletingPayload } from '@/interfaces';
+import DeleteCustomerLinkedCreidtNote from './DeleteCustomerLinkedCreditNote';
+
+const ERRORS = {
+  CUSTOMER_HAS_TRANSACTIONS: 'CUSTOMER_HAS_TRANSACTIONS',
+};
+
+@Service()
+export default class DeleteCustomerLinkedCreditSubscriber {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  deleteCustomerLinkedCredit: DeleteCustomerLinkedCreidtNote;
+
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.customers.onDeleting,
+      this.validateCustomerHasNoLinkedCreditsOnDeleting
+    );
+  };
+
+  /**
+   * Validate vendor has no assocaited credit transaction once the vendor deleting.
+   * @param {IVendorEventDeletingPayload} payload -
+   */
+  public validateCustomerHasNoLinkedCreditsOnDeleting = async ({
+    tenantId,
+    customerId,
+  }: ICustomerDeletingPayload) => {
+    try {
+      await this.deleteCustomerLinkedCredit.validateCustomerHasNoCreditTransaction(
+        tenantId,
+        customerId
+      );
+    } catch (error) {
+      throw new ServiceError(ERRORS.CUSTOMER_HAS_TRANSACTIONS);
+    }
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/DeleteRefundCreditNote.ts b/packages/server/src/services/CreditNotes/DeleteRefundCreditNote.ts
new file mode 100644
index 000000000..adc2c6fa6
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/DeleteRefundCreditNote.ts
@@ -0,0 +1,73 @@
+import Knex from 'knex';
+import {
+  IRefundCreditNoteDeletedPayload,
+  IRefundCreditNoteDeletingPayload,
+  IRefundVendorCreditDeletedPayload,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import { Inject, Service } from 'typedi';
+import RefundCreditNote from './RefundCreditNote';
+
+@Service()
+export default class DeleteRefundCreditNote extends RefundCreditNote {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  /**
+   * Retrieve the credit note graph.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @returns
+   */
+  public deleteCreditNoteRefund = async (
+    tenantId: number,
+    refundCreditId: number
+  ) => {
+    const { RefundCreditNote } = this.tenancy.models(tenantId);
+
+    // Retrieve the old credit note or throw not found service error.
+    const oldRefundCredit = await this.getCreditNoteRefundOrThrowError(
+      tenantId,
+      refundCreditId
+    );
+    // Triggers `onCreditNoteRefundDeleted` event.
+    await this.eventPublisher.emitAsync(events.creditNote.onRefundDelete, {
+      refundCreditId,
+      oldRefundCredit,
+      tenantId,
+    } as IRefundCreditNoteDeletedPayload);
+
+    // Deletes refund credit note transactions with associated entries.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      const eventPayload = {
+        trx,
+        refundCreditId,
+        oldRefundCredit,
+        tenantId,
+      } as IRefundCreditNoteDeletedPayload | IRefundCreditNoteDeletingPayload;
+
+      // Triggers `onCreditNoteRefundDeleting` event.
+      await this.eventPublisher.emitAsync(
+        events.creditNote.onRefundDeleting,
+        eventPayload
+      );
+      // Deletes the refund credit note graph from the storage.
+      await RefundCreditNote.query(trx).findById(refundCreditId).delete();
+
+      // Triggers `onCreditNoteRefundDeleted` event.
+      await this.eventPublisher.emitAsync(
+        events.creditNote.onRefundDeleted,
+        eventPayload as IRefundVendorCreditDeletedPayload
+      );
+    });
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/EditCreditNote.ts b/packages/server/src/services/CreditNotes/EditCreditNote.ts
new file mode 100644
index 000000000..074115c04
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/EditCreditNote.ts
@@ -0,0 +1,100 @@
+import {
+  ICreditNoteEditDTO,
+  ICreditNoteEditedPayload,
+  ICreditNoteEditingPayload,
+} from '@/interfaces';
+import { Knex } from 'knex';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import { Inject, Service } from 'typedi';
+import BaseCreditNotes from './CreditNotes';
+
+@Service()
+export default class EditCreditNote extends BaseCreditNotes {
+  @Inject()
+  itemsEntriesService: ItemsEntriesService;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  /**
+   * Edits the given credit note.
+   * @param {number} tenantId -
+   * @param {ICreditNoteEditDTO} creditNoteEditDTO -
+   */
+  public editCreditNote = async (
+    tenantId: number,
+    creditNoteId: number,
+    creditNoteEditDTO: ICreditNoteEditDTO
+  ) => {
+    const { CreditNote, Contact } = this.tenancy.models(tenantId);
+
+    // Retrieve the sale invoice or throw not found service error.
+    const oldCreditNote = await this.getCreditNoteOrThrowError(
+      tenantId,
+      creditNoteId
+    );
+    // Validate customer existance.
+    const customer = await Contact.query()
+      .modify('customer')
+      .findById(creditNoteEditDTO.customerId)
+      .throwIfNotFound();
+
+    // Validate items ids existance.
+    await this.itemsEntriesService.validateItemsIdsExistance(
+      tenantId,
+      creditNoteEditDTO.entries
+    );
+    // Validate non-sellable entries items.
+    await this.itemsEntriesService.validateNonSellableEntriesItems(
+      tenantId,
+      creditNoteEditDTO.entries
+    );
+    // Validate the items entries existance.
+    await this.itemsEntriesService.validateEntriesIdsExistance(
+      tenantId,
+      creditNoteId,
+      'CreditNote',
+      creditNoteEditDTO.entries
+    );
+    // Transformes the given DTO to storage layer data.
+    const creditNoteModel = this.transformCreateEditDTOToModel(
+      tenantId,
+      creditNoteEditDTO,
+      customer.currencyCode,
+      oldCreditNote
+    );
+    // Sales the credit note transactions with associated entries.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onCreditNoteEditing` event.
+      await this.eventPublisher.emitAsync(events.creditNote.onEditing, {
+        creditNoteEditDTO,
+        oldCreditNote,
+        trx,
+        tenantId,
+      } as ICreditNoteEditingPayload);
+
+      // Saves the credit note graph to the storage.
+      const creditNote = await CreditNote.query(trx).upsertGraph({
+        id: creditNoteId,
+        ...creditNoteModel,
+      });
+      // Triggers `onCreditNoteEdited` event.
+      await this.eventPublisher.emitAsync(events.creditNote.onEdited, {
+        trx,
+        oldCreditNote,
+        creditNoteId,
+        creditNote,
+        creditNoteEditDTO,
+        tenantId,
+      } as ICreditNoteEditedPayload);
+
+      return creditNote;
+    });
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/GetCreditNote.ts b/packages/server/src/services/CreditNotes/GetCreditNote.ts
new file mode 100644
index 000000000..95dd044fd
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/GetCreditNote.ts
@@ -0,0 +1,43 @@
+import { ServiceError } from '@/exceptions';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+import { ERRORS } from './constants';
+import BaseCreditNotes from './CreditNotes';
+import { CreditNoteTransformer } from './CreditNoteTransformer';
+
+@Service()
+export default class GetCreditNote extends BaseCreditNotes {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the credit note graph.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @returns
+   */
+  public getCreditNote = async (tenantId: number, creditNoteId: number) => {
+    const { CreditNote } = this.tenancy.models(tenantId);
+
+    // Retrieve the vendor credit model graph.
+    const creditNote = await CreditNote.query()
+      .findById(creditNoteId)
+      .withGraphFetched('entries.item')
+      .withGraphFetched('customer')
+      .withGraphFetched('branch');
+
+    if (!creditNote) {
+      throw new ServiceError(ERRORS.CREDIT_NOTE_NOT_FOUND);
+    }
+    // Transforms the credit note model to POJO.
+    return this.transformer.transform(
+      tenantId,
+      creditNote,
+      new CreditNoteTransformer(),
+    );
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/GetCreditNoteAssociatedAppliedInvoices.ts b/packages/server/src/services/CreditNotes/GetCreditNoteAssociatedAppliedInvoices.ts
new file mode 100644
index 000000000..925dc4c92
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/GetCreditNoteAssociatedAppliedInvoices.ts
@@ -0,0 +1,41 @@
+import { Inject, Service } from 'typedi';
+import { ISaleInvoice } from '@/interfaces';
+import BaseCreditNotes from './CreditNotes';
+import { CreditNoteAppliedInvoiceTransformer } from './CreditNoteAppliedInvoiceTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export default class GetCreditNoteAssociatedAppliedInvoices extends BaseCreditNotes {
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve credit note associated invoices to apply.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @returns {Promise<ISaleInvoice[]>}
+   */
+  public getCreditAssociatedAppliedInvoices = async (
+    tenantId: number,
+    creditNoteId: number
+  ): Promise<ISaleInvoice[]> => {
+    const { CreditNoteAppliedInvoice } = this.tenancy.models(tenantId);
+
+    // Retireve credit note or throw not found service error.
+    const creditNote = await this.getCreditNoteOrThrowError(
+      tenantId,
+      creditNoteId
+    );
+    const appliedToInvoices = await CreditNoteAppliedInvoice.query()
+      .where('credit_note_id', creditNoteId)
+      .withGraphFetched('saleInvoice')
+      .withGraphFetched('creditNote');
+
+    // Transformes credit note applied to invoices.
+    return this.transformer.transform(
+      tenantId,
+      appliedToInvoices,
+      new CreditNoteAppliedInvoiceTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/GetCreditNoteAssociatedInvoicesToApply.ts b/packages/server/src/services/CreditNotes/GetCreditNoteAssociatedInvoicesToApply.ts
new file mode 100644
index 000000000..30b44a23f
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/GetCreditNoteAssociatedInvoicesToApply.ts
@@ -0,0 +1,42 @@
+import { Service, Inject } from 'typedi';
+import BaseCreditNotes from './CreditNotes';
+import { ISaleInvoice } from '@/interfaces';
+import { CreditNoteWithInvoicesToApplyTransformer } from './CreditNoteWithInvoicesToApplyTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export default class GetCreditNoteAssociatedInvoicesToApply extends BaseCreditNotes {
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve credit note associated invoices to apply.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @returns {Promise<ISaleInvoice[]>}
+   */
+  public getCreditAssociatedInvoicesToApply = async (
+    tenantId: number,
+    creditNoteId: number
+  ): Promise<ISaleInvoice[]> => {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    // Retireve credit note or throw not found service error.
+    const creditNote = await this.getCreditNoteOrThrowError(
+      tenantId,
+      creditNoteId
+    );
+    // Retrieves the published due invoices that associated to the given customer.
+    const saleInvoices = await SaleInvoice.query()
+      .where('customerId', creditNote.customerId)
+      .modify('dueInvoices')
+      .modify('published');
+
+    // Transformes the sale invoices models to POJO.
+    return this.transformer.transform(
+      tenantId,
+      saleInvoices,
+      new CreditNoteWithInvoicesToApplyTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/GetCreditNotePdf.ts b/packages/server/src/services/CreditNotes/GetCreditNotePdf.ts
new file mode 100644
index 000000000..15ab728c5
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/GetCreditNotePdf.ts
@@ -0,0 +1,37 @@
+import { Inject, Service } from 'typedi';
+import PdfService from '@/services/PDF/PdfService';
+import { templateRender } from 'utils';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Tenant } from '@/system/models';
+
+@Service()
+export default class GetCreditNotePdf {
+  @Inject()
+  pdfService: PdfService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve sale invoice pdf content.
+   * @param {} saleInvoice -
+   */
+  async getCreditNotePdf(tenantId: number, creditNote) {
+    const i18n = this.tenancy.i18n(tenantId);
+
+    const organization = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const htmlContent = templateRender('modules/credit-note-standard', {
+      organization,
+      organizationName: organization.metadata.name,
+      organizationEmail: organization.metadata.email,
+      creditNote,
+      ...i18n,
+    });
+    const pdfContent = await this.pdfService.pdfDocument(htmlContent);
+
+    return pdfContent;
+  }
+}
diff --git a/packages/server/src/services/CreditNotes/GetRefundCreditNoteTransaction.ts b/packages/server/src/services/CreditNotes/GetRefundCreditNoteTransaction.ts
new file mode 100644
index 000000000..8ffbaba6b
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/GetRefundCreditNoteTransaction.ts
@@ -0,0 +1,37 @@
+import { Inject, Service } from 'typedi';
+import { IRefundCreditNote } from '@/interfaces';
+import RefundCreditNote from './RefundCreditNote';
+import RefundCreditNoteTransformer from './RefundCreditNoteTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export default class getRefundCreditNoteTransaction extends RefundCreditNote {
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve credit note associated invoices to apply.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @returns {Promise<ISaleInvoice[]>}
+   */
+  public getRefundCreditTransaction = async (
+    tenantId: number,
+    refundCreditId: number
+  ): Promise<IRefundCreditNote> => {
+    const { RefundCreditNote } = this.tenancy.models(tenantId);
+
+    await this.getCreditNoteRefundOrThrowError(tenantId, refundCreditId);
+
+    const refundCreditNote = await RefundCreditNote.query()
+      .findById(refundCreditId)
+      .withGraphFetched('fromAccount')
+      .withGraphFetched('creditNote');
+
+    return this.transformer.transform(
+      tenantId,
+      refundCreditNote,
+      new RefundCreditNoteTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/ListCreditNoteRefunds.ts b/packages/server/src/services/CreditNotes/ListCreditNoteRefunds.ts
new file mode 100644
index 000000000..0c99c6808
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/ListCreditNoteRefunds.ts
@@ -0,0 +1,41 @@
+import { IRefundCreditNotePOJO } from '@/interfaces';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+import BaseCreditNotes from './CreditNotes';
+import RefundCreditNoteTransformer from './RefundCreditNoteTransformer';
+
+@Service()
+export default class ListCreditNoteRefunds extends BaseCreditNotes {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the credit note graph.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @returns {Promise<IRefundCreditNotePOJO[]>}
+   */
+  public getCreditNoteRefunds = async (
+    tenantId: number,
+    creditNoteId: number
+  ): Promise<IRefundCreditNotePOJO[]> => {
+    const { RefundCreditNote } = this.tenancy.models(tenantId);
+
+    // Retrieve refund credit notes associated to the given credit note.
+    const refundCreditTransactions = await RefundCreditNote.query()
+      .where('creditNoteId', creditNoteId)
+      .withGraphFetched('creditNote')
+      .withGraphFetched('fromAccount');
+
+    // Transformes refund credit note models to POJO objects.
+    return this.transformer.transform(
+      tenantId,
+      refundCreditTransactions,
+      new RefundCreditNoteTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/ListCreditNotes.ts b/packages/server/src/services/CreditNotes/ListCreditNotes.ts
new file mode 100644
index 000000000..498d3d74d
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/ListCreditNotes.ts
@@ -0,0 +1,67 @@
+import { Service, Inject } from 'typedi';
+import * as R from 'ramda';
+import { ICreditNotesQueryDTO } from '@/interfaces';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import BaseCreditNotes from './CreditNotes';
+import { CreditNoteTransformer } from './CreditNoteTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export default class ListCreditNotes extends BaseCreditNotes {
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Parses the sale invoice list filter DTO.
+   * @param filterDTO
+   * @returns
+   */
+  private parseListFilterDTO = (filterDTO) => {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  };
+
+  /**
+   * Retrieves the paginated and filterable credit notes list.
+   * @param {number} tenantId -
+   * @param {ICreditNotesQueryDTO} creditNotesQuery -
+   */
+  public getCreditNotesList = async (
+    tenantId: number,
+    creditNotesQuery: ICreditNotesQueryDTO
+  ) => {
+    const { CreditNote } = this.tenancy.models(tenantId);
+
+    // Parses stringified filter roles.
+    const filter = this.parseListFilterDTO(creditNotesQuery);
+
+    // Dynamic list service.
+    const dynamicFilter = await this.dynamicListService.dynamicList(
+      tenantId,
+      CreditNote,
+      filter
+    );
+    const { results, pagination } = await CreditNote.query()
+      .onBuild((builder) => {
+        builder.withGraphFetched('entries');
+        builder.withGraphFetched('customer');
+        dynamicFilter.buildQuery()(builder);
+      })
+      .pagination(filter.page - 1, filter.pageSize);
+
+    // Transforomes the credit notes to POJO.
+    const creditNotes = await this.transformer.transform(
+      tenantId,
+      results,
+      new CreditNoteTransformer()
+    );
+
+    return {
+      creditNotes,
+      pagination,
+      filterMeta: dynamicFilter.getResponseMeta(),
+    };
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/OpenCreditNote.ts b/packages/server/src/services/CreditNotes/OpenCreditNote.ts
new file mode 100644
index 000000000..7efd4430c
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/OpenCreditNote.ts
@@ -0,0 +1,92 @@
+import { ServiceError } from '@/exceptions';
+import {
+  ICreditNote,
+  ICreditNoteOpenedPayload,
+  ICreditNoteOpeningPayload,
+} from '@/interfaces';
+import { Knex } from 'knex';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import { Inject, Service } from 'typedi';
+import BaseCreditNotes from './CreditNotes';
+import { ERRORS } from './constants';
+
+@Service()
+export default class OpenCreditNote extends BaseCreditNotes {
+  @Inject()
+  private itemsEntriesService: ItemsEntriesService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  /**
+   * Opens the given credit note.
+   * @param {number} tenantId -
+   * @param {ICreditNoteEditDTO} creditNoteEditDTO -
+   * @returns {Promise<ICreditNote>}
+   */
+  public openCreditNote = async (
+    tenantId: number,
+    creditNoteId: number
+  ): Promise<ICreditNote> => {
+    const { CreditNote } = this.tenancy.models(tenantId);
+
+    // Retrieve the sale invoice or throw not found service error.
+    const oldCreditNote = await this.getCreditNoteOrThrowError(
+      tenantId,
+      creditNoteId
+    );
+    // Throw service error if the credit note is already open.
+    this.throwErrorIfAlreadyOpen(oldCreditNote);
+
+    // Triggers `onCreditNoteOpen` event.
+    this.eventPublisher.emitAsync(events.creditNote.onOpen, {
+      tenantId,
+      creditNoteId,
+      oldCreditNote,
+    });
+    // Sales the credit note transactions with associated entries.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      const eventPayload = {
+        tenantId,
+        creditNoteId,
+        oldCreditNote,
+        trx,
+      } as ICreditNoteOpeningPayload;
+
+      // Triggers `onCreditNoteOpening` event.
+      await this.eventPublisher.emitAsync(
+        events.creditNote.onOpening,
+        eventPayload
+      );
+      // Saves the credit note graph to the storage.
+      const creditNote = await CreditNote.query(trx)
+        .findById(creditNoteId)
+        .update({
+          openedAt: new Date(),
+        });
+      // Triggers `onCreditNoteOpened` event.
+      await this.eventPublisher.emitAsync(events.creditNote.onOpened, {
+        ...eventPayload,
+        creditNote,
+      } as ICreditNoteOpenedPayload);
+
+      return creditNote;
+    });
+  };
+
+  /**
+   *
+   * @param creditNote
+   */
+  public throwErrorIfAlreadyOpen = (creditNote) => {
+    if (creditNote.openedAt) {
+      throw new ServiceError(ERRORS.CREDIT_NOTE_ALREADY_OPENED);
+    }
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/RefundCreditNote.ts b/packages/server/src/services/CreditNotes/RefundCreditNote.ts
new file mode 100644
index 000000000..395103dba
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/RefundCreditNote.ts
@@ -0,0 +1,45 @@
+import { Inject, Service } from 'typedi';
+import { ServiceError } from '@/exceptions';
+import { IAccount, IRefundCreditNote } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import BaseCreditNotes from './CreditNotes';
+import { ERRORS } from './constants';
+
+@Service()
+export default class RefundCreditNote extends BaseCreditNotes {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve the credit note graph.
+   * @param {number} tenantId
+   * @param {number} refundCreditId
+   * @returns {Promise<IRefundCreditNote>}
+   */
+  public getCreditNoteRefundOrThrowError = async (
+    tenantId: number,
+    refundCreditId: number
+  ): Promise<IRefundCreditNote> => {
+    const { RefundCreditNote } = this.tenancy.models(tenantId);
+
+    const refundCreditNote = await RefundCreditNote.query().findById(
+      refundCreditId
+    );
+    if (!refundCreditNote) {
+      throw new ServiceError(ERRORS.REFUND_CREDIT_NOTE_NOT_FOUND);
+    }
+    return refundCreditNote;
+  };
+
+  /**
+   * Validate the refund account type.
+   * @param {IAccount} account
+   */
+  public validateRefundWithdrawwalAccountType = (account: IAccount): void => {
+    const supportedTypes = ['bank', 'cash', 'fixed-asset'];
+
+    if (supportedTypes.indexOf(account.accountType) === -1) {
+      throw new ServiceError(ERRORS.ACCOUNT_INVALID_TYPE);
+    }
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/RefundCreditNoteGLEntries.ts b/packages/server/src/services/CreditNotes/RefundCreditNoteGLEntries.ts
new file mode 100644
index 000000000..4cee87a0c
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/RefundCreditNoteGLEntries.ts
@@ -0,0 +1,160 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import { AccountNormal, ILedgerEntry, IRefundCreditNote } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import Ledger from '@/services/Accounting/Ledger';
+
+@Service()
+export default class RefundCreditNoteGLEntries {
+  @Inject()
+  ledgerStorage: LedgerStorageService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieves the refund credit common GL entry.
+   * @param {IRefundCreditNote} refundCreditNote
+   * @returns
+   */
+  private getRefundCreditCommonGLEntry = (
+    refundCreditNote: IRefundCreditNote
+  ) => {
+    return {
+      currencyCode: refundCreditNote.currencyCode,
+      exchangeRate: refundCreditNote.exchangeRate,
+
+      transactionType: 'RefundCreditNote',
+      transactionId: refundCreditNote.id,
+      date: refundCreditNote.date,
+      userId: refundCreditNote.userId,
+
+      referenceNumber: refundCreditNote.referenceNo,
+
+      createdAt: refundCreditNote.createdAt,
+      indexGroup: 10,
+
+      credit: 0,
+      debit: 0,
+
+      note: refundCreditNote.description,
+      branchId: refundCreditNote.branchId,
+    };
+  };
+
+  /**
+   * Retrieves the refudn credit receivable GL entry.
+   * @param   {IRefundCreditNote} refundCreditNote
+   * @param   {number} ARAccountId
+   * @returns {ILedgerEntry}
+   */
+  private getRefundCreditGLReceivableEntry = (
+    refundCreditNote: IRefundCreditNote,
+    ARAccountId: number
+  ): ILedgerEntry => {
+    const commonEntry = this.getRefundCreditCommonGLEntry(refundCreditNote);
+
+    return {
+      ...commonEntry,
+      debit: refundCreditNote.amount,
+      accountId: ARAccountId,
+      contactId: refundCreditNote.creditNote.customerId,
+      index: 1,
+      accountNormal: AccountNormal.DEBIT,
+    };
+  };
+
+  /**
+   * Retrieves the refund credit withdrawal GL entry.
+   * @param   {number} refundCreditNote
+   * @returns {ILedgerEntry}
+   */
+  private getRefundCreditGLWithdrawalEntry = (
+    refundCreditNote: IRefundCreditNote
+  ): ILedgerEntry => {
+    const commonEntry = this.getRefundCreditCommonGLEntry(refundCreditNote);
+
+    return {
+      ...commonEntry,
+      credit: refundCreditNote.amount,
+      accountId: refundCreditNote.fromAccountId,
+      index: 2,
+      accountNormal: AccountNormal.DEBIT,
+    };
+  };
+
+  /**
+   * Retrieve the refund credit note GL entries.
+   * @param {IRefundCreditNote} refundCreditNote
+   * @param {number} receivableAccount
+   * @returns {ILedgerEntry[]}
+   */
+  public getRefundCreditGLEntries(
+    refundCreditNote: IRefundCreditNote,
+    ARAccountId: number
+  ): ILedgerEntry[] {
+    const receivableEntry = this.getRefundCreditGLReceivableEntry(
+      refundCreditNote,
+      ARAccountId
+    );
+    const withdrawalEntry =
+      this.getRefundCreditGLWithdrawalEntry(refundCreditNote);
+
+    return [receivableEntry, withdrawalEntry];
+  }
+
+  /**
+   * Creates refund credit GL entries.
+   * @param {number} tenantId
+   * @param {IRefundCreditNote} refundCreditNote
+   * @param {Knex.Transaction} trx
+   */
+  public createRefundCreditGLEntries = async (
+    tenantId: number,
+    refundCreditNoteId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { Account, RefundCreditNote } = this.tenancy.models(tenantId);
+
+    // Retrieve the refund with associated credit note.
+    const refundCreditNote = await RefundCreditNote.query(trx)
+      .findById(refundCreditNoteId)
+      .withGraphFetched('creditNote');
+
+    // Receivable account A/R.
+    const receivableAccount = await Account.query().findOne(
+      'slug',
+      'accounts-receivable'
+    );
+    // Retrieve refund credit GL entries.
+    const refundGLEntries = this.getRefundCreditGLEntries(
+      refundCreditNote,
+      receivableAccount.id
+    );
+    const ledger = new Ledger(refundGLEntries);
+
+    // Saves refund ledger entries.
+    await this.ledgerStorage.commit(tenantId, ledger, trx);
+  };
+
+  /**
+   * Reverts refund credit note GL entries.
+   * @param {number} tenantId
+   * @param {number} refundCreditNoteId
+   * @param {number} receivableAccount
+   * @param {Knex.Transaction} trx
+   */
+  public revertRefundCreditGLEntries = async (
+    tenantId: number,
+    refundCreditNoteId: number,
+    trx?: Knex.Transaction
+  ) => {
+    await this.ledgerStorage.deleteByReference(
+      tenantId,
+      refundCreditNoteId,
+      'RefundCreditNote',
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/RefundCreditNoteGLEntriesSubscriber.ts b/packages/server/src/services/CreditNotes/RefundCreditNoteGLEntriesSubscriber.ts
new file mode 100644
index 000000000..d075c4c85
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/RefundCreditNoteGLEntriesSubscriber.ts
@@ -0,0 +1,61 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import RefundCreditNoteGLEntries from './RefundCreditNoteGLEntries';
+import {
+  IRefundCreditNoteCreatedPayload,
+  IRefundCreditNoteDeletedPayload,
+} from '@/interfaces';
+
+@Service()
+export default class RefundCreditNoteGLEntriesSubscriber {
+  @Inject()
+  refundCreditGLEntries: RefundCreditNoteGLEntries;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.creditNote.onRefundCreated,
+      this.writeRefundCreditGLEntriesOnceCreated
+    );
+    bus.subscribe(
+      events.creditNote.onRefundDeleted,
+      this.revertRefundCreditGLEntriesOnceDeleted
+    );
+  };
+
+  /**
+   * Writes refund credit note GL entries once the transaction created.
+   * @param {IRefundCreditNoteCreatedPayload} payload -
+   */
+  private writeRefundCreditGLEntriesOnceCreated = async ({
+    trx,
+    refundCreditNote,
+    creditNote,
+    tenantId,
+  }: IRefundCreditNoteCreatedPayload) => {
+    await this.refundCreditGLEntries.createRefundCreditGLEntries(
+      tenantId,
+      refundCreditNote.id,
+      trx
+    );
+  };
+
+  /**
+   * Reverts refund credit note GL entries once the transaction deleted.
+   * @param {IRefundCreditNoteDeletedPayload} payload -
+   */
+  private revertRefundCreditGLEntriesOnceDeleted = async ({
+    trx,
+    refundCreditId,
+    oldRefundCredit,
+    tenantId,
+  }: IRefundCreditNoteDeletedPayload) => {
+    await this.refundCreditGLEntries.revertRefundCreditGLEntries(
+      tenantId,
+      refundCreditId,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/RefundCreditNoteTransformer.ts b/packages/server/src/services/CreditNotes/RefundCreditNoteTransformer.ts
new file mode 100644
index 000000000..73602de0c
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/RefundCreditNoteTransformer.ts
@@ -0,0 +1,30 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export default class RefundCreditNoteTransformer extends Transformer {
+  /**
+   * Includeded attributes.
+   * @returns {string[]}
+   */
+  public includeAttributes = (): string[] => {
+    return ['formttedAmount', 'formattedDate'];
+  };
+
+  /**
+   * Formatted amount.
+   * @returns {string}
+   */
+  protected formttedAmount = (item) => {
+    return formatNumber(item.amount, {
+      currencyCode: item.currencyCode,
+    });
+  };
+
+  /**
+   * Formatted date.
+   * @returns {string}
+   */
+  protected formattedDate = (item) => {
+    return this.formatDate(item.date);
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/RefundSyncCreditNoteBalance.ts b/packages/server/src/services/CreditNotes/RefundSyncCreditNoteBalance.ts
new file mode 100644
index 000000000..9414b33b6
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/RefundSyncCreditNoteBalance.ts
@@ -0,0 +1,48 @@
+import Knex from 'knex';
+import { IRefundCreditNote } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+
+@Service()
+export default class RefundSyncCreditNoteBalance {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {IRefundCreditNote} refundCreditNote
+   * @param {Knex.Transaction} trx
+   */
+  public incrementCreditNoteRefundAmount = async (
+    tenantId: number,
+    creditNoteId: number,
+    amount: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { CreditNote } = this.tenancy.models(tenantId);
+
+    await CreditNote.query(trx)
+      .findById(creditNoteId)
+      .increment('refunded_amount', amount);
+  };
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {IRefundCreditNote} refundCreditNote
+   * @param {Knex.Transaction} trx
+   */
+  public decrementCreditNoteRefundAmount = async (
+    tenantId: number,
+    creditNoteId: number,
+    amount: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { CreditNote } = this.tenancy.models(tenantId);
+
+    await CreditNote.query(trx)
+      .findById(creditNoteId)
+      .decrement('refunded_amount', amount);
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/RefundSyncCreditNoteBalanceSubscriber.ts b/packages/server/src/services/CreditNotes/RefundSyncCreditNoteBalanceSubscriber.ts
new file mode 100644
index 000000000..d82b44bff
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/RefundSyncCreditNoteBalanceSubscriber.ts
@@ -0,0 +1,62 @@
+import { Inject, Service } from 'typedi';
+import {
+  IRefundCreditNoteCreatedPayload,
+  IRefundCreditNoteDeletedPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import RefundSyncCreditNoteBalance from './RefundSyncCreditNoteBalance';
+
+@Service()
+export default class RefundSyncCreditNoteBalanceSubscriber {
+  @Inject()
+  refundSyncCreditBalance: RefundSyncCreditNoteBalance;
+
+  /**
+   * Attaches events with handlers.
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.creditNote.onRefundCreated,
+      this.incrementRefundedAmountOnceRefundCreated
+    );
+    bus.subscribe(
+      events.creditNote.onRefundDeleted,
+      this.decrementRefundedAmountOnceRefundDeleted
+    );
+    return bus;
+  }
+
+  /**
+   * Increment credit note refunded amount once associated refund transaction created.
+   * @param {IRefundCreditNoteCreatedPayload} payload -
+   */
+  private incrementRefundedAmountOnceRefundCreated = async ({
+    trx,
+    refundCreditNote,
+    tenantId,
+  }: IRefundCreditNoteCreatedPayload) => {
+    await this.refundSyncCreditBalance.incrementCreditNoteRefundAmount(
+      tenantId,
+      refundCreditNote.creditNoteId,
+      refundCreditNote.amount,
+      trx
+    );
+  };
+
+  /**
+   * Decrement credit note refunded amount once associated refuned transaction deleted.
+   * @param {IRefundCreditNoteDeletedPayload} payload -
+   */
+  private decrementRefundedAmountOnceRefundDeleted = async ({
+    trx,
+    oldRefundCredit,
+    tenantId,
+  }: IRefundCreditNoteDeletedPayload) => {
+    await this.refundSyncCreditBalance.decrementCreditNoteRefundAmount(
+      tenantId,
+      oldRefundCredit.creditNoteId,
+      oldRefundCredit.amount,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/CreditNotes/constants.ts b/packages/server/src/services/CreditNotes/constants.ts
new file mode 100644
index 000000000..9d0060075
--- /dev/null
+++ b/packages/server/src/services/CreditNotes/constants.ts
@@ -0,0 +1,68 @@
+export const ERRORS = {
+  CREDIT_NOTE_NOT_FOUND: 'CREDIT_NOTE_NOT_FOUND',
+  REFUND_CREDIT_NOTE_NOT_FOUND: 'REFUND_CREDIT_NOTE_NOT_FOUND',
+  CREDIT_NOTE_ALREADY_OPENED: 'CREDIT_NOTE_ALREADY_OPENED',
+  ACCOUNT_INVALID_TYPE: 'ACCOUNT_INVALID_TYPE',
+  CREDIT_NOTE_HAS_NO_REMAINING_AMOUNT: 'CREDIT_NOTE_HAS_NO_REMAINING_AMOUNT',
+  INVOICES_HAS_NO_REMAINING_AMOUNT: 'INVOICES_HAS_NO_REMAINING_AMOUNT',
+  CREDIT_NOTE_APPLY_TO_INVOICES_NOT_FOUND:
+    'CREDIT_NOTE_APPLY_TO_INVOICES_NOT_FOUND',
+  CREDIT_NOTE_HAS_REFUNDS_TRANSACTIONS: 'CREDIT_NOTE_HAS_REFUNDS_TRANSACTIONS',
+  CREDIT_NOTE_HAS_APPLIED_INVOICES: 'CREDIT_NOTE_HAS_APPLIED_INVOICES',
+  CUSTOMER_HAS_LINKED_CREDIT_NOTES: 'CUSTOMER_HAS_LINKED_CREDIT_NOTES'
+};
+
+export const DEFAULT_VIEW_COLUMNS = [];
+export const DEFAULT_VIEWS = [
+  {
+    name: 'credit_note.view.draft',
+    slug: 'draft',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'draft' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'credit_note.view.published',
+    slug: 'published',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'published',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'credit_note.view.open',
+    slug: 'open',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'open',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'credit_note.view.closed',
+    slug: 'closed',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'closed',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+];
diff --git a/packages/server/src/services/Currencies/CurrenciesService.ts b/packages/server/src/services/Currencies/CurrenciesService.ts
new file mode 100644
index 000000000..342a02e9f
--- /dev/null
+++ b/packages/server/src/services/Currencies/CurrenciesService.ts
@@ -0,0 +1,198 @@
+import { Inject, Service } from 'typedi';
+import { uniq } from 'lodash';
+
+import {
+  ICurrencyEditDTO,
+  ICurrencyDTO,
+  ICurrenciesService,
+  ICurrency,
+} from '@/interfaces';
+import {
+  EventDispatcher,
+  EventDispatcherInterface,
+} from 'decorators/eventDispatcher';
+import { ServiceError } from '@/exceptions';
+import TenancyService from '@/services/Tenancy/TenancyService';
+
+const ERRORS = {
+  CURRENCY_NOT_FOUND: 'currency_not_found',
+  CURRENCY_CODE_EXISTS: 'currency_code_exists',
+  BASE_CURRENCY_INVALID: 'BASE_CURRENCY_INVALID',
+  CANNOT_DELETE_BASE_CURRENCY: 'CANNOT_DELETE_BASE_CURRENCY',
+};
+
+@Service()
+export default class CurrenciesService implements ICurrenciesService {
+  @Inject('logger')
+  logger: any;
+
+  @EventDispatcher()
+  eventDispatcher: EventDispatcherInterface;
+
+  @Inject()
+  tenancy: TenancyService;
+
+  /**
+   * Retrieve currency by given currency code or throw not found error.
+   * @param {number} tenantId
+   * @param {string} currencyCode
+   * @param {number} currencyId
+   */
+  private async validateCurrencyCodeUniquiness(
+    tenantId: number,
+    currencyCode: string,
+    currencyId?: number
+  ) {
+    const { Currency } = this.tenancy.models(tenantId);
+
+    const foundCurrency = await Currency.query().onBuild((query) => {
+      query.findOne('currency_code', currencyCode);
+
+      if (currencyId) {
+        query.whereNot('id', currencyId);
+      }
+    });
+    if (foundCurrency) {
+      throw new ServiceError(ERRORS.CURRENCY_CODE_EXISTS);
+    }
+  }
+
+  /**
+   * Retrieve currency by the given currency code or throw service error.
+   * @param {number} tenantId
+   * @param {string} currencyCode
+   */
+  private async getCurrencyByCodeOrThrowError(
+    tenantId: number,
+    currencyCode: string
+  ) {
+    const { Currency } = this.tenancy.models(tenantId);
+
+    const foundCurrency = await Currency.query().findOne(
+      'currency_code',
+      currencyCode
+    );
+
+    if (!foundCurrency) {
+      throw new ServiceError(ERRORS.CURRENCY_NOT_FOUND);
+    }
+    return foundCurrency;
+  }
+
+  /**
+   * Retrieve currency by given id or throw not found error.
+   * @param {number} tenantId
+   * @param {number} currencyId
+   */
+  private async getCurrencyIdOrThrowError(
+    tenantId: number,
+    currencyId: number
+  ) {
+    const { Currency } = this.tenancy.models(tenantId);
+
+    const foundCurrency = await Currency.query().findOne('id', currencyId);
+
+    if (!foundCurrency) {
+      throw new ServiceError(ERRORS.CURRENCY_NOT_FOUND);
+    }
+    return foundCurrency;
+  }
+
+  /**
+   * Creates a new currency.
+   * @param {number} tenantId
+   * @param {ICurrencyDTO} currencyDTO
+   */
+  public async newCurrency(tenantId: number, currencyDTO: ICurrencyDTO) {
+    const { Currency } = this.tenancy.models(tenantId);
+  
+    // Validate currency code uniquiness.
+    await this.validateCurrencyCodeUniquiness(
+      tenantId,
+      currencyDTO.currencyCode
+    );
+
+    await Currency.query().insert({ ...currencyDTO });
+  }
+
+  /**
+   * Edit details of the given currency.
+   * @param {number} tenantId
+   * @param {number} currencyId
+   * @param {ICurrencyDTO} currencyDTO
+   */
+  public async editCurrency(
+    tenantId: number,
+    currencyId: number,
+    currencyDTO: ICurrencyEditDTO
+  ): Promise<ICurrency> {
+    const { Currency } = this.tenancy.models(tenantId);
+
+    await this.getCurrencyIdOrThrowError(tenantId, currencyId);
+
+    const currency = await Currency.query().patchAndFetchById(currencyId, {
+      ...currencyDTO,
+    });
+    return currency;
+  }
+
+  /**
+   * Validate cannot delete base currency.
+   * @param {number} tenantId
+   * @param {string} currencyCode
+   */
+  validateCannotDeleteBaseCurrency(tenantId: number, currencyCode: string) {
+    const settings = this.tenancy.settings(tenantId);
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+    if (baseCurrency === currencyCode) {
+      throw new ServiceError(ERRORS.CANNOT_DELETE_BASE_CURRENCY);
+    }
+  }
+
+  /**
+   * Delete the given currency code.
+   * @param {number} tenantId
+   * @param {string} currencyCode
+   * @return {Promise<}
+   */
+  public async deleteCurrency(
+    tenantId: number,
+    currencyCode: string
+  ): Promise<void> {
+    const { Currency } = this.tenancy.models(tenantId);
+
+    await this.getCurrencyByCodeOrThrowError(tenantId, currencyCode);
+
+    // Validate currency code not equals base currency.
+    await this.validateCannotDeleteBaseCurrency(tenantId, currencyCode);
+
+    await Currency.query().where('currency_code', currencyCode).delete();
+  }
+
+  /**
+   * Listing currencies.
+   * @param {number} tenantId
+   * @return {Promise<ICurrency[]>}
+   */
+  public async listCurrencies(tenantId: number): Promise<ICurrency[]> {
+    const { Currency } = this.tenancy.models(tenantId);
+
+    const settings = this.tenancy.settings(tenantId);
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+
+    const currencies = await Currency.query().onBuild((query) => {
+      query.orderBy('createdAt', 'ASC');
+    });
+    const formattedCurrencies = currencies.map((currency) => ({
+      isBaseCurrency: baseCurrency === currency.currencyCode,
+      ...currency,
+    }));
+    return formattedCurrencies;
+  }
+}
diff --git a/packages/server/src/services/Currencies/InitialCurrenciesSeed.ts b/packages/server/src/services/Currencies/InitialCurrenciesSeed.ts
new file mode 100644
index 000000000..b77c988a8
--- /dev/null
+++ b/packages/server/src/services/Currencies/InitialCurrenciesSeed.ts
@@ -0,0 +1,53 @@
+import { Inject, Service } from 'typedi';
+import { uniq } from 'lodash';
+import Currencies from 'js-money/lib/currency';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { InitialCurrencies } from './constants';
+
+@Service()
+export class InitialCurrenciesSeed {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Seeds the given base currency to the currencies list.
+   * @param {number} tenantId
+   * @param {string} baseCurrency
+   */
+  public seedCurrencyByCode = async (
+    tenantId: number,
+    currencyCode: string
+  ): Promise<void> => {
+    const { Currency } = this.tenancy.models(tenantId);
+    const currencyMeta = Currencies[currencyCode];
+
+    const foundBaseCurrency = await Currency.query().findOne(
+      'currency_code',
+      currencyCode
+    );
+    if (!foundBaseCurrency) {
+      await Currency.query().insert({
+        currency_code: currencyMeta.code,
+        currency_name: currencyMeta.name,
+        currency_sign: currencyMeta.symbol,
+      });
+    }
+  };
+
+  /**
+   * Seeds initial currencies to the organization.
+   * @param {number} tenantId
+   * @param {string} baseCurrency
+   */
+  public seedInitialCurrencies = async (
+    tenantId: number,
+    baseCurrency: string
+  ): Promise<void> => {
+    const initialCurrencies = uniq([...InitialCurrencies, baseCurrency]);
+    // Seed currency opers.
+    const seedCurrencyOpers = initialCurrencies.map((currencyCode) => {
+      return this.seedCurrencyByCode(tenantId, currencyCode);
+    });
+    await Promise.all(seedCurrencyOpers);
+  };
+}
diff --git a/packages/server/src/services/Currencies/constants.ts b/packages/server/src/services/Currencies/constants.ts
new file mode 100644
index 000000000..702150303
--- /dev/null
+++ b/packages/server/src/services/Currencies/constants.ts
@@ -0,0 +1,11 @@
+// eslint-disable-next-line import/prefer-default-export
+export const InitialCurrencies = [
+  'USD',
+  'CAD',
+  'EUR',
+  'LYD',
+  'GBP',
+  'CNY',
+  'AUD',
+  'INR',
+];
diff --git a/packages/server/src/services/Currencies/subscribers/SeedInitialCurrenciesOnSetupSubscriber.ts b/packages/server/src/services/Currencies/subscribers/SeedInitialCurrenciesOnSetupSubscriber.ts
new file mode 100644
index 000000000..28419f024
--- /dev/null
+++ b/packages/server/src/services/Currencies/subscribers/SeedInitialCurrenciesOnSetupSubscriber.ts
@@ -0,0 +1,32 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { IOrganizationBuildEventPayload } from '@/interfaces';
+import { InitialCurrenciesSeed } from '../InitialCurrenciesSeed';
+
+@Service()
+export class SeedInitialCurrenciesOnSetupSubsriber {
+  @Inject()
+  seedInitialCurrencies: InitialCurrenciesSeed;
+
+  /**
+   * Attaches events.
+   */
+  public attach(bus) {
+    bus.subscribe(events.organization.build, this.seedInitialCurrenciesOnBuild);
+  }
+
+  /**
+   * Seed initial currencies once organization build.
+   * @param {IOrganizationBuildEventPayload}
+   */
+  private seedInitialCurrenciesOnBuild = async ({
+    systemUser,
+    buildDTO,
+    tenantId,
+  }: IOrganizationBuildEventPayload) => {
+    await this.seedInitialCurrencies.seedInitialCurrencies(
+      tenantId,
+      buildDTO.baseCurrency
+    );
+  };
+}
diff --git a/packages/server/src/services/Dashboard/DashboardService.ts b/packages/server/src/services/Dashboard/DashboardService.ts
new file mode 100644
index 000000000..81c24a026
--- /dev/null
+++ b/packages/server/src/services/Dashboard/DashboardService.ts
@@ -0,0 +1,75 @@
+import { IFeatureAllItem, ISystemUser } from '@/interfaces';
+import { FeaturesManager } from '@/services/Features/FeaturesManager';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+
+interface IRoleAbility {
+  subject: string;
+  ability: string;
+}
+
+interface IDashboardBootMeta {
+  abilities: IRoleAbility[];
+  features: IFeatureAllItem[];
+}
+
+@Service()
+export default class DashboardService {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  featuresManager: FeaturesManager;
+
+  /**
+   * Retrieve dashboard meta.
+   * @param {number} tenantId
+   * @param {number} authorizedUser
+   */
+  public getBootMeta = async (
+    tenantId: number,
+    authorizedUser: ISystemUser
+  ): Promise<IDashboardBootMeta> => {
+    // Retrieves all orgnaization abilities.
+    const abilities = await this.getBootAbilities(tenantId, authorizedUser.id);
+
+    // Retrieves all organization features.
+    const features = await this.featuresManager.all(tenantId);
+
+    return {
+      abilities,
+      features,
+    };
+  };
+
+  /**
+   * Transformes role permissions to abilities.
+   */
+  transformRoleAbility = (permissions) => {
+    return permissions
+      .filter((permission) => permission.value)
+      .map((permission) => ({
+        subject: permission.subject,
+        action: permission.ability,
+      }));
+  };
+
+  /**
+   * Retrieve the boot abilities.
+   * @returns
+   */
+  private getBootAbilities = async (
+    tenantId: number,
+    systemUserId: number
+  ): Promise<IRoleAbility[]> => {
+    const { User } = this.tenancy.models(tenantId);
+
+    const tenantUser = await User.query()
+      .findOne('systemUserId', systemUserId)
+      .withGraphFetched('role.permissions');
+
+    return tenantUser.role.slug === 'admin'
+      ? [{ subject: 'all', action: 'manage' }]
+      : this.transformRoleAbility(tenantUser.role.permissions);
+  };
+}
diff --git a/packages/server/src/services/DynamicListing/DynamicListAbstruct.ts b/packages/server/src/services/DynamicListing/DynamicListAbstruct.ts
new file mode 100644
index 000000000..d7997966b
--- /dev/null
+++ b/packages/server/src/services/DynamicListing/DynamicListAbstruct.ts
@@ -0,0 +1,6 @@
+
+
+
+export default class DynamicListAbstruct {
+    
+}
\ No newline at end of file
diff --git a/packages/server/src/services/DynamicListing/DynamicListCustomView.ts b/packages/server/src/services/DynamicListing/DynamicListCustomView.ts
new file mode 100644
index 000000000..7642bd4c4
--- /dev/null
+++ b/packages/server/src/services/DynamicListing/DynamicListCustomView.ts
@@ -0,0 +1,57 @@
+import { Inject, Service } from 'typedi';
+import DynamicListAbstruct from './DynamicListAbstruct';
+import DynamicFilterViews from '@/lib/DynamicFilter/DynamicFilterViews';
+import { ServiceError } from '@/exceptions';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ERRORS } from './constants';
+import { IModel } from '@/interfaces';
+
+@Service()
+export default class DynamicListCustomView extends DynamicListAbstruct {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retreive custom view or throws error not found.
+   * @param  {number} tenantId
+   * @param  {number} viewId
+   * @return {Promise<IView>}
+   */
+  private getCustomViewOrThrowError = async (
+    tenantId: number,
+    viewSlug: string,
+    model: IModel
+  ) => {
+    const { View } = this.tenancy.models(tenantId);
+
+    // Finds the default view by the given view slug.
+    const defaultView = model.getDefaultViewBySlug(viewSlug);
+
+    if (!defaultView) {
+      throw new ServiceError(ERRORS.VIEW_NOT_FOUND);
+    }
+    return defaultView;
+  };
+
+  /**
+   * Dynamic list custom view.
+   * @param {IModel} model
+   * @param {number} customViewId
+   * @returns
+   */
+  public dynamicListCustomView = async (
+    dynamicFilter: any,
+    customViewSlug: string,
+    tenantId: number
+  ) => {
+    const model = dynamicFilter.getModel();
+
+    // Retrieve the custom view or throw not found.
+    const view = await this.getCustomViewOrThrowError(
+      tenantId,
+      customViewSlug,
+      model,
+    );
+    return new DynamicFilterViews(view);
+  };
+}
diff --git a/packages/server/src/services/DynamicListing/DynamicListFilterRoles.ts b/packages/server/src/services/DynamicListing/DynamicListFilterRoles.ts
new file mode 100644
index 000000000..688b05b09
--- /dev/null
+++ b/packages/server/src/services/DynamicListing/DynamicListFilterRoles.ts
@@ -0,0 +1,103 @@
+import { Service } from 'typedi';
+import * as R from 'ramda';
+import validator from 'is-my-json-valid';
+import { IFilterRole, IModel } from '@/interfaces';
+import DynamicListAbstruct from './DynamicListAbstruct';
+import DynamicFilterAdvancedFilter from '@/lib/DynamicFilter/DynamicFilterAdvancedFilter';
+import { ERRORS } from './constants';
+import { ServiceError } from '@/exceptions';
+
+@Service()
+export default class DynamicListFilterRoles extends DynamicListAbstruct {
+  /**
+   * Validates filter roles schema.
+   * @param {IFilterRole[]} filterRoles - Filter roles.
+   */
+  private validateFilterRolesSchema = (filterRoles: IFilterRole[]) => {
+    const validate = validator({
+      required: true,
+      type: 'object',
+      properties: {
+        condition: { type: 'string' },
+        fieldKey: { required: true, type: 'string' },
+        value: { required: true },
+      },
+    });
+    const invalidFields = filterRoles.filter((filterRole) => {
+      return !validate(filterRole);
+    });
+    if (invalidFields.length > 0) {
+      throw new ServiceError(ERRORS.STRINGIFIED_FILTER_ROLES_INVALID);
+    }
+  };
+
+  /**
+   * Retrieve filter roles fields key that not exists on the given model.
+   * @param {IModel} model
+   * @param {IFilterRole} filterRoles
+   * @returns {string[]}
+   */
+  private getFilterRolesFieldsNotExist = (
+    model,
+    filterRoles: IFilterRole[]
+  ): string[] => {
+    return filterRoles
+      .filter((filterRole) => !model.getField(filterRole.fieldKey))
+      .map((filterRole) => filterRole.fieldKey);
+  };
+
+  /**
+   * Validates existance the fields of filter roles.
+   * @param  {IModel} model
+   * @param  {IFilterRole[]} filterRoles
+   * @throws {ServiceError}
+   */
+  private validateFilterRolesFieldsExistance = (
+    model: IModel,
+    filterRoles: IFilterRole[]
+  ) => {
+    const invalidFieldsKeys = this.getFilterRolesFieldsNotExist(
+      model,
+      filterRoles
+    );
+    if (invalidFieldsKeys.length > 0) {
+      throw new ServiceError(ERRORS.FILTER_ROLES_FIELDS_NOT_FOUND);
+    }
+  };
+
+  /**
+   * Associate index to filter roles.
+   * @param {IFilterRole[]} filterRoles
+   * @returns {IFilterRole[]}
+   */
+  private incrementFilterRolesIndex = (
+    filterRoles: IFilterRole[]
+  ): IFilterRole[] => {
+    return filterRoles.map((filterRole, index) => ({
+      ...filterRole,
+      index: index + 1,
+    }));
+  };
+
+  /**
+   * Dynamic list filter roles.
+   * @param {IModel} model
+   * @param {IFilterRole[]} filterRoles
+   * @returns {DynamicFilterFilterRoles}
+   */
+  public dynamicList = (
+    model: IModel,
+    filterRoles: IFilterRole[]
+  ): DynamicFilterAdvancedFilter => {
+    const filterRolesParsed = R.compose(this.incrementFilterRolesIndex)(
+      filterRoles
+    );
+    // Validate filter roles json schema.
+    this.validateFilterRolesSchema(filterRolesParsed);
+
+    // Validate the model resource fields.
+    this.validateFilterRolesFieldsExistance(model, filterRoles);
+
+    return new DynamicFilterAdvancedFilter(filterRolesParsed);
+  };
+}
diff --git a/packages/server/src/services/DynamicListing/DynamicListSearch.ts b/packages/server/src/services/DynamicListing/DynamicListSearch.ts
new file mode 100644
index 000000000..517a15460
--- /dev/null
+++ b/packages/server/src/services/DynamicListing/DynamicListSearch.ts
@@ -0,0 +1,18 @@
+import { Service } from 'typedi';
+import { IFilterRole, IModel } from '@/interfaces';
+import DynamicListAbstruct from './DynamicListAbstruct';
+import DynamicFilterFilterRoles from '@/lib/DynamicFilter/DynamicFilterFilterRoles';
+import DynamicFilterSearch from '@/lib/DynamicFilter/DynamicFilterSearch';
+
+@Service()
+export default class DynamicListSearch extends DynamicListAbstruct {
+  /**
+   * Dynamic list filter roles.
+   * @param {IModel} model
+   * @param {IFilterRole[]} filterRoles
+   * @returns {DynamicFilterFilterRoles}
+   */
+  public dynamicSearch = (model: IModel, searchKeyword: string) => {
+    return new DynamicFilterSearch(searchKeyword);
+  };
+}
diff --git a/packages/server/src/services/DynamicListing/DynamicListService.ts b/packages/server/src/services/DynamicListing/DynamicListService.ts
new file mode 100644
index 000000000..5bd3c5d01
--- /dev/null
+++ b/packages/server/src/services/DynamicListing/DynamicListService.ts
@@ -0,0 +1,181 @@
+import { Service, Inject } from 'typedi';
+import { Request, Response, NextFunction } from 'express';
+import { castArray, isEmpty } from 'lodash';
+import { ServiceError } from '@/exceptions';
+import { DynamicFilter } from '@/lib/DynamicFilter';
+import {
+  IDynamicListFilter,
+  IDynamicListService,
+  IFilterRole,
+  IModel,
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import DynamicListFilterRoles from './DynamicListFilterRoles';
+import DynamicListSortBy from './DynamicListSortBy';
+import DynamicListCustomView from './DynamicListCustomView';
+import DynamicListSearch from './DynamicListSearch';
+
+@Service()
+export default class DynamicListService implements IDynamicListService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  dynamicListFilterRoles: DynamicListFilterRoles;
+
+  @Inject()
+  dynamicListSortBy: DynamicListSortBy;
+
+  @Inject()
+  dynamicListView: DynamicListCustomView;
+
+  @Inject()
+  dynamicListSearch: DynamicListSearch;
+
+  /**
+   * Parses filter DTO.
+   * @param {IMode} model -
+   * @param {} filterDTO -
+   */
+  private parseFilterObject = (model, filterDTO) => {
+    return {
+      // Merges the default properties with filter object.
+      ...(model.defaultSort
+        ? {
+            sortOrder: model.defaultSort.sortOrder,
+            columnSortBy: model.defaultSort.sortOrder,
+          }
+        : {}),
+      ...filterDTO,
+    };
+  };
+
+  /**
+   * Dynamic listing.
+   * @param {number} tenantId - Tenant id.
+   * @param {IModel} model - Model.
+   * @param {IDynamicListFilter} filter - Dynamic filter DTO.
+   */
+  public dynamicList = async (
+    tenantId: number,
+    model: IModel,
+    filter: IDynamicListFilter
+  ) => {
+    const dynamicFilter = new DynamicFilter(model);
+
+    // Parses the filter object.
+    const parsedFilter = this.parseFilterObject(model, filter);
+
+    // Search by keyword.
+    if (filter.searchKeyword) {
+      const dynamicListSearch = this.dynamicListSearch.dynamicSearch(
+        model,
+        filter.searchKeyword
+      );
+      dynamicFilter.setFilter(dynamicListSearch);
+    }
+    // Custom view filter roles.
+    if (filter.viewSlug) {
+      const dynamicListCustomView =
+        await this.dynamicListView.dynamicListCustomView(
+          dynamicFilter,
+          filter.viewSlug,
+          tenantId
+        );
+      dynamicFilter.setFilter(dynamicListCustomView);
+    }
+    // Sort by the given column.
+    if (parsedFilter.columnSortBy) {
+      const dynmaicListSortBy = this.dynamicListSortBy.dynamicSortBy(
+        model,
+        parsedFilter.columnSortBy,
+        parsedFilter.sortOrder
+      );
+      dynamicFilter.setFilter(dynmaicListSortBy);
+    }
+    // Filter roles.
+    if (!isEmpty(parsedFilter.filterRoles)) {
+      const dynamicFilterRoles = this.dynamicListFilterRoles.dynamicList(
+        model,
+        parsedFilter.filterRoles
+      );
+      dynamicFilter.setFilter(dynamicFilterRoles);
+    }
+    return dynamicFilter;
+  };
+
+  /**
+   * Middleware to catch services errors
+   * @param {Error} error
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public handlerErrorsToResponse(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    if (error instanceof ServiceError) {
+      if (error.errorType === 'sort_column_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'SORT.COLUMN.NOT.FOUND',
+              message: 'Sort column not found.',
+              code: 200,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'view_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'CUSTOM.VIEW.NOT.FOUND',
+              message: 'Custom view not found.',
+              code: 100,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'filter_roles_fields_not_found') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'FILTER.ROLES.FIELDS.NOT.FOUND',
+              message: 'Filter roles fields not found.',
+              code: 300,
+            },
+          ],
+        });
+      }
+      if (error.errorType === 'stringified_filter_roles_invalid') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'STRINGIFIED_FILTER_ROLES_INVALID',
+              message: 'Stringified filter roles json invalid.',
+              code: 400,
+            },
+          ],
+        });
+      }
+    }
+    next(error);
+  }
+
+  /**
+   * Parses stringified filter roles.
+   * @param {string} stringifiedFilterRoles - Stringified filter roles.
+   */
+  public parseStringifiedFilter = (filterRoles: IDynamicListFilter) => {
+    return {
+      ...filterRoles,
+      filterRoles: filterRoles.stringifiedFilterRoles
+        ? castArray(JSON.parse(filterRoles.stringifiedFilterRoles))
+        : [],
+    };
+  };
+}
diff --git a/packages/server/src/services/DynamicListing/DynamicListSortBy.ts b/packages/server/src/services/DynamicListing/DynamicListSortBy.ts
new file mode 100644
index 000000000..594e1c141
--- /dev/null
+++ b/packages/server/src/services/DynamicListing/DynamicListSortBy.ts
@@ -0,0 +1,40 @@
+import { Service } from 'typedi';
+import DynamicListAbstruct from './DynamicListAbstruct';
+import DynamicFilterSortBy from '@/lib/DynamicFilter/DynamicFilterSortBy';
+import { IModel, ISortOrder } from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+
+@Service()
+export default class DynamicListSortBy extends DynamicListAbstruct {
+  /**
+   * Dynamic list sort by.
+   * @param {IModel} model
+   * @param {string} columnSortBy
+   * @param {ISortOrder} sortOrder
+   * @returns {DynamicFilterSortBy}
+   */
+  public dynamicSortBy(
+    model: IModel,
+    columnSortBy: string,
+    sortOrder: ISortOrder
+  ) {
+    this.validateSortColumnExistance(model, columnSortBy);
+
+    return new DynamicFilterSortBy(columnSortBy, sortOrder);
+  }
+
+  /**
+   * Validates the sort column whether exists.
+   * @param  {IModel} model - Model.
+   * @param  {string} columnSortBy - Sort column
+   * @throws {ServiceError}
+   */
+  private validateSortColumnExistance(model: any, columnSortBy: string) {
+    const field = model.getField(columnSortBy);
+
+    if (!field) {
+      throw new ServiceError(ERRORS.SORT_COLUMN_NOT_FOUND);
+    }
+  }
+}
diff --git a/packages/server/src/services/DynamicListing/constants.ts b/packages/server/src/services/DynamicListing/constants.ts
new file mode 100644
index 000000000..414de46ac
--- /dev/null
+++ b/packages/server/src/services/DynamicListing/constants.ts
@@ -0,0 +1,6 @@
+export const ERRORS = {
+  STRINGIFIED_FILTER_ROLES_INVALID: 'stringified_filter_roles_invalid',
+  VIEW_NOT_FOUND: 'view_not_found',
+  SORT_COLUMN_NOT_FOUND: 'sort_column_not_found',
+  FILTER_ROLES_FIELDS_NOT_FOUND: 'filter_roles_fields_not_found',
+};
diff --git a/packages/server/src/services/DynamicListing/validators.ts b/packages/server/src/services/DynamicListing/validators.ts
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/server/src/services/Entries/index.ts b/packages/server/src/services/Entries/index.ts
new file mode 100644
index 000000000..1a9de20e5
--- /dev/null
+++ b/packages/server/src/services/Entries/index.ts
@@ -0,0 +1,78 @@
+import { Service } from 'typedi';
+import { ServiceError } from '@/exceptions';
+import { transformToMap } from 'utils';
+import {
+  ICommonLandedCostEntry,
+  ICommonLandedCostEntryDTO
+} from '@/interfaces';
+
+const ERRORS = {
+  ENTRIES_ALLOCATED_COST_COULD_NOT_DELETED:
+    'ENTRIES_ALLOCATED_COST_COULD_NOT_DELETED',
+  LOCATED_COST_ENTRIES_SHOULD_BIGGE_THAN_NEW_ENTRIES:
+    'LOCATED_COST_ENTRIES_SHOULD_BIGGE_THAN_NEW_ENTRIES',
+};
+
+@Service()
+export default class EntriesService {
+  /**
+   * Validates bill entries that has allocated landed cost amount not deleted.
+   * @param {IItemEntry[]} oldCommonEntries -
+   * @param {IItemEntry[]} newBillEntries -
+   */
+  public getLandedCostEntriesDeleted(
+    oldCommonEntries: ICommonLandedCostEntry[],
+    newCommonEntriesDTO: ICommonLandedCostEntryDTO[]
+  ): ICommonLandedCostEntry[] {
+    const newBillEntriesById = transformToMap(newCommonEntriesDTO, 'id');
+
+    return oldCommonEntries.filter((entry) => {
+      const newEntry = newBillEntriesById.get(entry.id);
+
+      if (entry.allocatedCostAmount > 0 && typeof newEntry === 'undefined') {
+        return true;
+      }
+      return false;
+    });
+  }
+
+  /**
+   * Validates the bill entries that have located cost amount should not be deleted.
+   * @param {IItemEntry[]} oldCommonEntries - Old bill entries.
+   * @param {IItemEntryDTO[]} newBillEntries - New DTO bill entries.
+   */
+  public validateLandedCostEntriesNotDeleted(
+    oldCommonEntries: ICommonLandedCostEntry[],
+    newCommonEntriesDTO: ICommonLandedCostEntryDTO[]
+  ): void {
+    const entriesDeleted = this.getLandedCostEntriesDeleted(
+      oldCommonEntries,
+      newCommonEntriesDTO
+    );
+    if (entriesDeleted.length > 0) {
+      throw new ServiceError(ERRORS.ENTRIES_ALLOCATED_COST_COULD_NOT_DELETED);
+    }
+  }
+
+  /**
+   * Validate allocated cost amount entries should be smaller than new entries amount.
+   * @param {IItemEntry[]} oldCommonEntries - Old bill entries.
+   * @param {IItemEntryDTO[]} newBillEntries - New DTO bill entries.
+   */
+  public validateLocatedCostEntriesSmallerThanNewEntries(
+    oldCommonEntries: ICommonLandedCostEntry[],
+    newCommonEntriesDTO: ICommonLandedCostEntryDTO[]
+  ): void {
+    const oldBillEntriesById = transformToMap(oldCommonEntries, 'id');
+
+    newCommonEntriesDTO.forEach((entry) => {
+      const oldEntry = oldBillEntriesById.get(entry.id);
+
+      if (oldEntry && oldEntry.allocatedCostAmount > entry.amount) {
+        throw new ServiceError(
+          ERRORS.LOCATED_COST_ENTRIES_SHOULD_BIGGE_THAN_NEW_ENTRIES
+        );
+      }
+    });
+  }
+}
diff --git a/packages/server/src/services/ExchangeRates/ExchangeRatesService.ts b/packages/server/src/services/ExchangeRates/ExchangeRatesService.ts
new file mode 100644
index 000000000..9bc63fbfd
--- /dev/null
+++ b/packages/server/src/services/ExchangeRates/ExchangeRatesService.ts
@@ -0,0 +1,193 @@
+import moment from 'moment';
+import { difference } from 'lodash';
+import { Service, Inject } from 'typedi';
+import { ServiceError } from '@/exceptions';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import {
+  EventDispatcher,
+  EventDispatcherInterface,
+} from 'decorators/eventDispatcher';
+import {
+  IExchangeRateDTO,
+  IExchangeRate,
+  IExchangeRatesService,
+  IExchangeRateEditDTO,
+  IExchangeRateFilter,
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+
+const ERRORS = {
+  NOT_FOUND_EXCHANGE_RATES: 'NOT_FOUND_EXCHANGE_RATES',
+  EXCHANGE_RATE_PERIOD_EXISTS: 'EXCHANGE_RATE_PERIOD_EXISTS',
+  EXCHANGE_RATE_NOT_FOUND: 'EXCHANGE_RATE_NOT_FOUND',
+};
+
+@Service()
+export default class ExchangeRatesService implements IExchangeRatesService {
+  @Inject('logger')
+  logger: any;
+
+  @EventDispatcher()
+  eventDispatcher: EventDispatcherInterface;
+
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  /**
+   * Creates a new exchange rate.
+   * @param {number} tenantId
+   * @param {IExchangeRateDTO} exchangeRateDTO
+   * @returns {Promise<IExchangeRate>}
+   */
+  public async newExchangeRate(
+    tenantId: number,
+    exchangeRateDTO: IExchangeRateDTO
+  ): Promise<IExchangeRate> {
+    const { ExchangeRate } = this.tenancy.models(tenantId);
+
+    this.logger.info('[exchange_rates] trying to insert new exchange rate.', {
+      tenantId,
+      exchangeRateDTO,
+    });
+    await this.validateExchangeRatePeriodExistance(tenantId, exchangeRateDTO);
+
+    const exchangeRate = await ExchangeRate.query().insertAndFetch({
+      ...exchangeRateDTO,
+      date: moment(exchangeRateDTO.date).format('YYYY-MM-DD'),
+    });
+    this.logger.info('[exchange_rates] inserted successfully.', {
+      tenantId,
+      exchangeRateDTO,
+    });
+    return exchangeRate;
+  }
+
+  /**
+   * Edits the exchange rate details.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} exchangeRateId - Exchange rate id.
+   * @param {IExchangeRateEditDTO} editExRateDTO - Edit exchange rate DTO.
+   */
+  public async editExchangeRate(
+    tenantId: number,
+    exchangeRateId: number,
+    editExRateDTO: IExchangeRateEditDTO
+  ): Promise<void> {
+    const { ExchangeRate } = this.tenancy.models(tenantId);
+
+    this.logger.info('[exchange_rates] trying to edit exchange rate.', {
+      tenantId,
+      exchangeRateId,
+      editExRateDTO,
+    });
+    await this.validateExchangeRateExistance(tenantId, exchangeRateId);
+
+    await ExchangeRate.query()
+      .where('id', exchangeRateId)
+      .update({ ...editExRateDTO });
+    this.logger.info('[exchange_rates] exchange rate edited successfully.', {
+      tenantId,
+      exchangeRateId,
+      editExRateDTO,
+    });
+  }
+
+  /**
+   * Deletes the given exchange rate.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} exchangeRateId - Exchange rate id.
+   */
+  public async deleteExchangeRate(
+    tenantId: number,
+    exchangeRateId: number
+  ): Promise<void> {
+    const { ExchangeRate } = this.tenancy.models(tenantId);
+    await this.validateExchangeRateExistance(tenantId, exchangeRateId);
+
+    await ExchangeRate.query().findById(exchangeRateId).delete();
+  }
+
+  /**
+   * Listing exchange rates details.
+   * @param {number} tenantId - Tenant id.
+   * @param {IExchangeRateFilter} exchangeRateFilter - Exchange rates list filter.
+   */
+  public async listExchangeRates(
+    tenantId: number,
+    exchangeRateFilter: IExchangeRateFilter
+  ): Promise<void> {
+    const { ExchangeRate } = this.tenancy.models(tenantId);
+    const dynamicFilter = await this.dynamicListService.dynamicList(
+      tenantId,
+      ExchangeRate,
+      exchangeRateFilter
+    );
+    // Retrieve exchange rates by the given query.
+    const exchangeRates = await ExchangeRate.query()
+      .onBuild((query) => {
+        dynamicFilter.buildQuery()(query);
+      })
+      .pagination(exchangeRateFilter.page - 1, exchangeRateFilter.pageSize);
+
+    return exchangeRates;
+  }
+
+  /**
+   * Validates period of the exchange rate existance.
+   * @param {number} tenantId - Tenant id.
+   * @param {IExchangeRateDTO} exchangeRateDTO - Exchange rate DTO.
+   * @return {Promise<void>}
+   */
+  private async validateExchangeRatePeriodExistance(
+    tenantId: number,
+    exchangeRateDTO: IExchangeRateDTO
+  ): Promise<void> {
+    const { ExchangeRate } = this.tenancy.models(tenantId);
+
+    this.logger.info('[exchange_rates] trying to validate period existance.', {
+      tenantId,
+    });
+    const foundExchangeRate = await ExchangeRate.query()
+      .where('currency_code', exchangeRateDTO.currencyCode)
+      .where('date', exchangeRateDTO.date);
+
+    if (foundExchangeRate.length > 0) {
+      this.logger.info('[exchange_rates] given exchange rate period exists.', {
+        tenantId,
+      });
+      throw new ServiceError(ERRORS.EXCHANGE_RATE_PERIOD_EXISTS);
+    }
+  }
+
+  /**
+   * Validate the given echange rate id existance.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} exchangeRateId - Exchange rate id.
+   * @returns {Promise<void>}
+   */
+  private async validateExchangeRateExistance(
+    tenantId: number,
+    exchangeRateId: number
+  ) {
+    const { ExchangeRate } = this.tenancy.models(tenantId);
+
+    this.logger.info(
+      '[exchange_rates] trying to validate exchange rate id existance.',
+      { tenantId, exchangeRateId }
+    );
+    const foundExchangeRate = await ExchangeRate.query().findById(
+      exchangeRateId
+    );
+
+    if (!foundExchangeRate) {
+      this.logger.info('[exchange_rates] exchange rate not found.', {
+        tenantId,
+        exchangeRateId,
+      });
+      throw new ServiceError(ERRORS.EXCHANGE_RATE_NOT_FOUND);
+    }
+  }
+}
diff --git a/packages/server/src/services/Expenses/CRUD/CommandExpenseValidator.ts b/packages/server/src/services/Expenses/CRUD/CommandExpenseValidator.ts
new file mode 100644
index 000000000..4e71b6ce3
--- /dev/null
+++ b/packages/server/src/services/Expenses/CRUD/CommandExpenseValidator.ts
@@ -0,0 +1,117 @@
+import { Service, Inject } from 'typedi';
+import { sumBy, difference } from 'lodash';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from '../constants';
+import {
+  IAccount,
+  IExpense,
+  IExpenseCreateDTO,
+  IExpenseEditDTO,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ACCOUNT_PARENT_TYPE, ACCOUNT_ROOT_TYPE } from '@/data/AccountTypes';
+
+@Service()
+export class CommandExpenseValidator {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Validates expense categories not equals zero.
+   * @param  {IExpenseCreateDTO | IExpenseEditDTO} expenseDTO
+   * @throws {ServiceError}
+   */
+  public validateCategoriesNotEqualZero = (
+    expenseDTO: IExpenseCreateDTO | IExpenseEditDTO
+  ) => {
+    const totalAmount = sumBy(expenseDTO.categories, 'amount') || 0;
+
+    if (totalAmount <= 0) {
+      throw new ServiceError(ERRORS.TOTAL_AMOUNT_EQUALS_ZERO);
+    }
+  };
+
+  /**
+   * Retrieve expense accounts or throw error in case one of the given accounts
+   * not found not the storage.
+   * @param   {number} tenantId
+   * @param   {number} expenseAccountsIds
+   * @throws  {ServiceError}
+   * @returns {Promise<IAccount[]>}
+   */
+  public validateExpensesAccountsExistance(
+    expenseAccounts: IAccount[],
+    DTOAccountsIds: number[]
+  ) {
+    const storedExpenseAccountsIds = expenseAccounts.map((a: IAccount) => a.id);
+
+    const notStoredAccountsIds = difference(
+      DTOAccountsIds,
+      storedExpenseAccountsIds
+    );
+    if (notStoredAccountsIds.length > 0) {
+      throw new ServiceError(ERRORS.SOME_ACCOUNTS_NOT_FOUND);
+    }
+  }
+
+  /**
+   * Validate expenses accounts type.
+   * @param {number} tenantId
+   * @param {number[]} expensesAccountsIds
+   */
+  public validateExpensesAccountsType = (expensesAccounts: IAccount[]) => {
+    const invalidExpenseAccounts: number[] = [];
+
+    expensesAccounts.forEach((expenseAccount) => {
+      if (!expenseAccount.isRootType(ACCOUNT_ROOT_TYPE.EXPENSE)) {
+        invalidExpenseAccounts.push(expenseAccount.id);
+      }
+    });
+    if (invalidExpenseAccounts.length > 0) {
+      throw new ServiceError(ERRORS.EXPENSES_ACCOUNT_HAS_INVALID_TYPE);
+    }
+  };
+
+  /**
+   * Validates payment account type in case has invalid type throws errors.
+   * @param  {number} tenantId
+   * @param  {number} paymentAccountId
+   * @throws {ServiceError}
+   */
+  public validatePaymentAccountType = (paymentAccount: number[]) => {
+    if (!paymentAccount.isParentType(ACCOUNT_PARENT_TYPE.CURRENT_ASSET)) {
+      throw new ServiceError(ERRORS.PAYMENT_ACCOUNT_HAS_INVALID_TYPE);
+    }
+  };
+
+  /**
+   * Validates the expense has not associated landed cost
+   * references to the given expense.
+   * @param {number} tenantId
+   * @param {number} expenseId
+   */
+  public async validateNoAssociatedLandedCost(
+    tenantId: number,
+    expenseId: number
+  ) {
+    const { BillLandedCost } = this.tenancy.models(tenantId);
+
+    const associatedLandedCosts = await BillLandedCost.query()
+      .where('fromTransactionType', 'Expense')
+      .where('fromTransactionId', expenseId);
+
+    if (associatedLandedCosts.length > 0) {
+      throw new ServiceError(ERRORS.EXPENSE_HAS_ASSOCIATED_LANDED_COST);
+    }
+  }
+
+  /**
+   * Validates expenses is not already published before.
+   * @param {IExpense} expense
+   */
+  public validateExpenseIsNotPublished(expense: IExpense) {
+    if (expense.publishedAt) {
+      throw new ServiceError(ERRORS.EXPENSE_ALREADY_PUBLISHED);
+    }
+  }
+}
diff --git a/packages/server/src/services/Expenses/CRUD/CreateExpense.ts b/packages/server/src/services/Expenses/CRUD/CreateExpense.ts
new file mode 100644
index 000000000..c0f0824bf
--- /dev/null
+++ b/packages/server/src/services/Expenses/CRUD/CreateExpense.ts
@@ -0,0 +1,130 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import events from '@/subscribers/events';
+import {
+  IExpense,
+  IExpenseCreateDTO,
+  ISystemUser,
+  IExpenseCreatedPayload,
+  IExpenseCreatingPayload,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+import { CommandExpenseValidator } from './CommandExpenseValidator';
+import { ExpenseDTOTransformer } from './ExpenseDTOTransformer';
+
+@Service()
+export class CreateExpense {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private validator: CommandExpenseValidator;
+
+  @Inject()
+  private transformDTO: ExpenseDTOTransformer;
+
+  /**
+   * Authorize before create a new expense transaction.
+   * @param {number} tenantId
+   * @param {IExpenseDTO} expenseDTO
+   */
+  private authorize = async (
+    tenantId: number,
+    expenseDTO: IExpenseCreateDTO
+  ) => {
+    const { Account } = await this.tenancy.models(tenantId);
+
+    // Validate payment account existance on the storage.
+    const paymentAccount = await Account.query()
+      .findById(expenseDTO.paymentAccountId)
+      .throwIfNotFound();
+
+    // Retrieves the DTO expense accounts ids.
+    const DTOExpenseAccountsIds = expenseDTO.categories.map(
+      (category) => category.expenseAccountId
+    );
+    // Retrieves the expenses accounts.
+    const expenseAccounts = await Account.query().whereIn(
+      'id',
+      DTOExpenseAccountsIds
+    );
+    // Validate expense accounts exist on the storage.
+    this.validator.validateExpensesAccountsExistance(
+      expenseAccounts,
+      DTOExpenseAccountsIds
+    );
+    // Validate payment account type.
+    this.validator.validatePaymentAccountType(paymentAccount);
+
+    // Validate expenses accounts type.
+    this.validator.validateExpensesAccountsType(expenseAccounts);
+
+    // Validate the given expense categories not equal zero.
+    this.validator.validateCategoriesNotEqualZero(expenseDTO);
+  };
+
+  /**
+   * Precedures.
+   * ---------
+   * 1. Validate payment account existance on the storage.
+   * 2. Validate expense accounts exist on the storage.
+   * 3. Validate payment account type.
+   * 4. Validate expenses accounts type.
+   * 5. Validate the expense payee contact id existance on storage.
+   * 6. Validate the given expense categories not equal zero.
+   * 7. Stores the expense to the storage.
+   * ---------
+   * @param {number} tenantId
+   * @param {IExpenseDTO} expenseDTO
+   */
+  public newExpense = async (
+    tenantId: number,
+    expenseDTO: IExpenseCreateDTO,
+    authorizedUser: ISystemUser
+  ): Promise<IExpense> => {
+    const { Expense } = await this.tenancy.models(tenantId);
+
+    // Authorize before create a new expense.
+    await this.authorize(tenantId, expenseDTO);
+
+    // Save the expense to the storage.
+    const expenseObj = await this.transformDTO.expenseCreateDTO(
+      tenantId,
+      expenseDTO,
+      authorizedUser
+    );
+    // Writes the expense transaction with associated transactions under
+    // unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onExpenseCreating` event.
+      await this.eventPublisher.emitAsync(events.expenses.onCreating, {
+        trx,
+        tenantId,
+        expenseDTO,
+      } as IExpenseCreatingPayload);
+
+      // Creates a new expense transaction graph.
+      const expense: IExpense = await Expense.query(trx).upsertGraph(
+        expenseObj
+      );
+      // Triggers `onExpenseCreated` event.
+      await this.eventPublisher.emitAsync(events.expenses.onCreated, {
+        tenantId,
+        expenseId: expense.id,
+        authorizedUser,
+        expense,
+        trx,
+      } as IExpenseCreatedPayload);
+
+      return expense;
+    });
+  };
+}
diff --git a/packages/server/src/services/Expenses/CRUD/DeleteExpense.ts b/packages/server/src/services/Expenses/CRUD/DeleteExpense.ts
new file mode 100644
index 000000000..78fe74fad
--- /dev/null
+++ b/packages/server/src/services/Expenses/CRUD/DeleteExpense.ts
@@ -0,0 +1,78 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import {
+  ISystemUser,
+  IExpenseEventDeletePayload,
+  IExpenseDeletingPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import { CommandExpenseValidator } from './CommandExpenseValidator';
+import { ExpenseCategory } from 'models';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class DeleteExpense {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private validator: CommandExpenseValidator;
+
+  /**
+   * Deletes the given expense.
+   * @param {number} tenantId
+   * @param {number} expenseId
+   * @param {ISystemUser} authorizedUser
+   */
+  public deleteExpense = async (
+    tenantId: number,
+    expenseId: number,
+    authorizedUser: ISystemUser
+  ): Promise<void> => {
+    const { Expense } = this.tenancy.models(tenantId);
+
+    // Retrieves the expense transaction with associated entries or
+    // throw not found error.
+    const oldExpense = await Expense.query()
+      .findById(expenseId)
+      .withGraphFetched('categories')
+      .throwIfNotFound();
+
+    // Validates the expense has no associated landed cost.
+    await this.validator.validateNoAssociatedLandedCost(tenantId, expenseId);
+
+    // Deletes expense transactions with associated transactions under
+    // unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onExpenseDeleting` event.
+      await this.eventPublisher.emitAsync(events.expenses.onDeleting, {
+        trx,
+        tenantId,
+        oldExpense,
+      } as IExpenseDeletingPayload);
+
+      // Deletes expense associated entries.
+      await ExpenseCategory.query(trx).findById(expenseId).delete();
+
+      // Deletes expense transactions.
+      await Expense.query(trx).findById(expenseId).delete();
+
+      // Triggers `onExpenseDeleted` event.
+      await this.eventPublisher.emitAsync(events.expenses.onDeleted, {
+        tenantId,
+        expenseId,
+        authorizedUser,
+        oldExpense,
+        trx,
+      } as IExpenseEventDeletePayload);
+    });
+  };
+}
diff --git a/packages/server/src/services/Expenses/CRUD/EditExpense.ts b/packages/server/src/services/Expenses/CRUD/EditExpense.ts
new file mode 100644
index 000000000..93b0acc62
--- /dev/null
+++ b/packages/server/src/services/Expenses/CRUD/EditExpense.ts
@@ -0,0 +1,157 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import {
+  IExpense,
+  ISystemUser,
+  IExpenseEventEditPayload,
+  IExpenseEventEditingPayload,
+  IExpenseEditDTO,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import { CommandExpenseValidator } from './CommandExpenseValidator';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ExpenseDTOTransformer } from './ExpenseDTOTransformer';
+import EntriesService from '@/services/Entries';
+
+@Service()
+export class EditExpense {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private validator: CommandExpenseValidator;
+
+  @Inject()
+  private transformDTO: ExpenseDTOTransformer;
+
+  @Inject()
+  private entriesService: EntriesService;
+
+  /**
+   * Authorize the DTO before editing expense transaction.
+   * @param {number} tenantId
+   * @param {number} expenseId
+   * @param {IExpenseEditDTO} expenseDTO
+   */
+  public authorize = async (
+    tenantId: number,
+    oldExpense: IExpense,
+    expenseDTO: IExpenseEditDTO
+  ) => {
+    const { Account } = this.tenancy.models(tenantId);
+
+    // Validate payment account existance on the storage.
+    const paymentAccount = await Account.query()
+      .findById(expenseDTO.paymentAccountId)
+      .throwIfNotFound();
+
+    // Retrieves the DTO expense accounts ids.
+    const DTOExpenseAccountsIds = expenseDTO.categories.map(
+      (category) => category.expenseAccountId
+    );
+    // Retrieves the expenses accounts.
+    const expenseAccounts = await Account.query().whereIn(
+      'id',
+      DTOExpenseAccountsIds
+    );
+    // Validate expense accounts exist on the storage.
+    this.validator.validateExpensesAccountsExistance(
+      expenseAccounts,
+      DTOExpenseAccountsIds
+    );
+    // Validate payment account type.
+    await this.validator.validatePaymentAccountType(paymentAccount);
+
+    // Validate expenses accounts type.
+    await this.validator.validateExpensesAccountsType(expenseAccounts);
+    // Validate the given expense categories not equal zero.
+    this.validator.validateCategoriesNotEqualZero(expenseDTO);
+
+    // Validate expense entries that have allocated landed cost cannot be deleted.
+    this.entriesService.validateLandedCostEntriesNotDeleted(
+      oldExpense.categories,
+      expenseDTO.categories
+    );
+    // Validate expense entries that have allocated cost amount should be bigger than amount.
+    this.entriesService.validateLocatedCostEntriesSmallerThanNewEntries(
+      oldExpense.categories,
+      expenseDTO.categories
+    );
+  };
+
+  /**
+   * Precedures.
+   * ---------
+   * 1. Validate expense existance.
+   * 2. Validate payment account existance on the storage.
+   * 3. Validate expense accounts exist on the storage.
+   * 4. Validate payment account type.
+   * 5. Validate expenses accounts type.
+   * 6. Validate the given expense categories not equal zero.
+   * 7. Stores the expense to the storage.
+   * ---------
+   * @param {number} tenantId
+   * @param {number} expenseId
+   * @param {IExpenseDTO} expenseDTO
+   * @param {ISystemUser} authorizedUser
+   */
+  public async editExpense(
+    tenantId: number,
+    expenseId: number,
+    expenseDTO: IExpenseEditDTO,
+    authorizedUser: ISystemUser
+  ): Promise<IExpense> {
+    const { Expense } = this.tenancy.models(tenantId);
+
+    // Retrieves the expense model or throw not found error.
+    const oldExpense = await Expense.query()
+      .findById(expenseId)
+      .withGraphFetched('categories')
+      .throwIfNotFound();
+
+    // Authorize expense DTO before editing.
+    await this.authorize(tenantId, oldExpense, expenseDTO);
+
+    // Update the expense on the storage.
+    const expenseObj = await this.transformDTO.expenseEditDTO(
+      tenantId,
+      expenseDTO
+    );
+    // Edits expense transactions and associated transactions under UOW envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onExpenseEditing` event.
+      await this.eventPublisher.emitAsync(events.expenses.onEditing, {
+        tenantId,
+        oldExpense,
+        expenseDTO,
+        trx,
+      } as IExpenseEventEditingPayload);
+
+      // Upsert the expense object with expense entries.
+      const expense: IExpense = await Expense.query(trx).upsertGraph({
+        id: expenseId,
+        ...expenseObj,
+      });
+      // Triggers `onExpenseCreated` event.
+      await this.eventPublisher.emitAsync(events.expenses.onEdited, {
+        tenantId,
+        expenseId,
+        expense,
+        expenseDTO,
+        authorizedUser,
+        oldExpense,
+        trx,
+      } as IExpenseEventEditPayload);
+
+      return expense;
+    });
+  }
+}
diff --git a/packages/server/src/services/Expenses/CRUD/ExpenseDTOTransformer.ts b/packages/server/src/services/Expenses/CRUD/ExpenseDTOTransformer.ts
new file mode 100644
index 000000000..9357df7c5
--- /dev/null
+++ b/packages/server/src/services/Expenses/CRUD/ExpenseDTOTransformer.ts
@@ -0,0 +1,115 @@
+import { Service, Inject } from 'typedi';
+import { omit, sumBy } from 'lodash';
+import moment from 'moment';
+import * as R from 'ramda';
+import {
+  IExpense,
+  IExpenseCreateDTO,
+  IExpenseDTO,
+  IExpenseEditDTO,
+  ISystemUser,
+} from '@/interfaces';
+import { BranchTransactionDTOTransform } from '@/services/Branches/Integrations/BranchTransactionDTOTransform';
+import { TenantMetadata } from '@/system/models';
+
+@Service()
+export class ExpenseDTOTransformer {
+  @Inject()
+  private branchDTOTransform: BranchTransactionDTOTransform;
+
+  /**
+   * Retrieve the expense landed cost amount.
+   * @param  {IExpenseDTO} expenseDTO
+   * @return {number}
+   */
+  private getExpenseLandedCostAmount = (expenseDTO: IExpenseDTO): number => {
+    const landedCostEntries = expenseDTO.categories.filter((entry) => {
+      return entry.landedCost === true;
+    });
+    return this.getExpenseCategoriesTotal(landedCostEntries);
+  };
+
+  /**
+   * Retrieve the given expense categories total.
+   * @param   {IExpenseCategory} categories
+   * @returns {number}
+   */
+  private getExpenseCategoriesTotal = (categories): number => {
+    return sumBy(categories, 'amount');
+  };
+
+  /**
+   * Mapping expense DTO to model.
+   * @param  {IExpenseDTO} expenseDTO
+   * @param  {ISystemUser} authorizedUser
+   * @return {IExpense}
+   */
+  private expenseDTOToModel(
+    tenantId: number,
+    expenseDTO: IExpenseCreateDTO | IExpenseEditDTO,
+    user?: ISystemUser
+  ): IExpense {
+    const landedCostAmount = this.getExpenseLandedCostAmount(expenseDTO);
+    const totalAmount = this.getExpenseCategoriesTotal(expenseDTO.categories);
+
+    const initialDTO = {
+      categories: [],
+      ...omit(expenseDTO, ['publish']),
+      totalAmount,
+      landedCostAmount,
+      paymentDate: moment(expenseDTO.paymentDate).toMySqlDateTime(),
+      ...(expenseDTO.publish
+        ? {
+            publishedAt: moment().toMySqlDateTime(),
+          }
+        : {}),
+    };
+    return R.compose(this.branchDTOTransform.transformDTO<IExpense>(tenantId))(
+      initialDTO
+    );
+  }
+
+  /**
+   * Transformes the expense create DTO.
+   * @param   {number} tenantId
+   * @param   {IExpenseCreateDTO} expenseDTO
+   * @param   {ISystemUser} user
+   * @returns {IExpense}
+   */
+  public expenseCreateDTO = async (
+    tenantId: number,
+    expenseDTO: IExpenseCreateDTO,
+    user?: ISystemUser
+  ): Promise<IExpense> => {
+    const initialDTO = this.expenseDTOToModel(tenantId, expenseDTO, user);
+
+    // Retrieves the tenant metadata.
+    const tenantMetadata = await TenantMetadata.query().findOne({ tenantId });
+
+    return {
+      ...initialDTO,
+      currencyCode: expenseDTO.currencyCode || tenantMetadata?.baseCurrency,
+      exchangeRate: expenseDTO.exchangeRate || 1,
+      ...(user
+        ? {
+            userId: user.id,
+          }
+        : {}),
+    };
+  };
+
+  /**
+   * Transformes the expense edit DTO.
+   * @param   {number} tenantId
+   * @param   {IExpenseEditDTO} expenseDTO
+   * @param   {ISystemUser} user
+   * @returns {IExpense}
+   */
+  public expenseEditDTO = async (
+    tenantId: number,
+    expenseDTO: IExpenseEditDTO,
+    user?: ISystemUser
+  ): Promise<IExpense> => {
+    return this.expenseDTOToModel(tenantId, expenseDTO, user);
+  };
+}
diff --git a/packages/server/src/services/Expenses/CRUD/ExpenseTransformer.ts b/packages/server/src/services/Expenses/CRUD/ExpenseTransformer.ts
new file mode 100644
index 000000000..2812a9261
--- /dev/null
+++ b/packages/server/src/services/Expenses/CRUD/ExpenseTransformer.ts
@@ -0,0 +1,60 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+import { IExpense } from '@/interfaces';
+
+export class ExpenseTransfromer extends Transformer {
+  /**
+   * Include these attributes to expense object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedAmount',
+      'formattedLandedCostAmount',
+      'formattedAllocatedCostAmount',
+      'formattedDate'
+    ];
+  };
+
+  /**
+   * Retrieve formatted expense amount.
+   * @param {IExpense} expense
+   * @returns {string}
+   */
+  protected formattedAmount = (expense: IExpense): string => {
+    return formatNumber(expense.totalAmount, {
+      currencyCode: expense.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve formatted expense landed cost amount.
+   * @param {IExpense} expense
+   * @returns {string}
+   */
+  protected formattedLandedCostAmount = (expense: IExpense): string => {
+    return formatNumber(expense.landedCostAmount, {
+      currencyCode: expense.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve formatted allocated cost amount.
+   * @param {IExpense} expense
+   * @returns {string}
+   */
+  protected formattedAllocatedCostAmount = (expense: IExpense): string => {
+    return formatNumber(expense.allocatedCostAmount, {
+      currencyCode: expense.currencyCode,
+    });
+  };
+
+  /**
+   * Retriecve fromatted date.
+   * @param {IExpense} expense
+   * @returns {string}
+   */
+  protected formattedDate = (expense: IExpense): string => {
+    return this.formatDate(expense.paymentDate);
+  }
+}
diff --git a/packages/server/src/services/Expenses/CRUD/GetExpense.ts b/packages/server/src/services/Expenses/CRUD/GetExpense.ts
new file mode 100644
index 000000000..2203d4e13
--- /dev/null
+++ b/packages/server/src/services/Expenses/CRUD/GetExpense.ts
@@ -0,0 +1,41 @@
+import { IExpense } from '@/interfaces';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Service, Inject } from 'typedi';
+import { ExpenseTransfromer } from './ExpenseTransformer';
+
+@Service()
+export class GetExpense {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve expense details.
+   * @param {number} tenantId
+   * @param {number} expenseId
+   * @return {Promise<IExpense>}
+   */
+  public async getExpense(
+    tenantId: number,
+    expenseId: number
+  ): Promise<IExpense> {
+    const { Expense } = this.tenancy.models(tenantId);
+
+    const expense = await Expense.query()
+      .findById(expenseId)
+      .withGraphFetched('categories.expenseAccount')
+      .withGraphFetched('paymentAccount')
+      .withGraphFetched('branch')
+      .throwIfNotFound();
+
+    // Transformes expense model to POJO.
+    return this.transformer.transform(
+      tenantId,
+      expense,
+      new ExpenseTransfromer()
+    );
+  }
+}
diff --git a/packages/server/src/services/Expenses/CRUD/GetExpenses.ts b/packages/server/src/services/Expenses/CRUD/GetExpenses.ts
new file mode 100644
index 000000000..95e9d0c61
--- /dev/null
+++ b/packages/server/src/services/Expenses/CRUD/GetExpenses.ts
@@ -0,0 +1,80 @@
+import { Service, Inject } from 'typedi';
+import * as R from 'ramda';
+import {
+  IExpensesFilter,
+  IExpense,
+  IPaginationMeta,
+  IFilterMeta,
+} from '@/interfaces';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ExpenseTransfromer } from './ExpenseTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export class GetExpenses {
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve expenses paginated list.
+   * @param  {number} tenantId
+   * @param  {IExpensesFilter} expensesFilter
+   * @return {IExpense[]}
+   */
+  public getExpensesList = async (
+    tenantId: number,
+    filterDTO: IExpensesFilter
+  ): Promise<{
+    expenses: IExpense[];
+    pagination: IPaginationMeta;
+    filterMeta: IFilterMeta;
+  }> => {
+    const { Expense } = this.tenancy.models(tenantId);
+
+    // Parses list filter DTO.
+    const filter = this.parseListFilterDTO(filterDTO);
+
+    // Dynamic list service.
+    const dynamicList = await this.dynamicListService.dynamicList(
+      tenantId,
+      Expense,
+      filter
+    );
+    // Retrieves the paginated results.
+    const { results, pagination } = await Expense.query()
+      .onBuild((builder) => {
+        builder.withGraphFetched('paymentAccount');
+        builder.withGraphFetched('categories.expenseAccount');
+
+        dynamicList.buildQuery()(builder);
+      })
+      .pagination(filter.page - 1, filter.pageSize);
+
+    // Transformes the expenses models to POJO.
+    const expenses = await this.transformer.transform(
+      tenantId,
+      results,
+      new ExpenseTransfromer()
+    );
+    return {
+      expenses,
+      pagination,
+      filterMeta: dynamicList.getResponseMeta(),
+    };
+  };
+
+  /**
+   * Parses filter DTO of expenses list.
+   * @param filterDTO -
+   */
+  private parseListFilterDTO(filterDTO) {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  }
+}
diff --git a/packages/server/src/services/Expenses/CRUD/PublishExpense.ts b/packages/server/src/services/Expenses/CRUD/PublishExpense.ts
new file mode 100644
index 000000000..8962dbacd
--- /dev/null
+++ b/packages/server/src/services/Expenses/CRUD/PublishExpense.ts
@@ -0,0 +1,79 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import {
+  ISystemUser,
+  IExpensePublishingPayload,
+  IExpenseEventPublishedPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import { CommandExpenseValidator } from './CommandExpenseValidator';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Inject()
+export class PublishExpense {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private validator: CommandExpenseValidator;
+
+  /**
+   * Publish the given expense.
+   * @param {number} tenantId
+   * @param {number} expenseId
+   * @param {ISystemUser} authorizedUser
+   * @return {Promise<void>}
+   */
+  public async publishExpense(
+    tenantId: number,
+    expenseId: number,
+    authorizedUser: ISystemUser
+  ) {
+    const { Expense } = this.tenancy.models(tenantId);
+
+    // Retrieves the old expense or throw not found error.
+    const oldExpense = await Expense.query()
+      .findById(expenseId)
+      .throwIfNotFound();
+
+    // Validate the expense whether is published before.
+    this.validator.validateExpenseIsNotPublished(oldExpense);
+
+    // Publishes expense transactions with associated transactions
+    // under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Trigggers `onExpensePublishing` event.
+      await this.eventPublisher.emitAsync(events.expenses.onPublishing, {
+        trx,
+        oldExpense,
+        tenantId,
+      } as IExpensePublishingPayload);
+
+      // Publish the given expense on the storage.
+      await Expense.query().findById(expenseId).modify('publish');
+
+      // Retrieve the new expense after modification.
+      const expense = await Expense.query()
+        .findById(expenseId)
+        .withGraphFetched('categories');
+
+      // Triggers `onExpensePublished` event.
+      await this.eventPublisher.emitAsync(events.expenses.onPublished, {
+        tenantId,
+        expenseId,
+        oldExpense,
+        expense,
+        authorizedUser,
+        trx,
+      } as IExpenseEventPublishedPayload);
+    });
+  }
+}
diff --git a/packages/server/src/services/Expenses/ExpenseGLEntries.ts b/packages/server/src/services/Expenses/ExpenseGLEntries.ts
new file mode 100644
index 000000000..527199388
--- /dev/null
+++ b/packages/server/src/services/Expenses/ExpenseGLEntries.ts
@@ -0,0 +1,106 @@
+import * as R from 'ramda';
+import { Service } from 'typedi';
+import {
+  AccountNormal,
+  IExpense,
+  IExpenseCategory,
+  ILedger,
+  ILedgerEntry,
+} from '@/interfaces';
+import Ledger from '@/services/Accounting/Ledger';
+
+@Service()
+export class ExpenseGLEntries {
+  /**
+   * Retrieves the expense GL common entry.
+   * @param {IExpense} expense
+   * @returns
+   */
+  private getExpenseGLCommonEntry = (expense: IExpense) => {
+    return {
+      currencyCode: expense.currencyCode,
+      exchangeRate: expense.exchangeRate,
+
+      transactionType: 'Expense',
+      transactionId: expense.id,
+
+      date: expense.paymentDate,
+      userId: expense.userId,
+
+      debit: 0,
+      credit: 0,
+
+      branchId: expense.branchId,
+    };
+  };
+
+  /**
+   * Retrieves the expense GL payment entry.
+   * @param   {IExpense} expense
+   * @returns {ILedgerEntry}
+   */
+  private getExpenseGLPaymentEntry = (expense: IExpense): ILedgerEntry => {
+    const commonEntry = this.getExpenseGLCommonEntry(expense);
+
+    return {
+      ...commonEntry,
+      credit: expense.localAmount,
+      accountId: expense.paymentAccountId,
+      accountNormal: AccountNormal.CREDIT,
+      index: 1,
+    };
+  };
+
+  /**
+   * Retrieves the expense GL category entry.
+   * @param   {IExpense} expense -
+   * @param   {IExpenseCategory} expenseCategory -
+   * @param   {number} index
+   * @returns {ILedgerEntry}
+   */
+  private getExpenseGLCategoryEntry = R.curry(
+    (
+      expense: IExpense,
+      category: IExpenseCategory,
+      index: number
+    ): ILedgerEntry => {
+      const commonEntry = this.getExpenseGLCommonEntry(expense);
+      const localAmount = category.amount * expense.exchangeRate;
+
+      return {
+        ...commonEntry,
+        accountId: category.expenseAccountId,
+        accountNormal: AccountNormal.DEBIT,
+        debit: localAmount,
+        note: category.description,
+        index: index + 2,
+        projectId: category.projectId,
+      };
+    }
+  );
+
+  /**
+   * Retrieves the expense GL entries.
+   * @param   {IExpense} expense
+   * @returns {ILedgerEntry[]}
+   */
+  public getExpenseGLEntries = (expense: IExpense): ILedgerEntry[] => {
+    const getCategoryEntry = this.getExpenseGLCategoryEntry(expense);
+
+    const paymentEntry = this.getExpenseGLPaymentEntry(expense);
+    const categoryEntries = expense.categories.map(getCategoryEntry);
+
+    return [paymentEntry, ...categoryEntries];
+  };
+
+  /**
+   * Retrieves the given expense ledger.
+   * @param   {IExpense} expense
+   * @returns {ILedger}
+   */
+  public getExpenseLedger = (expense: IExpense): ILedger => {
+    const entries = this.getExpenseGLEntries(expense);
+
+    return new Ledger(entries);
+  };
+}
diff --git a/packages/server/src/services/Expenses/ExpenseGLEntriesStorage.ts b/packages/server/src/services/Expenses/ExpenseGLEntriesStorage.ts
new file mode 100644
index 000000000..0821c3bd4
--- /dev/null
+++ b/packages/server/src/services/Expenses/ExpenseGLEntriesStorage.ts
@@ -0,0 +1,78 @@
+import { Knex } from 'knex';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Service, Inject } from 'typedi';
+import { ExpenseGLEntries } from './ExpenseGLEntries';
+
+@Service()
+export class ExpenseGLEntriesStorage {
+  @Inject()
+  private expenseGLEntries: ExpenseGLEntries;
+
+  @Inject()
+  private ledgerStorage: LedgerStorageService;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Writes the expense GL entries.
+   * @param {number} tenantId
+   * @param {number} expenseId
+   * @param {Knex.Transaction} trx
+   */
+  public writeExpenseGLEntries = async (
+    tenantId: number,
+    expenseId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { Expense } = await this.tenancy.models(tenantId);
+
+    const expense = await Expense.query(trx)
+      .findById(expenseId)
+      .withGraphFetched('categories');
+
+    // Retrieves the given expense ledger.
+    const expenseLedger = this.expenseGLEntries.getExpenseLedger(expense);
+
+    // Commits the expense ledger entries.
+    await this.ledgerStorage.commit(tenantId, expenseLedger, trx);
+  };
+
+  /**
+   * Reverts the given expense GL entries.
+   * @param {number} tenantId
+   * @param {number} expenseId
+   * @param {Knex.Transaction} trx
+   */
+  public revertExpenseGLEntries = async (
+    tenantId: number,
+    expenseId: number,
+    trx?: Knex.Transaction
+  ) => {
+    await this.ledgerStorage.deleteByReference(
+      tenantId,
+      expenseId,
+      'Expense',
+      trx
+    );
+  };
+
+  /**
+   * Rewrites the expense GL entries.
+   * @param {number} tenantId
+   * @param {number} expenseId
+   * @param {Knex.Transaction} trx
+   */
+  public rewriteExpenseGLEntries = async (
+    tenantId: number,
+    expenseId: number,
+    trx?: Knex.Transaction
+  ) => {
+    // Reverts the expense GL entries.
+    await this.revertExpenseGLEntries(tenantId, expenseId, trx);
+
+    // Writes the expense GL entries.
+    await this.writeExpenseGLEntries(tenantId, expenseId, trx);
+  };
+}
diff --git a/packages/server/src/services/Expenses/ExpenseGLEntriesSubscriber.ts b/packages/server/src/services/Expenses/ExpenseGLEntriesSubscriber.ts
new file mode 100644
index 000000000..56d37a7db
--- /dev/null
+++ b/packages/server/src/services/Expenses/ExpenseGLEntriesSubscriber.ts
@@ -0,0 +1,117 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import {
+  IExpenseCreatedPayload,
+  IExpenseEventDeletePayload,
+  IExpenseEventEditPayload,
+  IExpenseEventPublishedPayload,
+} from '@/interfaces';
+import { ExpenseGLEntriesStorage } from './ExpenseGLEntriesStorage';
+
+@Service()
+export class ExpensesWriteGLSubscriber {
+  @Inject()
+  private tenancy: TenancyService;
+
+  @Inject()
+  private expenseGLEntries: ExpenseGLEntriesStorage;
+
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.expenses.onCreated,
+      this.handleWriteGLEntriesOnceCreated
+    );
+    bus.subscribe(
+      events.expenses.onEdited,
+      this.handleRewriteGLEntriesOnceEdited
+    );
+    bus.subscribe(
+      events.expenses.onDeleted,
+      this.handleRevertGLEntriesOnceDeleted
+    );
+    bus.subscribe(
+      events.expenses.onPublished,
+      this.handleWriteGLEntriesOncePublished
+    );
+  }
+
+  /**
+   * Handles the writing journal entries once the expense created.
+   * @param {IExpenseCreatedPayload} payload -
+   */
+  public handleWriteGLEntriesOnceCreated = async ({
+    expense,
+    tenantId,
+    trx,
+  }: IExpenseCreatedPayload) => {
+    // In case expense published, write journal entries.
+    if (!expense.publishedAt) return;
+
+    await this.expenseGLEntries.writeExpenseGLEntries(
+      tenantId,
+      expense.id,
+      trx
+    );
+  };
+
+  /**
+   * Handle writing expense journal entries once the expense edited.
+   * @param {IExpenseEventEditPayload} payload -
+   */
+  public handleRewriteGLEntriesOnceEdited = async ({
+    expenseId,
+    tenantId,
+    expense,
+    authorizedUser,
+    trx,
+  }: IExpenseEventEditPayload) => {
+    // In case expense published, write journal entries.
+    if (expense.publishedAt) return;
+
+    await this.expenseGLEntries.writeExpenseGLEntries(
+      tenantId,
+      expense.id,
+      trx
+    );
+  };
+
+  /**
+   * Reverts expense journal entries once the expense deleted.
+   * @param {IExpenseEventDeletePayload} payload -
+   */
+  public handleRevertGLEntriesOnceDeleted = async ({
+    expenseId,
+    tenantId,
+    trx,
+  }: IExpenseEventDeletePayload) => {
+    await this.expenseGLEntries.revertExpenseGLEntries(
+      tenantId,
+      expenseId,
+      trx
+    );
+  };
+
+  /**
+   * Handles writing expense journal once the expense publish.
+   * @param {IExpenseEventPublishedPayload} payload -
+   */
+  public handleWriteGLEntriesOncePublished = async ({
+    tenantId,
+    expense,
+    trx,
+  }: IExpenseEventPublishedPayload) => {
+    // In case expense published, write journal entries.
+    if (!expense.publishedAt) return;
+
+    await this.expenseGLEntries.rewriteExpenseGLEntries(
+      tenantId,
+      expense.id,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Expenses/ExpensesApplication.ts b/packages/server/src/services/Expenses/ExpensesApplication.ts
new file mode 100644
index 000000000..fbd502f90
--- /dev/null
+++ b/packages/server/src/services/Expenses/ExpensesApplication.ts
@@ -0,0 +1,132 @@
+import {
+  IExpense,
+  IExpenseCreateDTO,
+  IExpenseEditDTO,
+  IExpensesFilter,
+  ISystemUser,
+} from '@/interfaces';
+import { Service, Inject } from 'typedi';
+import { CreateExpense } from './CRUD/CreateExpense';
+import { DeleteExpense } from './CRUD/DeleteExpense';
+import { EditExpense } from './CRUD/EditExpense';
+import { GetExpense } from './CRUD/GetExpense';
+import { GetExpenses } from './CRUD/GetExpenses';
+import { PublishExpense } from './CRUD/PublishExpense';
+
+@Service()
+export class ExpensesApplication {
+  @Inject()
+  private createExpenseService: CreateExpense;
+
+  @Inject()
+  private editExpenseService: EditExpense;
+
+  @Inject()
+  private deleteExpenseService: DeleteExpense;
+
+  @Inject()
+  private publishExpenseService: PublishExpense;
+
+  @Inject()
+  private getExpenseService: GetExpense;
+
+  @Inject()
+  private getExpensesService: GetExpenses;
+
+  /**
+   * Create a new expense transaction.
+   * @param   {number} tenantId
+   * @param   {IExpenseDTO} expenseDTO
+   * @param   {ISystemUser} authorizedUser
+   * @returns {Promise<IExpense>}
+   */
+  public createExpense = (
+    tenantId: number,
+    expenseDTO: IExpenseCreateDTO,
+    authorizedUser: ISystemUser
+  ): Promise<IExpense> => {
+    return this.createExpenseService.newExpense(
+      tenantId,
+      expenseDTO,
+      authorizedUser
+    );
+  };
+
+  /**
+   * Edits the given expense transaction.
+   * @param {number} tenantId
+   * @param {number} expenseId
+   * @param {IExpenseDTO} expenseDTO
+   * @param {ISystemUser} authorizedUser
+   */
+  public editExpense = (
+    tenantId: number,
+    expenseId: number,
+    expenseDTO: IExpenseEditDTO,
+    authorizedUser: ISystemUser
+  ) => {
+    return this.editExpenseService.editExpense(
+      tenantId,
+      expenseId,
+      expenseDTO,
+      authorizedUser
+    );
+  };
+
+  /**
+   * Deletes the given expense.
+   * @param   {number} tenantId
+   * @param   {number} expenseId
+   * @param   {ISystemUser} authorizedUser
+   * @returns {Promise<void>}
+   */
+  public deleteExpense = (
+    tenantId: number,
+    expenseId: number,
+    authorizedUser: ISystemUser
+  ) => {
+    return this.deleteExpenseService.deleteExpense(
+      tenantId,
+      expenseId,
+      authorizedUser
+    );
+  };
+
+  /**
+   * Publishes the given expense.
+   * @param  {number} tenantId
+   * @param  {number} expenseId
+   * @param  {ISystemUser} authorizedUser
+   * @return {Promise<void>}
+   */
+  public publishExpense = (
+    tenantId: number,
+    expenseId: number,
+    authorizedUser: ISystemUser
+  ) => {
+    return this.publishExpenseService.publishExpense(
+      tenantId,
+      expenseId,
+      authorizedUser
+    );
+  };
+
+  /**
+   * Retrieve the given expense details.
+   * @param  {number} tenantId
+   * @param  {number} expenseId
+   * @return {Promise<IExpense>}
+   */
+  public getExpense = (tenantId: number, expenseId: number) => {
+    return this.getExpenseService.getExpense(tenantId, expenseId);
+  };
+
+  /**
+   * Retrieve expenses paginated list.
+   * @param  {number} tenantId
+   * @param  {IExpensesFilter} expensesFilter
+   */
+  public getExpenses = (tenantId: number, filterDTO: IExpensesFilter) => {
+    return this.getExpensesService.getExpensesList(tenantId, filterDTO);
+  };
+}
diff --git a/packages/server/src/services/Expenses/constants.ts b/packages/server/src/services/Expenses/constants.ts
new file mode 100644
index 000000000..424acb9bb
--- /dev/null
+++ b/packages/server/src/services/Expenses/constants.ts
@@ -0,0 +1,38 @@
+export const DEFAULT_VIEW_COLUMNS = [];
+export const DEFAULT_VIEWS = [
+  {
+    name: 'Draft',
+    slug: 'draft',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'draft' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Published',
+    slug: 'published',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'published',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+];
+
+export const ERRORS = {
+  EXPENSE_NOT_FOUND: 'expense_not_found',
+  EXPENSES_NOT_FOUND: 'EXPENSES_NOT_FOUND',
+  PAYMENT_ACCOUNT_NOT_FOUND: 'payment_account_not_found',
+  SOME_ACCOUNTS_NOT_FOUND: 'some_expenses_not_found',
+  TOTAL_AMOUNT_EQUALS_ZERO: 'total_amount_equals_zero',
+  PAYMENT_ACCOUNT_HAS_INVALID_TYPE: 'payment_account_has_invalid_type',
+  EXPENSES_ACCOUNT_HAS_INVALID_TYPE: 'expenses_account_has_invalid_type',
+  EXPENSE_ALREADY_PUBLISHED: 'expense_already_published',
+  EXPENSE_HAS_ASSOCIATED_LANDED_COST: 'EXPENSE_HAS_ASSOCIATED_LANDED_COST',
+};
diff --git a/packages/server/src/services/Features/FeaturesConfigureManager.ts b/packages/server/src/services/Features/FeaturesConfigureManager.ts
new file mode 100644
index 000000000..f19c733a3
--- /dev/null
+++ b/packages/server/src/services/Features/FeaturesConfigureManager.ts
@@ -0,0 +1,18 @@
+import { get } from 'lodash';
+import { Service } from 'typedi';
+import { FeaturesConfigure } from './constants';
+
+@Service()
+export class FeaturesConfigureManager {
+  /**
+   *
+   * @param featureName
+   * @returns
+   */
+  getFeatureConfigure = (featureName: string, accessor?: string) => {
+    const meta = FeaturesConfigure.find(
+      (feature) => feature.name === featureName
+    );
+    return accessor ? get(meta, accessor) : meta;
+  };
+}
diff --git a/packages/server/src/services/Features/FeaturesManager.ts b/packages/server/src/services/Features/FeaturesManager.ts
new file mode 100644
index 000000000..c57f3663e
--- /dev/null
+++ b/packages/server/src/services/Features/FeaturesManager.ts
@@ -0,0 +1,74 @@
+import { defaultTo } from 'lodash';
+import { Inject, Service } from 'typedi';
+import { omit } from 'lodash';
+import { FeaturesSettingsDriver } from './FeaturesSettingsDriver';
+import { FeaturesConfigureManager } from './FeaturesConfigureManager';
+import { IFeatureAllItem } from '@/interfaces';
+
+@Service()
+export class FeaturesManager {
+  @Inject()
+  private drive: FeaturesSettingsDriver;
+
+  @Inject()
+  private configure: FeaturesConfigureManager;
+
+  /**
+   * Turns-on the given feature name.
+   * @param   {number} tenantId
+   * @param   {string} feature
+   * @returns {Promise<void>}
+   */
+  public turnOn(tenantId: number, feature: string) {
+    return this.drive.turnOn(tenantId, feature);
+  }
+
+  /**
+   * Turns-off the given feature name.
+   * @param   {number} tenantId
+   * @param   {string} feature
+   * @returns {Promise<void>}
+   */
+  public turnOff(tenantId: number, feature: string) {
+    return this.drive.turnOff(tenantId, feature);
+  }
+
+  /**
+   * Detarmines the given feature name is accessiable.
+   * @param   {number} tenantId
+   * @param   {string} feature
+   * @returns {Promise<void>}
+   */
+  public async accessible(tenantId: number, feature: string) {
+    // Retrieves the feature default accessible value.
+    const defaultValue = this.configure.getFeatureConfigure(
+      feature,
+      'defaultValue'
+    );
+    const isAccessible = await this.drive.accessible(tenantId, feature);
+
+    return defaultTo(isAccessible, defaultValue);
+  }
+
+  /**
+   * Retrieves the all features and their accessible value and default value.
+   * @param   {number} tenantId
+   * @returns
+   */
+  public async all(tenantId: number): Promise<IFeatureAllItem[]> {
+    const all = await this.drive.all(tenantId);
+
+    return all.map((feature: IFeatureAllItem) => {
+      const defaultAccessible = this.configure.getFeatureConfigure(
+        feature.name,
+        'defaultValue'
+      );
+      const isAccessible = feature.isAccessible;
+
+      return {
+        ...feature,
+        isAccessible: defaultTo(isAccessible, defaultAccessible),
+      };
+    });
+  }
+}
diff --git a/packages/server/src/services/Features/FeaturesSettingsDriver.ts b/packages/server/src/services/Features/FeaturesSettingsDriver.ts
new file mode 100644
index 000000000..6e3827951
--- /dev/null
+++ b/packages/server/src/services/Features/FeaturesSettingsDriver.ts
@@ -0,0 +1,63 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { FeaturesConfigure } from './constants';
+import { IFeatureAllItem } from '@/interfaces';
+
+@Service()
+export class FeaturesSettingsDriver {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Turns-on the given feature name.
+   * @param   {number} tenantId
+   * @param   {string} feature
+   * @returns {Promise<void>}
+   */
+  async turnOn(tenantId: number, feature: string) {
+    const settings = this.tenancy.settings(tenantId);
+
+    settings.set({ group: 'features', key: feature, value: true });
+  }
+
+  /**
+   * Turns-off the given feature name.
+   * @param   {number} tenantId
+   * @param   {string} feature
+   * @returns {Promise<void>}
+   */
+  async turnOff(tenantId: number, feature: string) {
+    const settings = this.tenancy.settings(tenantId);
+
+    settings.set({ group: 'features', key: feature, value: false });
+  }
+
+  /**
+   * Detarmines the given feature name is accessiable.
+   * @param   {number} tenantId
+   * @param   {string} feature
+   * @returns {Promise<boolean|null|undefined>}
+   */
+  async accessible(tenantId: number, feature: string) {
+    const settings = this.tenancy.settings(tenantId);
+
+    return !!settings.get({ group: 'features', key: feature });
+  }
+
+  /**
+   * Retrieves the all features and their accessible value and default value.
+   * @param   {number} tenantId
+   * @returns {Promise<IFeatureAllItem>}
+   */
+  async all(tenantId: number): Promise<IFeatureAllItem[]> {
+    const mappedOpers = FeaturesConfigure.map(async (featureConfigure) => {
+      const { name, defaultValue } = featureConfigure;
+      const isAccessible = await this.accessible(
+        tenantId,
+        featureConfigure.name
+      );
+      return { name, isAccessible, defaultAccessible: defaultValue };
+    });
+    return Promise.all(mappedOpers);
+  }
+}
diff --git a/packages/server/src/services/Features/constants.ts b/packages/server/src/services/Features/constants.ts
new file mode 100644
index 000000000..5e2b807f6
--- /dev/null
+++ b/packages/server/src/services/Features/constants.ts
@@ -0,0 +1,12 @@
+import { Features, IFeatureConfiugration } from '@/interfaces';
+
+export const FeaturesConfigure: IFeatureConfiugration[] = [
+  {
+    name: Features.BRANCHES,
+    defaultValue: false,
+  },
+  {
+    name: Features.WAREHOUSES,
+    defaultValue: false,
+  },
+];
diff --git a/packages/server/src/services/FinancialStatements/AgingSummary/APAgingSummaryService.ts b/packages/server/src/services/FinancialStatements/AgingSummary/APAgingSummaryService.ts
new file mode 100644
index 000000000..ad85b1688
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/AgingSummary/APAgingSummaryService.ts
@@ -0,0 +1,121 @@
+import moment from 'moment';
+import { Inject, Service } from 'typedi';
+import { IAPAgingSummaryQuery, IARAgingSummaryMeta } from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import APAgingSummarySheet from './APAgingSummarySheet';
+import { Tenant } from '@/system/models';
+import { isEmpty } from 'lodash';
+
+@Service()
+export default class PayableAgingSummaryService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  /**
+   * Default report query.
+   */
+  get defaultQuery(): IAPAgingSummaryQuery {
+    return {
+      asDate: moment().format('YYYY-MM-DD'),
+      agingDaysBefore: 30,
+      agingPeriods: 3,
+      numberFormat: {
+        precision: 2,
+        divideOn1000: false,
+        showZero: false,
+        formatMoney: 'total',
+        negativeFormat: 'mines',
+      },
+      vendorsIds: [],
+      branchesIds: [],
+      noneZero: false,
+    };
+  }
+
+  /**
+   * Retrieve the balance sheet meta.
+   * @param {number} tenantId -
+   * @returns {IBalanceSheetMeta}
+   */
+  reportMetadata(tenantId: number): IARAgingSummaryMeta {
+    const settings = this.tenancy.settings(tenantId);
+
+    const organizationName = settings.get({
+      group: 'organization',
+      key: 'name',
+    });
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+
+    return {
+      organizationName,
+      baseCurrency,
+    };
+  }
+
+  /**
+   * Retrieve A/P aging summary report.
+   * @param {number} tenantId -
+   * @param {IAPAgingSummaryQuery} query -
+   */
+  async APAgingSummary(tenantId: number, query: IAPAgingSummaryQuery) {
+    const { Bill } = this.tenancy.models(tenantId);
+    const { vendorRepository } = this.tenancy.repositories(tenantId);
+
+    const filter = {
+      ...this.defaultQuery,
+      ...query,
+    };
+    // Settings tenant service.
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    // Retrieve all vendors from the storage.
+    const vendors =
+      filter.vendorsIds.length > 0
+        ? await vendorRepository.findWhereIn('id', filter.vendorsIds)
+        : await vendorRepository.all();
+
+    // Common query.
+    const commonQuery = (query) => {
+      if (isEmpty(filter.branchesIds)) {
+        query.modify('filterByBranches', filter.branchesIds);
+      }
+    };
+    // Retrieve all overdue vendors bills.
+    const overdueBills = await Bill.query()
+      .modify('overdueBillsFromDate', filter.asDate)
+      .onBuild(commonQuery);
+
+    // Retrieve all due vendors bills.
+    const dueBills = await Bill.query()
+      .modify('dueBillsFromDate', filter.asDate)
+      .onBuild(commonQuery);
+
+    // A/P aging summary report instance.
+    const APAgingSummaryReport = new APAgingSummarySheet(
+      tenantId,
+      filter,
+      vendors,
+      overdueBills,
+      dueBills,
+      tenant.metadata.baseCurrency
+    );
+    // A/P aging summary report data and columns.
+    const data = APAgingSummaryReport.reportData();
+    const columns = APAgingSummaryReport.reportColumns();
+
+    return {
+      data,
+      columns,
+      query: filter,
+      meta: this.reportMetadata(tenantId),
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/AgingSummary/APAgingSummarySheet.ts b/packages/server/src/services/FinancialStatements/AgingSummary/APAgingSummarySheet.ts
new file mode 100644
index 000000000..dff23c4b6
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/AgingSummary/APAgingSummarySheet.ts
@@ -0,0 +1,183 @@
+import { groupBy, sum, isEmpty } from 'lodash';
+import * as R from 'ramda';
+import AgingSummaryReport from './AgingSummary';
+import {
+  IAPAgingSummaryQuery,
+  IAgingPeriod,
+  IBill,
+  IVendor,
+  IAPAgingSummaryData,
+  IAPAgingSummaryVendor,
+  IAPAgingSummaryColumns,
+  IAPAgingSummaryTotal,
+} from '@/interfaces';
+import { Dictionary } from 'tsyringe/dist/typings/types';
+import { allPassedConditionsPass } from 'utils';
+
+export default class APAgingSummarySheet extends AgingSummaryReport {
+  readonly tenantId: number;
+  readonly query: IAPAgingSummaryQuery;
+  readonly contacts: IVendor[];
+  readonly unpaidBills: IBill[];
+  readonly baseCurrency: string;
+
+  readonly overdueInvoicesByContactId: Dictionary<IBill[]>;
+  readonly currentInvoicesByContactId: Dictionary<IBill[]>;
+
+  readonly agingPeriods: IAgingPeriod[];
+
+  /**
+   * Constructor method.
+   * @param {number} tenantId - Tenant id.
+   * @param {IAPAgingSummaryQuery} query - Report query.
+   * @param {IVendor[]} vendors - Unpaid bills.
+   * @param {string} baseCurrency - Base currency of the organization.
+   */
+  constructor(
+    tenantId: number,
+    query: IAPAgingSummaryQuery,
+    vendors: IVendor[],
+    overdueBills: IBill[],
+    unpaidBills: IBill[],
+    baseCurrency: string
+  ) {
+    super();
+
+    this.tenantId = tenantId;
+    this.query = query;
+    this.numberFormat = this.query.numberFormat;
+    this.contacts = vendors;
+    this.baseCurrency = baseCurrency;
+
+    this.overdueInvoicesByContactId = groupBy(overdueBills, 'vendorId');
+    this.currentInvoicesByContactId = groupBy(unpaidBills, 'vendorId');
+
+    // Initializes the aging periods.
+    this.agingPeriods = this.agingRangePeriods(
+      this.query.asDate,
+      this.query.agingDaysBefore,
+      this.query.agingPeriods
+    );
+  }
+
+  /**
+   * Retrieve the vendors aging and current total.
+   * @param  {IAPAgingSummaryTotal} vendorsAgingPeriods
+   * @return {IAPAgingSummaryTotal}
+   */
+  private getVendorsTotal = (vendorsAgingPeriods): IAPAgingSummaryTotal => {
+    const totalAgingPeriods = this.getTotalAgingPeriods(vendorsAgingPeriods);
+    const totalCurrent = this.getTotalCurrent(vendorsAgingPeriods);
+    const totalVendorsTotal = this.getTotalContactsTotals(vendorsAgingPeriods);
+
+    return {
+      current: this.formatTotalAmount(totalCurrent),
+      aging: totalAgingPeriods,
+      total: this.formatTotalAmount(totalVendorsTotal),
+    };
+  };
+
+  /**
+   * Retrieve the vendor section data.
+   * @param  {IVendor} vendor
+   * @return {IAPAgingSummaryVendor}
+   */
+  private vendorTransformer = (vendor: IVendor): IAPAgingSummaryVendor => {
+    const agingPeriods = this.getContactAgingPeriods(vendor.id);
+    const currentTotal = this.getContactCurrentTotal(vendor.id);
+    const agingPeriodsTotal = this.getAgingPeriodsTotal(agingPeriods);
+
+    const amount = sum([agingPeriodsTotal, currentTotal]);
+
+    return {
+      vendorName: vendor.displayName,
+      current: this.formatTotalAmount(currentTotal),
+      aging: agingPeriods,
+      total: this.formatTotalAmount(amount),
+    };
+  };
+
+  /**
+   * Mappes the given vendor objects to vendor report node.
+   * @param {IVendor[]} vendors
+   * @returns {IAPAgingSummaryVendor[]}
+   */
+  private vendorsMapper = (vendors: IVendor[]): IAPAgingSummaryVendor[] => {
+    return vendors.map(this.vendorTransformer);
+  };
+
+  /**
+   * Detarmines whether the given vendor node is none zero.
+   * @param {IAPAgingSummaryVendor} vendorNode
+   * @returns {boolean}
+   */
+  private filterNoneZeroVendorNode = (
+    vendorNode: IAPAgingSummaryVendor
+  ): boolean => {
+    return vendorNode.total.amount !== 0;
+  };
+
+  /**
+   * Filters vendors report nodes based on the given report query.
+   * @param {IAPAgingSummaryVendor} vendorNode
+   * @returns {boolean}
+   */
+  private vendorNodeFilter = (vendorNode: IAPAgingSummaryVendor): boolean => {
+    const { noneZero } = this.query;
+
+    const conditions = [[noneZero, this.filterNoneZeroVendorNode]];
+
+    return allPassedConditionsPass(conditions)(vendorNode);
+  };
+
+  /**
+   * Filtesr the given report vendors nodes.
+   * @param {IAPAgingSummaryVendor[]} vendorNodes
+   * @returns {IAPAgingSummaryVendor[]}
+   */
+  private vendorsFilter = (
+    vendorNodes: IAPAgingSummaryVendor[]
+  ): IAPAgingSummaryVendor[] => {
+    return vendorNodes.filter(this.vendorNodeFilter);
+  };
+
+  /**
+   * Detarmines whether vendors nodes filter enabled.
+   * @returns {boolean}
+   */
+  private isVendorNodesFilter = (): boolean => {
+    return isEmpty(this.query.vendorsIds);
+  };
+
+  /**
+   * Retrieve vendors aging periods.
+   * @return {IAPAgingSummaryVendor[]}
+   */
+  private vendorsSection = (vendors: IVendor[]): IAPAgingSummaryVendor[] => {
+    return R.compose(
+      R.when(this.isVendorNodesFilter, this.vendorsFilter),
+      this.vendorsMapper
+    )(vendors);
+  };
+
+  /**
+   * Retrieve the A/P aging summary report data.
+   * @return {IAPAgingSummaryData}
+   */
+  public reportData = (): IAPAgingSummaryData => {
+    const vendorsAgingPeriods = this.vendorsSection(this.contacts);
+    const vendorsTotal = this.getVendorsTotal(vendorsAgingPeriods);
+
+    return {
+      vendors: vendorsAgingPeriods,
+      total: vendorsTotal,
+    };
+  };
+
+  /**
+   * Retrieve the A/P aging summary report columns.
+   */
+  public reportColumns = (): IAPAgingSummaryColumns => {
+    return this.agingPeriods;
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/AgingSummary/ARAgingSummaryService.ts b/packages/server/src/services/FinancialStatements/AgingSummary/ARAgingSummaryService.ts
new file mode 100644
index 000000000..b1a5764af
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/AgingSummary/ARAgingSummaryService.ts
@@ -0,0 +1,120 @@
+import moment from 'moment';
+import { Inject, Service } from 'typedi';
+import { isEmpty } from 'lodash';
+import { IARAgingSummaryQuery, IARAgingSummaryMeta } from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import ARAgingSummarySheet from './ARAgingSummarySheet';
+import { Tenant } from '@/system/models';
+
+@Service()
+export default class ARAgingSummaryService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  /**
+   * Default report query.
+   */
+  get defaultQuery(): IARAgingSummaryQuery {
+    return {
+      asDate: moment().format('YYYY-MM-DD'),
+      agingDaysBefore: 30,
+      agingPeriods: 3,
+      numberFormat: {
+        divideOn1000: false,
+        negativeFormat: 'mines',
+        showZero: false,
+        formatMoney: 'total',
+        precision: 2,
+      },
+      customersIds: [],
+      branchesIds: [],
+      noneZero: false,
+    };
+  }
+
+  /**
+   * Retrieve the balance sheet meta.
+   * @param {number} tenantId -
+   * @returns {IBalanceSheetMeta}
+   */
+  reportMetadata(tenantId: number): IARAgingSummaryMeta {
+    const settings = this.tenancy.settings(tenantId);
+
+    const organizationName = settings.get({
+      group: 'organization',
+      key: 'name',
+    });
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+
+    return {
+      organizationName,
+      baseCurrency,
+    };
+  }
+
+  /**
+   * Retrieve A/R aging summary report.
+   * @param {number} tenantId - Tenant id.
+   * @param {IARAgingSummaryQuery} query -
+   */
+  async ARAgingSummary(tenantId: number, query: IARAgingSummaryQuery) {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+    const { customerRepository } = this.tenancy.repositories(tenantId);
+
+    const filter = {
+      ...this.defaultQuery,
+      ...query,
+    };
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    // Retrieve all customers from the storage.
+    const customers =
+      filter.customersIds.length > 0
+        ? await customerRepository.findWhereIn('id', filter.customersIds)
+        : await customerRepository.all();
+
+    // Common query.
+    const commonQuery = (query) => {
+      if (!isEmpty(filter.branchesIds)) {
+        query.modify('filterByBranches', filter.branchesIds);
+      }
+    };
+    // Retrieve all overdue sale invoices.
+    const overdueSaleInvoices = await SaleInvoice.query()
+      .modify('dueInvoicesFromDate', filter.asDate)
+      .onBuild(commonQuery);
+
+    // Retrieve all due sale invoices.
+    const currentInvoices = await SaleInvoice.query()
+      .modify('overdueInvoicesFromDate', filter.asDate)
+      .onBuild(commonQuery);
+
+    // AR aging summary report instance.
+    const ARAgingSummaryReport = new ARAgingSummarySheet(
+      tenantId,
+      filter,
+      customers,
+      overdueSaleInvoices,
+      currentInvoices,
+      tenant.metadata.baseCurrency
+    );
+    // AR aging summary report data and columns.
+    const data = ARAgingSummaryReport.reportData();
+    const columns = ARAgingSummaryReport.reportColumns();
+
+    return {
+      data,
+      columns,
+      query: filter,
+      meta: this.reportMetadata(tenantId),
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/AgingSummary/ARAgingSummarySheet.ts b/packages/server/src/services/FinancialStatements/AgingSummary/ARAgingSummarySheet.ts
new file mode 100644
index 000000000..0dba17a1e
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/AgingSummary/ARAgingSummarySheet.ts
@@ -0,0 +1,198 @@
+import { groupBy, isEmpty, sum } from 'lodash';
+import * as R from 'ramda';
+import {
+  ICustomer,
+  IARAgingSummaryQuery,
+  IARAgingSummaryCustomer,
+  IAgingPeriod,
+  ISaleInvoice,
+  IARAgingSummaryData,
+  IARAgingSummaryColumns,
+  IARAgingSummaryTotal,
+} from '@/interfaces';
+import AgingSummaryReport from './AgingSummary';
+import { allPassedConditionsPass } from '../../../utils';
+
+export default class ARAgingSummarySheet extends AgingSummaryReport {
+  readonly tenantId: number;
+  readonly query: IARAgingSummaryQuery;
+  readonly contacts: ICustomer[];
+  readonly agingPeriods: IAgingPeriod[];
+  readonly baseCurrency: string;
+
+  readonly overdueInvoicesByContactId: Dictionary<ISaleInvoice[]>;
+  readonly currentInvoicesByContactId: Dictionary<ISaleInvoice[]>;
+
+  /**
+   * Constructor method.
+   * @param {number} tenantId
+   * @param {IARAgingSummaryQuery} query
+   * @param {ICustomer[]} customers
+   * @param {IJournalPoster} journal
+   */
+  constructor(
+    tenantId: number,
+    query: IARAgingSummaryQuery,
+    customers: ICustomer[],
+    overdueSaleInvoices: ISaleInvoice[],
+    currentSaleInvoices: ISaleInvoice[],
+    baseCurrency: string
+  ) {
+    super();
+
+    this.tenantId = tenantId;
+    this.contacts = customers;
+    this.query = query;
+    this.baseCurrency = baseCurrency;
+    this.numberFormat = this.query.numberFormat;
+
+    this.overdueInvoicesByContactId = groupBy(
+      overdueSaleInvoices,
+      'customerId'
+    );
+    this.currentInvoicesByContactId = groupBy(
+      currentSaleInvoices,
+      'customerId'
+    );
+
+    // Initializes the aging periods.
+    this.agingPeriods = this.agingRangePeriods(
+      this.query.asDate,
+      this.query.agingDaysBefore,
+      this.query.agingPeriods
+    );
+  }
+
+  /**
+   * Mapping aging customer.
+   * @param {ICustomer} customer -
+   * @return {IARAgingSummaryCustomer[]}
+   */
+  private customerTransformer = (
+    customer: ICustomer
+  ): IARAgingSummaryCustomer => {
+    const agingPeriods = this.getContactAgingPeriods(customer.id);
+    const currentTotal = this.getContactCurrentTotal(customer.id);
+    const agingPeriodsTotal = this.getAgingPeriodsTotal(agingPeriods);
+    const amount = sum([agingPeriodsTotal, currentTotal]);
+
+    return {
+      customerName: customer.displayName,
+      current: this.formatAmount(currentTotal),
+      aging: agingPeriods,
+      total: this.formatTotalAmount(amount),
+    };
+  };
+
+  /**
+   * Mappes the customers objects to report accounts nodes.
+   * @param {ICustomer[]} customers
+   * @returns {IARAgingSummaryCustomer[]}
+   */
+  private customersMapper = (
+    customers: ICustomer[]
+  ): IARAgingSummaryCustomer[] => {
+    return customers.map(this.customerTransformer);
+  };
+
+  /**
+   * Filters the none-zero account report node.
+   * @param {IARAgingSummaryCustomer} node
+   * @returns {boolean}
+   */
+  private filterNoneZeroAccountNode = (
+    node: IARAgingSummaryCustomer
+  ): boolean => {
+    return node.total.amount !== 0;
+  };
+
+  /**
+   * Filters customer report node based on the given report query.
+   * @param {IARAgingSummaryCustomer} customerNode
+   * @returns {boolean}
+   */
+  private customerNodeFilter = (
+    customerNode: IARAgingSummaryCustomer
+  ): boolean => {
+    const { noneZero } = this.query;
+
+    const conditions = [[noneZero, this.filterNoneZeroAccountNode]];
+
+    return allPassedConditionsPass(conditions)(customerNode);
+  };
+
+  /**
+   * Filters customers report nodes.
+   * @param {IARAgingSummaryCustomer[]} customers
+   * @returns {IARAgingSummaryCustomer[]}
+   */
+  private customersFilter = (
+    customers: IARAgingSummaryCustomer[]
+  ): IARAgingSummaryCustomer[] => {
+    return customers.filter(this.customerNodeFilter);
+  };
+
+  /**
+   * Detarmines the customers nodes filter is enabled.
+   * @returns {boolean}
+   */
+  private isCustomersFilterEnabled = (): boolean => {
+    return isEmpty(this.query.customersIds);
+  }
+
+  /**
+   * Retrieve customers report.
+   * @param {ICustomer[]} customers
+   * @return {IARAgingSummaryCustomer[]}
+   */
+  private customersWalker = (
+    customers: ICustomer[]
+  ): IARAgingSummaryCustomer[] => {
+    return R.compose(
+      R.when(this.isCustomersFilterEnabled, this.customersFilter),
+      this.customersMapper
+    )(customers);
+  };
+
+  /**
+   * Retrieve the customers aging and current total.
+   * @param {IARAgingSummaryCustomer} customersAgingPeriods
+   */
+  private getCustomersTotal = (
+    customersAgingPeriods: IARAgingSummaryCustomer[]
+  ): IARAgingSummaryTotal => {
+    const totalAgingPeriods = this.getTotalAgingPeriods(customersAgingPeriods);
+    const totalCurrent = this.getTotalCurrent(customersAgingPeriods);
+    const totalCustomersTotal = this.getTotalContactsTotals(
+      customersAgingPeriods
+    );
+
+    return {
+      current: this.formatTotalAmount(totalCurrent),
+      aging: totalAgingPeriods,
+      total: this.formatTotalAmount(totalCustomersTotal),
+    };
+  };
+
+  /**
+   * Retrieve A/R aging summary report data.
+   * @return {IARAgingSummaryData}
+   */
+  public reportData = (): IARAgingSummaryData => {
+    const customersAgingPeriods = this.customersWalker(this.contacts);
+    const customersTotal = this.getCustomersTotal(customersAgingPeriods);
+
+    return {
+      customers: customersAgingPeriods,
+      total: customersTotal,
+    };
+  };
+
+  /**
+   * Retrieve AR aging summary report columns.
+   * @return {IARAgingSummaryColumns}
+   */
+  public reportColumns(): IARAgingSummaryColumns {
+    return this.agingPeriods;
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/AgingSummary/AgingReport.ts b/packages/server/src/services/FinancialStatements/AgingSummary/AgingReport.ts
new file mode 100644
index 000000000..dbbe9119f
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/AgingSummary/AgingReport.ts
@@ -0,0 +1,54 @@
+import moment from 'moment';
+import {
+  IAgingPeriod,
+} from '@/interfaces';
+import FinancialSheet from "../FinancialSheet";
+
+
+export default abstract class AgingReport extends FinancialSheet{
+  /**
+   * Retrieve the aging periods range.
+   * @param {string} asDay
+   * @param {number} agingDaysBefore
+   * @param {number} agingPeriodsFreq
+   */
+  agingRangePeriods(
+    asDay: Date|string,
+    agingDaysBefore: number,
+    agingPeriodsFreq: number
+  ): IAgingPeriod[] {
+    const totalAgingDays = agingDaysBefore * agingPeriodsFreq;
+    const startAging = moment(asDay).startOf('day');
+    const endAging = startAging
+      .clone()
+      .subtract(totalAgingDays, 'days')
+      .endOf('day');
+
+    const agingPeriods: IAgingPeriod[] = [];
+    const startingAging = startAging.clone();
+
+    let beforeDays = 1;
+    let toDays = 0;
+
+    while (startingAging > endAging) {
+      const currentAging = startingAging.clone();
+      startingAging.subtract(agingDaysBefore, 'days').endOf('day');
+      toDays += agingDaysBefore;
+
+      agingPeriods.push({
+        fromPeriod: moment(currentAging).format('YYYY-MM-DD'),
+        toPeriod: moment(startingAging).format('YYYY-MM-DD'),
+        beforeDays: beforeDays === 1 ? 0 : beforeDays,
+        toDays: toDays,
+        ...(startingAging.valueOf() === endAging.valueOf()
+          ? {
+              toPeriod: null,
+              toDays: null,
+            }
+          : {}),
+      });
+      beforeDays += agingDaysBefore;
+    }
+    return agingPeriods;
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/services/FinancialStatements/AgingSummary/AgingSummary.ts b/packages/server/src/services/FinancialStatements/AgingSummary/AgingSummary.ts
new file mode 100644
index 000000000..97cc8f186
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/AgingSummary/AgingSummary.ts
@@ -0,0 +1,228 @@
+import { defaultTo, sumBy, get } from 'lodash';
+import {
+  IAgingPeriod,
+  ISaleInvoice,
+  IBill,
+  IAgingPeriodTotal,
+  IARAgingSummaryCustomer,
+  IContact,
+  IARAgingSummaryQuery,
+  IFormatNumberSettings,
+  IAgingAmount,
+  IAgingSummaryContact,
+} from '@/interfaces';
+import AgingReport from './AgingReport';
+import { Dictionary } from 'tsyringe/dist/typings/types';
+
+export default abstract class AgingSummaryReport extends AgingReport {
+  protected readonly contacts: IContact[];
+  protected readonly agingPeriods: IAgingPeriod[] = [];
+  protected readonly baseCurrency: string;
+  protected readonly query: IARAgingSummaryQuery;
+  protected readonly overdueInvoicesByContactId: Dictionary<
+    (ISaleInvoice | IBill)[]
+  >;
+  protected readonly currentInvoicesByContactId: Dictionary<
+    (ISaleInvoice | IBill)[]
+  >;
+
+  /**
+   * Setes initial aging periods to the contact.
+   */
+  protected getInitialAgingPeriodsTotal(): IAgingPeriodTotal[] {
+    return this.agingPeriods.map((agingPeriod) => ({
+      ...agingPeriod,
+      total: this.formatAmount(0),
+    }));
+  }
+
+  /**
+   * Calculates the given contact aging periods.
+   * @param {number} contactId - Contact id.
+   * @return {IAgingPeriodTotal[]}
+   */
+  protected getContactAgingPeriods(contactId: number): IAgingPeriodTotal[] {
+    const unpaidInvoices = this.getUnpaidInvoicesByContactId(contactId);
+    const initialAgingPeriods = this.getInitialAgingPeriodsTotal();
+
+    return unpaidInvoices.reduce(
+      (agingPeriods: IAgingPeriodTotal[], unpaidInvoice) => {
+        const newAgingPeriods = this.getContactAgingDueAmount(
+          agingPeriods,
+          unpaidInvoice.dueAmount,
+          unpaidInvoice.overdueDays
+        );
+        return newAgingPeriods;
+      },
+      initialAgingPeriods
+    );
+  }
+
+  /**
+   * Sets the contact aging due amount to the table.
+   * @param {IAgingPeriodTotal} agingPeriods - Aging periods.
+   * @param {number} dueAmount - Due amount.
+   * @param {number} overdueDays - Overdue days.
+   * @return {IAgingPeriodTotal[]}
+   */
+  protected getContactAgingDueAmount(
+    agingPeriods: IAgingPeriodTotal[],
+    dueAmount: number,
+    overdueDays: number
+  ): IAgingPeriodTotal[] {
+    const newAgingPeriods = agingPeriods.map((agingPeriod) => {
+      const isInAgingPeriod =
+        agingPeriod.beforeDays <= overdueDays &&
+        (agingPeriod.toDays > overdueDays || !agingPeriod.toDays);
+
+      const total: number = isInAgingPeriod
+        ? agingPeriod.total.amount + dueAmount
+        : agingPeriod.total.amount;
+
+      return {
+        ...agingPeriod,
+        total: this.formatAmount(total),
+      };
+    });
+    return newAgingPeriods;
+  }
+
+  /**
+   * Retrieve the aging period total object.
+   * @param {number} amount
+   * @param {IFormatNumberSettings} settings - Override the format number settings.
+   * @return {IAgingAmount}
+   */
+  protected formatAmount(
+    amount: number,
+    settings: IFormatNumberSettings = {}
+  ): IAgingAmount {
+    return {
+      amount,
+      formattedAmount: this.formatNumber(amount, settings),
+      currencyCode: this.baseCurrency,
+    };
+  }
+
+  /**
+   * Retrieve the aging period total object.
+   * @param {number} amount
+   * @param {IFormatNumberSettings} settings - Override the format number settings.
+   * @return {IAgingPeriodTotal}
+   */
+  protected formatTotalAmount(
+    amount: number,
+    settings: IFormatNumberSettings = {}
+  ): IAgingAmount {
+    return this.formatAmount(amount, {
+      money: true,
+      excerptZero: false,
+      ...settings,
+    });
+  }
+
+  /**
+   * Calculates the total of the aging period by the given index.
+   * @param {number} index
+   * @return {number}
+   */
+  protected getTotalAgingPeriodByIndex(
+    contactsAgingPeriods: any,
+    index: number
+  ): number {
+    return this.contacts.reduce((acc, contact) => {
+      const totalPeriod = contactsAgingPeriods[index]
+        ? contactsAgingPeriods[index].total
+        : 0;
+
+      return acc + totalPeriod;
+    }, 0);
+  }
+
+  /**
+   * Retrieve the due invoices by the given contact id.
+   * @param  {number} contactId -
+   * @return {(ISaleInvoice | IBill)[]}
+   */
+  protected getUnpaidInvoicesByContactId(
+    contactId: number
+  ): (ISaleInvoice | IBill)[] {
+    return defaultTo(this.overdueInvoicesByContactId[contactId], []);
+  }
+
+  /**
+   * Retrieve total aging periods of the report.
+   * @return {(IAgingPeriodTotal & IAgingPeriod)[]}
+   */
+  protected getTotalAgingPeriods(
+    contactsAgingPeriods: IARAgingSummaryCustomer[]
+  ): IAgingPeriodTotal[] {
+    return this.agingPeriods.map((agingPeriod, index) => {
+      const total = sumBy(
+        contactsAgingPeriods,
+        (summary: IARAgingSummaryCustomer) => {
+          const aging = summary.aging[index];
+
+          if (!aging) {
+            return 0;
+          }
+          return aging.total.amount;
+        }
+      );
+
+      return {
+        ...agingPeriod,
+        total: this.formatTotalAmount(total),
+      };
+    });
+  }
+
+  /**
+   * Retrieve the current invoices by the given contact id.
+   * @param {number} contactId - Specific contact id.
+   * @return {(ISaleInvoice | IBill)[]}
+   */
+  protected getCurrentInvoicesByContactId(
+    contactId: number
+  ): (ISaleInvoice | IBill)[] {
+    return get(this.currentInvoicesByContactId, contactId, []);
+  }
+
+  /**
+   * Retrieve the contact total due amount.
+   * @param {number} contactId - Specific contact id.
+   * @return {number}
+   */
+  protected getContactCurrentTotal(contactId: number): number {
+    const currentInvoices = this.getCurrentInvoicesByContactId(contactId);
+    return sumBy(currentInvoices, (invoice) => invoice.dueAmount);
+  }
+
+  /**
+   * Retrieve to total sumation of the given contacts summeries sections.
+   * @param {IARAgingSummaryCustomer[]} contactsSections -
+   * @return {number}
+   */
+  protected getTotalCurrent(contactsSummaries: IAgingSummaryContact[]): number {
+    return sumBy(contactsSummaries, (summary) => summary.current.amount);
+  }
+
+  /**
+   * Retrieve the total of the given aging periods.
+   * @param {IAgingPeriodTotal[]} agingPeriods
+   * @return {number}
+   */
+  protected getAgingPeriodsTotal(agingPeriods: IAgingPeriodTotal[]): number {
+    return sumBy(agingPeriods, (period) => period.total.amount);
+  }
+
+  /**
+   * Retrieve total of contacts totals.
+   * @param {IAgingSummaryContact[]} contactsSummaries
+   */
+  protected getTotalContactsTotals(
+    contactsSummaries: IAgingSummaryContact[]
+  ): number {
+    return sumBy(contactsSummaries, (summary) => summary.total.amount);
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheet.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheet.ts
new file mode 100644
index 000000000..28c9b9197
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheet.ts
@@ -0,0 +1,305 @@
+import * as R from 'ramda';
+import { defaultTo, isEmpty, sumBy } from 'lodash';
+import FinancialSheet from '../FinancialSheet';
+import {
+  IBalanceSheetAggregateNode,
+  IBalanceSheetAccountNode,
+  BALANCE_SHEET_SCHEMA_NODE_TYPE,
+  IBalanceSheetQuery,
+  INumberFormatQuery,
+  IAccount,
+  IBalanceSheetSchemaNode,
+  IBalanceSheetSchemaAggregateNode,
+  IBalanceSheetDataNode,
+  IBalanceSheetSchemaAccountNode,
+  IBalanceSheetCommonNode,
+} from '../../../interfaces';
+import { BalanceSheetSchema } from './BalanceSheetSchema';
+import { BalanceSheetPercentage } from './BalanceSheetPercentage';
+import { BalanceSheetComparsionPreviousPeriod } from './BalanceSheetComparsionPreviousPeriod';
+import { BalanceSheetComparsionPreviousYear } from './BalanceSheetComparsionPreviousYear';
+import { BalanceSheetDatePeriods } from './BalanceSheetDatePeriods';
+import { BalanceSheetBase } from './BalanceSheetBase';
+import { FinancialSheetStructure } from '../FinancialSheetStructure';
+import BalanceSheetRepository from './BalanceSheetRepository';
+import { BalanceSheetQuery } from './BalanceSheetQuery';
+import { BalanceSheetFiltering } from './BalanceSheetFiltering';
+
+export default class BalanceSheet extends R.compose(
+  BalanceSheetFiltering,
+  BalanceSheetDatePeriods,
+  BalanceSheetComparsionPreviousPeriod,
+  BalanceSheetComparsionPreviousYear,
+  BalanceSheetPercentage,
+  BalanceSheetSchema,
+  BalanceSheetBase,
+  FinancialSheetStructure
+)(FinancialSheet) {
+  /**
+   * Balance sheet query.
+   * @param {BalanceSheetQuery}
+   */
+  readonly query: BalanceSheetQuery;
+
+  /**
+   * Balance sheet number format query.
+   * @param {INumberFormatQuery}
+   */
+  readonly numberFormat: INumberFormatQuery;
+
+  /**
+   * Base currency of the organization.
+   * @param {string}
+   */
+  readonly baseCurrency: string;
+
+  readonly i18n: any;
+
+  /**
+   * Constructor method.
+   * @param {IBalanceSheetQuery} query -
+   * @param {IAccount[]} accounts -
+   * @param {string} baseCurrency -
+   */
+  constructor(
+    query: IBalanceSheetQuery,
+    repository: BalanceSheetRepository,
+    baseCurrency: string,
+    i18n
+  ) {
+    super();
+
+    this.query = new BalanceSheetQuery(query);
+    this.repository = repository;
+    this.baseCurrency = baseCurrency;
+    this.numberFormat = this.query.query.numberFormat;
+    this.i18n = i18n;
+  }
+
+  /**
+   * Retrieve the accounts node of accounts types.
+   * @param   {string} accountsTypes
+   * @returns {IAccount[]}
+   */
+  private getAccountsByAccountTypes = (accountsTypes: string[]): IAccount[] => {
+    const mapAccountsByTypes = R.map((accountType) =>
+      defaultTo(this.repository.accountsByType.get(accountType), [])
+    );
+    return R.compose(R.flatten, mapAccountsByTypes)(accountsTypes);
+  };
+
+  /**
+   * Mappes the aggregate schema node type.
+   * @param  {IBalanceSheetSchemaAggregateNode} node - Schema node.
+   * @return {IBalanceSheetAggregateNode}
+   */
+  private reportSchemaAggregateNodeMapper = (
+    node: IBalanceSheetSchemaAggregateNode
+  ): IBalanceSheetAggregateNode => {
+    const total = this.getTotalOfNodes(node.children);
+
+    return {
+      name: this.i18n.__(node.name),
+      id: node.id,
+      nodeType: BALANCE_SHEET_SCHEMA_NODE_TYPE.AGGREGATE,
+      total: this.getTotalAmountMeta(total),
+      children: node.children,
+    };
+  };
+
+  /**
+   * Compose shema aggregate node of balance sheet schema.
+   * @param   {IBalanceSheetSchemaAggregateNode} node
+   * @returns {IBalanceSheetSchemaAggregateNode}
+   */
+  private schemaAggregateNodeCompose = (
+    node: IBalanceSheetSchemaAggregateNode
+  ) => {
+    return R.compose(
+      this.aggregateNodeTotalMapper,
+      this.reportSchemaAggregateNodeMapper
+    )(node);
+  };
+
+  /**
+   * Mappes the account model to report account node.
+   * @param   {IAccount} account
+   * @returns {IBalanceSheetAccountNode}
+   */
+  private reportSchemaAccountNodeMapper = (
+    account: IAccount
+  ): IBalanceSheetAccountNode => {
+    const total = this.repository.totalAccountsLedger
+      .whereAccountId(account.id)
+      .getClosingBalance();
+
+    return {
+      id: account.id,
+      index: account.index,
+      name: account.name,
+      code: account.code,
+      total: this.getAmountMeta(total),
+      nodeType: BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNT,
+    };
+  };
+
+  /**
+   *
+   * @param   {IAccount} account
+   * @returns {IBalanceSheetAccountNode}
+   */
+  private reportSchemaAccountNodeComposer = (
+    account: IAccount
+  ): IBalanceSheetAccountNode => {
+    return R.compose(
+      R.when(
+        this.query.isPreviousYearActive,
+        this.previousYearAccountNodeComposer
+      ),
+      R.when(
+        this.query.isPreviousPeriodActive,
+        this.previousPeriodAccountNodeComposer
+      ),
+      R.when(
+        this.query.isDatePeriodsColumnsType,
+        this.assocAccountNodeDatePeriods
+      ),
+      this.reportSchemaAccountNodeMapper
+    )(account);
+  };
+
+  /**
+   * Retrieve the total of the given nodes.
+   * @param   {IBalanceSheetCommonNode[]} nodes
+   * @returns {number}
+   */
+  private getTotalOfNodes = (nodes: IBalanceSheetCommonNode[]) => {
+    return sumBy(nodes, 'total.amount');
+  };
+
+  /**
+   * Retrieve the report accounts node by the given accounts types.
+   * @param   {string[]} accountsTypes
+   * @returns {}
+   */
+  private getAccountsNodesByAccountTypes = (accountsTypes: string[]) => {
+    const accounts = this.getAccountsByAccountTypes(accountsTypes);
+
+    return R.compose(R.map(this.reportSchemaAccountNodeComposer))(accounts);
+  };
+
+  /**
+   * Mappes the accounts schema node type.
+   * @param   {IBalanceSheetSchemaNode} node - Schema node.
+   * @returns {IBalanceSheetAccountNode}
+   */
+  private reportSchemaAccountsNodeMapper = (
+    node: IBalanceSheetSchemaAccountNode
+  ): IBalanceSheetAccountNode => {
+    const accounts = this.getAccountsNodesByAccountTypes(node.accountsTypes);
+    const total = this.getTotalOfNodes(accounts);
+
+    return {
+      id: node.id,
+      name: this.i18n.__(node.name),
+      type: node.type,
+      nodeType: BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNTS,
+      children: accounts,
+      total: this.getTotalAmountMeta(total),
+    };
+  };
+
+  /**
+   * Compose account schema node to report node.
+   * @param   {IBalanceSheetSchemaAccountNode} node
+   * @returns {IBalanceSheetAccountNode}
+   */
+  private reportSchemaAccountsNodeComposer = (
+    node: IBalanceSheetSchemaAccountNode
+  ): IBalanceSheetAccountNode => {
+    return R.compose(
+      R.when(
+        this.query.isPreviousYearActive,
+        this.previousYearAggregateNodeComposer
+      ),
+      R.when(
+        this.query.isPreviousPeriodActive,
+        this.previousPeriodAggregateNodeComposer
+      ),
+      R.when(
+        this.query.isDatePeriodsColumnsType,
+        this.assocAccountsNodeDatePeriods
+      ),
+      this.reportSchemaAccountsNodeMapper
+    )(node);
+  };
+
+  /**
+   * Mappes the given report schema node.
+   * @param  {IBalanceSheetSchemaNode} node - Schema node.
+   * @return {IBalanceSheetDataNode}
+   */
+  private reportSchemaNodeMapper = (
+    schemaNode: IBalanceSheetSchemaNode
+  ): IBalanceSheetDataNode => {
+    return R.compose(
+      R.when(
+        this.isSchemaNodeType(BALANCE_SHEET_SCHEMA_NODE_TYPE.AGGREGATE),
+        this.schemaAggregateNodeCompose
+      ),
+      R.when(
+        this.isSchemaNodeType(BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNTS),
+        this.reportSchemaAccountsNodeComposer
+      )
+    )(schemaNode);
+  };
+
+  /**
+   * Mappes the report schema nodes.
+   * @param  {IBalanceSheetSchemaNode[]} nodes -
+   * @return {IBalanceSheetStructureSection[]}
+   */
+  private reportSchemaAccountNodesMapper = (
+    schemaNodes: IBalanceSheetSchemaNode[]
+  ): IBalanceSheetDataNode[] => {
+    return this.mapNodesDeepReverse(schemaNodes, this.reportSchemaNodeMapper);
+  };
+
+  /**
+   * Sets total amount that calculated from node children.
+   * @param   {IBalanceSheetSection} node
+   * @returns {IBalanceSheetDataNode}
+   */
+  private aggregateNodeTotalMapper = (
+    node: IBalanceSheetDataNode
+  ): IBalanceSheetDataNode => {
+    return R.compose(
+      R.when(
+        this.query.isPreviousYearActive,
+        this.previousYearAggregateNodeComposer
+      ),
+      R.when(
+        this.query.isPreviousPeriodActive,
+        this.previousPeriodAggregateNodeComposer
+      ),
+      R.when(
+        this.query.isDatePeriodsColumnsType,
+        this.assocAggregateNodeDatePeriods
+      )
+    )(node);
+  };
+
+  /**
+   * Retrieve the report statement data.
+   * @returns {IBalanceSheetDataNode[]}
+   */
+  public reportData = () => {
+    const balanceSheetSchema = this.getSchema();
+
+    return R.compose(
+      this.reportFilterPlugin,
+      this.reportPercentageCompose,
+      this.reportSchemaAccountNodesMapper
+    )(balanceSheetSchema);
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetBase.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetBase.ts
new file mode 100644
index 000000000..9089f0364
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetBase.ts
@@ -0,0 +1,32 @@
+import * as R from 'ramda';
+import { IBalanceSheetDataNode, IBalanceSheetSchemaNode } from '@/interfaces';
+
+export const BalanceSheetBase = (Base) =>
+  class extends Base {
+    /**
+     * Detarmines the node type of the given schema node.
+     * @param  {IBalanceSheetStructureSection} node -
+     * @param  {string} type -
+     * @return {boolean}
+     */
+    protected isSchemaNodeType = R.curry(
+      (type: string, node: IBalanceSheetSchemaNode): boolean => {
+        return node.type === type;
+      }
+    );
+
+    isNodeType = R.curry(
+      (type: string, node: IBalanceSheetDataNode): boolean => {
+        return node.nodeType === type;
+      }
+    );
+
+    /**
+     * Detarmines the given display columns by type.
+     * @param   {string} displayColumnsBy
+     * @returns {boolean}
+     */
+    protected isDisplayColumnsBy = (displayColumnsBy: string): boolean => {
+      return this.query.displayColumnsType === displayColumnsBy;
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetComparsionPreviousPeriod.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetComparsionPreviousPeriod.ts
new file mode 100644
index 000000000..23db25a10
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetComparsionPreviousPeriod.ts
@@ -0,0 +1,267 @@
+import * as R from 'ramda';
+import { sumBy } from 'lodash';
+import {
+  IBalanceSheetAccountNode,
+  IBalanceSheetDataNode,
+  IBalanceSheetAggregateNode,
+  IBalanceSheetTotal,
+  IBalanceSheetCommonNode,
+} from '@/interfaces';
+import { FinancialPreviousPeriod } from '../FinancialPreviousPeriod';
+import { FinancialHorizTotals } from '../FinancialHorizTotals';
+
+export const BalanceSheetComparsionPreviousPeriod = (Base: any) =>
+  class
+    extends R.compose(FinancialPreviousPeriod, FinancialHorizTotals)(Base)
+    implements IBalanceSheetComparsions
+  {
+    // ------------------------------
+    // # Account
+    // ------------------------------
+    /**
+     * Associates the previous period to account node.
+     * @param   {IBalanceSheetDataNode} node
+     * @returns {IBalanceSheetDataNode}
+     */
+    protected assocPreviousPeriodAccountNode = (
+      node: IBalanceSheetDataNode
+    ): IBalanceSheetDataNode => {
+      const total = this.repository.PPTotalAccountsLedger.whereAccountId(
+        node.id
+      ).getClosingBalance();
+
+      return R.assoc('previousPeriod', this.getAmountMeta(total), node);
+    };
+
+    /**
+     * Previous period account node composer.
+     * @param   {IBalanceSheetAccountNode} node
+     * @returns {IBalanceSheetAccountNode}
+     */
+    protected previousPeriodAccountNodeComposer = (
+      node: IBalanceSheetAccountNode
+    ): IBalanceSheetAccountNode => {
+      return R.compose(
+        R.when(
+          this.isNodeHasHorizTotals,
+          this.assocPreivousPeriodAccountHorizNodeComposer
+        ),
+        R.when(
+          this.query.isPreviousPeriodPercentageActive,
+          this.assocPreviousPeriodPercentageNode
+        ),
+        R.when(
+          this.query.isPreviousPeriodChangeActive,
+          this.assocPreviousPeriodChangeNode
+        ),
+        R.when(
+          this.query.isPreviousPeriodActive,
+          this.assocPreviousPeriodAccountNode
+        )
+      )(node);
+    };
+
+    // ------------------------------
+    // # Aggregate
+    // ------------------------------
+    /**
+     * Assoc previous period total to aggregate node.
+     * @param   {IBalanceSheetAggregateNode} node
+     * @returns {IBalanceSheetAggregateNode}
+     */
+    protected assocPreviousPeriodAggregateNode = (
+      node: IBalanceSheetAggregateNode
+    ): IBalanceSheetAggregateNode => {
+      const total = sumBy(node.children, 'previousYear.amount');
+
+      return R.assoc('previousPeriod', this.getTotalAmountMeta(total), node);
+    };
+
+    /**
+     * Previous period aggregate node composer.
+     * @param   {IBalanceSheetAccountNode} node
+     * @returns {IBalanceSheetAccountNode}
+     */
+    protected previousPeriodAggregateNodeComposer = (
+      node: IBalanceSheetAccountNode
+    ): IBalanceSheetAccountNode => {
+      return R.compose(
+        R.when(
+          this.isNodeHasHorizTotals,
+          this.assocPreviousPeriodAggregateHorizNode
+        ),
+        R.when(
+          this.query.isPreviousPeriodPercentageActive,
+          this.assocPreviousPeriodTotalPercentageNode
+        ),
+        R.when(
+          this.query.isPreviousPeriodChangeActive,
+          this.assocPreviousPeriodTotalChangeNode
+        ),
+        R.when(
+          this.query.isPreviousPeriodActive,
+          this.assocPreviousPeriodAggregateNode
+        )
+      )(node);
+    };
+
+    // ------------------------------
+    // # Horizontal Nodes - Account.
+    // ------------------------------
+    /**
+     * Retrieve the given account total in the given period.
+     * @param   {number} accountId - Account id.
+     * @param   {Date} fromDate - From date.
+     * @param   {Date} toDate - To date.
+     * @returns {number}
+     */
+    private getAccountPPDatePeriodTotal = R.curry(
+      (accountId: number, fromDate: Date, toDate: Date): number => {
+        const PPPeriodsTotal =
+          this.repository.PPPeriodsAccountsLedger.whereAccountId(accountId)
+            .whereToDate(toDate)
+            .getClosingBalance();
+
+        const PPPeriodsOpeningTotal =
+          this.repository.PPPeriodsOpeningAccountLedger.whereAccountId(
+            accountId
+          ).getClosingBalance();
+
+        return PPPeriodsOpeningTotal + PPPeriodsTotal;
+      }
+    );
+
+    /**
+     * Assoc preivous period to account horizontal total node.
+     * @param   {IBalanceSheetAccountNode} node
+     * @returns {}
+     */
+    private assocPreviousPeriodAccountHorizTotal = R.curry(
+      (node: IBalanceSheetAccountNode, totalNode) => {
+        const total = this.getAccountPPDatePeriodTotal(
+          node.id,
+          totalNode.previousPeriodFromDate.date,
+          totalNode.previousPeriodToDate.date
+        );
+        return R.assoc('previousPeriod', this.getAmountMeta(total), totalNode);
+      }
+    );
+
+    /**
+     * Previous year account horizontal node composer.
+     * @param   {IBalanceSheetAccountNode} node -
+     * @param   {IBalanceSheetTotal}
+     * @returns {IBalanceSheetTotal}
+     */
+    private previousPeriodAccountHorizNodeCompose = R.curry(
+      (
+        node: IBalanceSheetAccountNode,
+        horizontalTotalNode: IBalanceSheetTotal
+      ): IBalanceSheetTotal => {
+        return R.compose(
+          R.when(
+            this.query.isPreviousPeriodPercentageActive,
+            this.assocPreviousPeriodPercentageNode
+          ),
+          R.when(
+            this.query.isPreviousPeriodChangeActive,
+            this.assocPreviousPeriodChangeNode
+          ),
+          R.when(
+            this.query.isPreviousPeriodActive,
+            this.assocPreviousPeriodAccountHorizTotal(node)
+          ),
+          R.when(
+            this.query.isPreviousPeriodActive,
+            this.assocPreviousPeriodHorizNodeFromToDates(
+              this.query.displayColumnsBy
+            )
+          )
+        )(horizontalTotalNode);
+      }
+    );
+
+    /**
+     *
+     * @param {IBalanceSheetAccountNode} node
+     * @returns
+     */
+    private assocPreivousPeriodAccountHorizNodeComposer = (
+      node: IBalanceSheetAccountNode
+    ) => {
+      const horizontalTotals = R.map(
+        this.previousPeriodAccountHorizNodeCompose(node),
+        node.horizontalTotals
+      );
+      return R.assoc('horizontalTotals', horizontalTotals, node);
+    };
+
+    // ------------------------------
+    // # Horizontal Nodes - Aggregate
+    // ------------------------------
+    /**
+     * Assoc previous year total to horizontal node.
+     * @param node
+     * @returns
+     */
+    private assocPreviousPeriodAggregateHorizTotalNode = R.curry(
+      (node, index: number, totalNode) => {
+        const total = this.getPPHorizNodesTotalSumation(index, node);
+
+        return R.assoc(
+          'previousPeriod',
+          this.getTotalAmountMeta(total),
+          totalNode
+        );
+      }
+    );
+
+    /**
+     * Compose previous period to aggregate horizontal nodes.
+     * @param   {IBalanceSheetTotal} node
+     * @returns {IBalanceSheetTotal}
+     */
+    private previousPeriodAggregateHorizNodeComposer = R.curry(
+      (
+        node: IBalanceSheetCommonNode,
+        horiontalTotalNode: IBalanceSheetTotal,
+        index: number
+      ): IBalanceSheetTotal => {
+        return R.compose(
+          R.when(
+            this.query.isPreviousPeriodPercentageActive,
+            this.assocPreviousPeriodTotalPercentageNode
+          ),
+          R.when(
+            this.query.isPreviousPeriodChangeActive,
+            this.assocPreviousPeriodTotalChangeNode
+          ),
+          R.when(
+            this.query.isPreviousPeriodActive,
+            this.assocPreviousPeriodAggregateHorizTotalNode(node, index)
+          ),
+          R.when(
+            this.query.isPreviousPeriodActive,
+            this.assocPreviousPeriodHorizNodeFromToDates(
+              this.query.displayColumnsBy
+            )
+          )
+        )(horiontalTotalNode);
+      }
+    );
+
+    /**
+     * Assoc
+     * @param   {IBalanceSheetCommonNode} node
+     * @returns {IBalanceSheetCommonNode}
+     */
+    private assocPreviousPeriodAggregateHorizNode = (
+      node: IBalanceSheetCommonNode
+    ) => {
+      const horizontalTotals = R.addIndex(R.map)(
+        this.previousPeriodAggregateHorizNodeComposer(node),
+        node.horizontalTotals
+      );
+      return R.assoc('horizontalTotals', horizontalTotals, node);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetComparsionPreviousYear.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetComparsionPreviousYear.ts
new file mode 100644
index 000000000..4486269e2
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetComparsionPreviousYear.ts
@@ -0,0 +1,269 @@
+import * as R from 'ramda';
+import { sumBy, isEmpty } from 'lodash';
+import {
+  IBalanceSheetAccountNode,
+  IBalanceSheetCommonNode,
+  IBalanceSheetDataNode,
+  IBalanceSheetTotal,
+  ITableColumn,
+} from '@/interfaces';
+import { FinancialPreviousYear } from '../FinancialPreviousYear';
+
+export const BalanceSheetComparsionPreviousYear = (Base: any) =>
+  class
+    extends R.compose(FinancialPreviousYear)(Base)
+    implements IBalanceSheetComparsions
+  {
+    // ------------------------------
+    // # Account
+    // ------------------------------
+    /**
+     * Associates the previous year to account node.
+     * @param   {IBalanceSheetDataNode} node
+     * @returns {IBalanceSheetDataNode}
+     */
+    protected assocPreviousYearAccountNode = (
+      node: IBalanceSheetDataNode
+    ): IBalanceSheetDataNode => {
+      const closingBalance =
+        this.repository.PYTotalAccountsLedger.whereAccountId(
+          node.id
+        ).getClosingBalance();
+
+      return R.assoc('previousYear', this.getAmountMeta(closingBalance), node);
+    };
+
+    /**
+     * Assoc previous year attributes to account node.
+     * @param   {IBalanceSheetAccountNode} node
+     * @returns {IBalanceSheetAccountNode}
+     */
+    protected previousYearAccountNodeComposer = (
+      node: IBalanceSheetAccountNode
+    ): IBalanceSheetAccountNode => {
+      return R.compose(
+        R.when(
+          this.isNodeHasHorizontalTotals,
+          this.assocPreviousYearAccountHorizNodeComposer
+        ),
+        R.when(
+          this.query.isPreviousYearPercentageActive,
+          this.assocPreviousYearPercentageNode
+        ),
+        R.when(
+          this.query.isPreviousYearChangeActive,
+          this.assocPreviousYearChangetNode
+        ),
+        this.assocPreviousYearAccountNode
+      )(node);
+    };
+
+    // ------------------------------
+    // # Aggregate
+    // ------------------------------
+    /**
+     * Assoc previous year on aggregate node.
+     * @param   {IBalanceSheetAccountNode} node
+     * @returns {IBalanceSheetAccountNode}
+     */
+    protected assocPreviousYearAggregateNode = (
+      node: IBalanceSheetAccountNode
+    ): IBalanceSheetAccountNode => {
+      const total = sumBy(node.children, 'previousYear.amount');
+
+      return R.assoc('previousYear', this.getTotalAmountMeta(total), node);
+    };
+
+    /**
+     * Assoc previous year attributes to aggregate node.
+     * @param   {IBalanceSheetAccountNode} node
+     * @returns {IBalanceSheetAccountNode}
+     */
+    protected previousYearAggregateNodeComposer = (
+      node: IBalanceSheetAccountNode
+    ): IBalanceSheetAccountNode => {
+      return R.compose(
+        R.when(
+          this.query.isPreviousYearPercentageActive,
+          this.assocPreviousYearTotalPercentageNode
+        ),
+        R.when(
+          this.query.isPreviousYearChangeActive,
+          this.assocPreviousYearTotalChangeNode
+        ),
+        R.when(
+          this.isNodeHasHorizontalTotals,
+          this.assocPreviousYearAggregateHorizNode
+        ),
+        this.assocPreviousYearAggregateNode
+      )(node);
+    };
+
+    // ------------------------------
+    // # Horizontal Nodes - Aggregate
+    // ------------------------------
+    /**
+     * Assoc previous year total to horizontal node.
+     * @param node
+     * @returns
+     */
+    private assocPreviousYearAggregateHorizTotalNode = R.curry(
+      (node, index, totalNode) => {
+        const total = this.getPYHorizNodesTotalSumation(index, node);
+
+        return R.assoc(
+          'previousYear',
+          this.getTotalAmountMeta(total),
+          totalNode
+        );
+      }
+    );
+
+    /**
+     * Compose previous year to aggregate horizontal nodes.
+     * @param   {IBalanceSheetTotal} node
+     * @returns {IBalanceSheetTotal}
+     */
+    private previousYearAggregateHorizNodeComposer = R.curry(
+      (
+        node: IBalanceSheetCommonNode,
+        horiontalTotalNode: IBalanceSheetTotal,
+        index: number
+      ): IBalanceSheetTotal => {
+        return R.compose(
+          R.when(
+            this.query.isPreviousYearPercentageActive,
+            this.assocPreviousYearTotalPercentageNode
+          ),
+          R.when(
+            this.query.isPreviousYearChangeActive,
+            this.assocPreviousYearTotalChangeNode
+          ),
+          R.when(
+            this.query.isPreviousYearActive,
+            this.assocPreviousYearAggregateHorizTotalNode(node, index)
+          ),
+          R.when(
+            this.query.isPreviousYearActive,
+            this.assocPreviousYearHorizNodeFromToDates
+          )
+        )(horiontalTotalNode);
+      }
+    );
+
+    /**
+     * Assoc
+     * @param   {IBalanceSheetCommonNode} node
+     * @returns {IBalanceSheetCommonNode}
+     */
+    private assocPreviousYearAggregateHorizNode = (
+      node: IBalanceSheetCommonNode
+    ) => {
+      const horizontalTotals = R.addIndex(R.map)(
+        this.previousYearAggregateHorizNodeComposer(node),
+        node.horizontalTotals
+      );
+      return R.assoc('horizontalTotals', horizontalTotals, node);
+    };
+
+    // ------------------------------
+    // # Horizontal Nodes - Account.
+    // ------------------------------
+    /**
+     * Retrieve the given account total in the given period.
+     * @param   {number} accountId - Account id.
+     * @param   {Date} fromDate - From date.
+     * @param   {Date} toDate - To date.
+     * @returns {number}
+     */
+    private getAccountPYDatePeriodTotal = R.curry(
+      (accountId: number, fromDate: Date, toDate: Date): number => {
+        const PYPeriodsTotal =
+          this.repository.PYPeriodsAccountsLedger.whereAccountId(accountId)
+            .whereToDate(toDate)
+            .getClosingBalance();
+
+        const PYPeriodsOpeningTotal =
+          this.repository.PYPeriodsOpeningAccountLedger.whereAccountId(
+            accountId
+          ).getClosingBalance();
+
+        return PYPeriodsOpeningTotal + PYPeriodsTotal;
+      }
+    );
+
+    /**
+     * Assoc preivous year to account horizontal total node.
+     * @param   {IBalanceSheetAccountNode} node
+     * @returns {}
+     */
+    private assocPreviousYearAccountHorizTotal = R.curry(
+      (node: IBalanceSheetAccountNode, totalNode) => {
+        const total = this.getAccountPYDatePeriodTotal(
+          node.id,
+          totalNode.previousYearFromDate.date,
+          totalNode.previousYearToDate.date
+        );
+        return R.assoc('previousYear', this.getAmountMeta(total), totalNode);
+      }
+    );
+
+    /**
+     * Previous year account horizontal node composer.
+     * @param   {IBalanceSheetAccountNode} node -
+     * @param   {IBalanceSheetTotal}
+     * @returns {IBalanceSheetTotal}
+     */
+    private previousYearAccountHorizNodeCompose = R.curry(
+      (
+        node: IBalanceSheetAccountNode,
+        horizontalTotalNode: IBalanceSheetTotal
+      ): IBalanceSheetTotal => {
+        return R.compose(
+          R.when(
+            this.query.isPreviousYearPercentageActive,
+            this.assocPreviousYearPercentageNode
+          ),
+          R.when(
+            this.query.isPreviousYearChangeActive,
+            this.assocPreviousYearChangetNode
+          ),
+          R.when(
+            this.query.isPreviousYearActive,
+            this.assocPreviousYearAccountHorizTotal(node)
+          ),
+          R.when(
+            this.query.isPreviousYearActive,
+            this.assocPreviousYearHorizNodeFromToDates
+          )
+        )(horizontalTotalNode);
+      }
+    );
+
+    /**
+     * Assoc previous year horizontal nodes to account node.
+     * @param   {IBalanceSheetAccountNode} node
+     * @returns {IBalanceSheetAccountNode}
+     */
+    private assocPreviousYearAccountHorizNodeComposer = (
+      node: IBalanceSheetAccountNode
+    ) => {
+      const horizontalTotals = R.map(
+        this.previousYearAccountHorizNodeCompose(node),
+        node.horizontalTotals
+      );
+      return R.assoc('horizontalTotals', horizontalTotals, node);
+    };
+
+    // ------------------------------
+    // # Horizontal Nodes - Aggregate.
+    // ------------------------------
+
+    /**
+     * Detarmines whether the given node has horizontal totals.
+     * @param   {IBalanceSheetCommonNode} node
+     * @returns {boolean}
+     */
+    private isNodeHasHorizontalTotals = (node: IBalanceSheetCommonNode) =>
+      !isEmpty(node.horizontalTotals);
+  };
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetDatePeriods.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetDatePeriods.ts
new file mode 100644
index 000000000..632ef9e9e
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetDatePeriods.ts
@@ -0,0 +1,211 @@
+import * as R from 'ramda';
+import { sumBy } from 'lodash';
+import {
+  IBalanceSheetQuery,
+  IFormatNumberSettings,
+  IBalanceSheetDatePeriods,
+  IBalanceSheetAccountNode,
+  IBalanceSheetTotalPeriod,
+  IDateRange,
+  IBalanceSheetCommonNode,
+} from '@/interfaces';
+import FinancialSheet from '../FinancialSheet';
+import { FinancialDatePeriods } from '../FinancialDatePeriods';
+
+/**
+ * Balance sheet date periods.
+ */
+export const BalanceSheetDatePeriods = (Base: FinancialSheet) =>
+  class
+    extends R.compose(FinancialDatePeriods)(Base)
+    implements IBalanceSheetDatePeriods
+  {
+    /**
+     * @param {IBalanceSheetQuery}
+     */
+    readonly query: IBalanceSheetQuery;
+
+    /**
+     * Retrieves the date periods based on the report query.
+     * @returns {IDateRange[]}
+     */
+    get datePeriods(): IDateRange[] {
+      return this.getDateRanges(
+        this.query.fromDate,
+        this.query.toDate,
+        this.query.displayColumnsBy
+      );
+    }
+
+    /**
+     * Retrieves the date periods of the given node based on the report query.
+     * @param   {IBalanceSheetCommonNode} node
+     * @param   {Function} callback
+     * @returns {}
+     */
+    protected getReportNodeDatePeriods = (
+      node: IBalanceSheetCommonNode,
+      callback: (
+        node: IBalanceSheetCommonNode,
+        fromDate: Date,
+        toDate: Date,
+        index: number
+      ) => any
+    ) => {
+      return this.getNodeDatePeriods(
+        this.query.fromDate,
+        this.query.toDate,
+        this.query.displayColumnsBy,
+        node,
+        callback
+      );
+    };
+
+    /**
+     * Retrieve the date period meta.
+     * @param  {number} total - Total amount.
+     * @param  {Date} fromDate - From date.
+     * @param  {Date} toDate -  To date.
+     * @return {ICashFlowDatePeriod}
+     */
+    private getDatePeriodTotalMeta = (
+      total: number,
+      fromDate: Date,
+      toDate: Date,
+      overrideSettings: IFormatNumberSettings = {}
+    ): IBalanceSheetTotalPeriod => {
+      return this.getDatePeriodMeta(total, fromDate, toDate, {
+        money: true,
+        ...overrideSettings,
+      });
+    };
+
+    // --------------------------------
+    // # Account
+    // --------------------------------
+    /**
+     * Retrieve the given account date period total.
+     * @param   {number} accountId
+     * @param   {Date} toDate
+     * @returns {number}
+     */
+    private getAccountDatePeriodTotal = (
+      accountId: number,
+      toDate: Date
+    ): number => {
+      const periodTotalBetween = this.repository.periodsAccountsLedger
+        .whereAccountId(accountId)
+        .whereToDate(toDate)
+        .getClosingBalance();
+
+      const periodOpening = this.repository.periodsOpeningAccountLedger
+        .whereAccountId(accountId)
+        .getClosingBalance();
+
+      return periodOpening + periodTotalBetween;
+    };
+
+    /**
+     *
+     * @param   {IBalanceSheetAccountNode} node
+     * @param   {Date} fromDate
+     * @param   {Date} toDate
+     * @returns {IBalanceSheetAccountNode}
+     */
+    private getAccountNodeDatePeriod = (
+      node: IBalanceSheetAccountNode,
+      fromDate: Date,
+      toDate: Date
+    ): IBalanceSheetTotalPeriod => {
+      const periodTotal = this.getAccountDatePeriodTotal(node.id, toDate);
+
+      return this.getDatePeriodTotalMeta(periodTotal, fromDate, toDate);
+    };
+
+    /**
+     * Retrieve total date periods of the given account node.
+     * @param   {IBalanceSheetAccountNode} node
+     * @returns {IBalanceSheetAccountNode}
+     */
+    private getAccountsNodeDatePeriods = (
+      node: IBalanceSheetAccountNode
+    ): IBalanceSheetTotalPeriod[] => {
+      return this.getReportNodeDatePeriods(node, this.getAccountNodeDatePeriod);
+    };
+
+    /**
+     * Assoc total date periods to account node.
+     * @param   {IBalanceSheetAccountNode} node
+     * @returns {IBalanceSheetAccountNode}
+     */
+    public assocAccountNodeDatePeriods = (
+      node: IBalanceSheetAccountNode
+    ): IBalanceSheetAccountNode => {
+      const datePeriods = this.getAccountsNodeDatePeriods(node);
+
+      return R.assoc('horizontalTotals', datePeriods, node);
+    };
+
+    // --------------------------------
+    // # Aggregate
+    // --------------------------------
+    /**
+     *
+     * @param   {} node
+     * @param   {number} index
+     * @returns {number}
+     */
+    private getAggregateDatePeriodIndexTotal = (node, index) => {
+      return sumBy(node.children, `horizontalTotals[${index}].total.amount`);
+    };
+
+    /**
+     *
+     * @param {IBalanceSheetAccountNode} node
+     * @param {Date} fromDate
+     * @param {Date} toDate
+     * @returns
+     */
+    public getAggregateNodeDatePeriod = (
+      node: IBalanceSheetAccountNode,
+      fromDate: Date,
+      toDate: Date,
+      index: number
+    ) => {
+      const periodTotal = this.getAggregateDatePeriodIndexTotal(node, index);
+
+      return this.getDatePeriodTotalMeta(periodTotal, fromDate, toDate);
+    };
+
+    /**
+     *
+     * @param node
+     * @returns
+     */
+    public getAggregateNodeDatePeriods = (node) => {
+      return this.getReportNodeDatePeriods(
+        node,
+        this.getAggregateNodeDatePeriod
+      );
+    };
+
+    /**
+     * Assoc total date periods to aggregate node.
+     * @param node
+     * @returns {}
+     */
+    public assocAggregateNodeDatePeriods = (node) => {
+      const datePeriods = this.getAggregateNodeDatePeriods(node);
+
+      return R.assoc('horizontalTotals', datePeriods, node);
+    };
+
+    /**
+     *
+     * @param node
+     * @returns
+     */
+    public assocAccountsNodeDatePeriods = (node) => {
+      return this.assocAggregateNodeDatePeriods(node);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetFilter.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetFilter.ts
new file mode 100644
index 000000000..8b1378917
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetFilter.ts
@@ -0,0 +1 @@
+
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetFiltering.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetFiltering.ts
new file mode 100644
index 000000000..6aa80d78a
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetFiltering.ts
@@ -0,0 +1,167 @@
+import * as R from 'ramda';
+import { get } from 'lodash';
+import {
+  IBalanceSheetDataNode,
+  BALANCE_SHEET_NODE_TYPE,
+} from '../../../interfaces';
+import { FinancialFilter } from '../FinancialFilter';
+
+export const BalanceSheetFiltering = (Base) =>
+  class extends R.compose(FinancialFilter)(Base) {
+    // -----------------------
+    // # Account
+    // -----------------------
+    /**
+     * Filter report node detarmine.
+     * @param  {IBalanceSheetDataNode} node - Balance sheet node.
+     * @return {boolean}
+     */
+    private accountNoneZeroNodesFilterDetarminer = (
+      node: IBalanceSheetDataNode
+    ): boolean => {
+      return R.ifElse(
+        this.isNodeType(BALANCE_SHEET_NODE_TYPE.ACCOUNT),
+        this.isNodeNoneZero,
+        R.always(true)
+      )(node);
+    };
+
+    /**
+     * Detarmines account none-transactions node.
+     * @param   {IBalanceSheetDataNode} node
+     * @returns {boolean}
+     */
+    private accountNoneTransFilterDetarminer = (
+      node: IBalanceSheetDataNode
+    ): boolean => {
+      return R.ifElse(
+        this.isNodeType(BALANCE_SHEET_NODE_TYPE.ACCOUNT),
+        this.isNodeNoneZero,
+        R.always(true)
+      )(node);
+    };
+
+    /**
+     * Report nodes filter.
+     * @param  {IBalanceSheetSection[]} nodes -
+     * @return {IBalanceSheetSection[]}
+     */
+    private accountsNoneZeroNodesFilter = (
+      nodes: IBalanceSheetDataNode[]
+    ): IBalanceSheetDataNode[] => {
+      return this.filterNodesDeep(
+        nodes,
+        this.accountNoneZeroNodesFilterDetarminer
+      );
+    };
+
+    /**
+     * Filters the accounts none-transactions nodes.
+     * @param   {IBalanceSheetDataNode[]} nodes
+     * @returns {IBalanceSheetDataNode[]}
+     */
+    private accountsNoneTransactionsNodesFilter = (
+      nodes: IBalanceSheetDataNode[]
+    ) => {
+      return this.filterNodesDeep(nodes, this.accountNoneTransFilterDetarminer);
+    };
+
+    // -----------------------
+    // # Aggregate/Accounts.
+    // -----------------------
+    /**
+     * Detearmines aggregate none-children filtering.
+     * @param   {IBalanceSheetDataNode} node
+     * @returns {boolean}
+     */
+    private aggregateNoneChildrenFilterDetarminer = (
+      node: IBalanceSheetDataNode
+    ): boolean => {
+      // Detarmines whether the given node is aggregate or accounts node.
+      const isAggregateOrAccounts =
+        this.isNodeType(BALANCE_SHEET_NODE_TYPE.AGGREGATE, node) ||
+        this.isNodeType(BALANCE_SHEET_NODE_TYPE.ACCOUNTS, node);
+
+      // Retrieve the schema node of the given id.
+      const schemaNode = this.getSchemaNodeById(node.id);
+
+      // Detarmines if the schema node is always should show.
+      const isSchemaAlwaysShow = get(schemaNode, 'alwaysShow', false);
+
+      return isAggregateOrAccounts && !isSchemaAlwaysShow
+        ? this.isNodeHasChildren(node)
+        : true;
+    };
+
+    /**
+     * Filters aggregate none-children nodes.
+     * @param   {IBalanceSheetDataNode[]} nodes
+     * @returns {IBalanceSheetDataNode[]}
+     */
+    private aggregateNoneChildrenFilter = (
+      nodes: IBalanceSheetDataNode[]
+    ): IBalanceSheetDataNode[] => {
+      return this.filterNodesDeep2(
+        this.aggregateNoneChildrenFilterDetarminer,
+        nodes
+      );
+    };
+
+    // -----------------------
+    // # Composers.
+    // -----------------------
+    /**
+     * Filters none-zero nodes.
+     * @param   {IBalanceSheetDataNode[]} nodes
+     * @returns {IBalanceSheetDataNode[]}
+     */
+    private filterNoneZeroNodesCompose = (
+      nodes: IBalanceSheetDataNode[]
+    ): IBalanceSheetDataNode[] => {
+      return R.compose(
+        this.aggregateNoneChildrenFilter,
+        this.accountsNoneZeroNodesFilter
+      )(nodes);
+    };
+
+    /**
+     * Filters none-transactions nodes.
+     * @param   {IBalanceSheetDataNode[]} nodes
+     * @returns {IBalanceSheetDataNode[]}
+     */
+    private filterNoneTransNodesCompose = (
+      nodes: IBalanceSheetDataNode[]
+    ): IBalanceSheetDataNode[] => {
+      return R.compose(
+        this.aggregateNoneChildrenFilter,
+        this.accountsNoneTransactionsNodesFilter
+      )(nodes);
+    };
+
+    /**
+     * Supress nodes when accounts transactions ledger is empty.
+     * @param   {IBalanceSheetDataNode[]} nodes
+     * @returns {IBalanceSheetDataNode[]}
+     */
+    private supressNodesWhenAccountsTransactionsEmpty = (
+      nodes: IBalanceSheetDataNode[]
+    ): IBalanceSheetDataNode[] => {
+      return this.repository.totalAccountsLedger.isEmpty() ? [] : nodes;
+    };
+
+    /**
+     * Compose report nodes filtering.
+     * @param   {IBalanceSheetDataNode[]} nodes
+     * @returns {IBalanceSheetDataNode[]}
+     */
+    protected reportFilterPlugin = (nodes: IBalanceSheetDataNode[]) => {
+      return R.compose(
+        this.supressNodesWhenAccountsTransactionsEmpty,
+        R.when(R.always(this.query.noneZero), this.filterNoneZeroNodesCompose),
+        R.when(
+          R.always(this.query.noneTransactions),
+          this.filterNoneTransNodesCompose
+        )
+      )(nodes);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetPercentage.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetPercentage.ts
new file mode 100644
index 000000000..ff87cec7b
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetPercentage.ts
@@ -0,0 +1,225 @@
+import * as R from 'ramda';
+import { get } from 'lodash';
+import { IBalanceSheetDataNode } from '@/interfaces';
+import { BalanceSheetQuery } from './BalanceSheetQuery';
+
+export const BalanceSheetPercentage = (Base: any) =>
+  class extends Base {
+    readonly query: BalanceSheetQuery;
+
+    /**
+     * Assoc percentage of column to report node.
+     * @param   {IBalanceSheetDataNode} node
+     * @returns {IBalanceSheetDataNode}
+     */
+    protected assocReportNodeColumnPercentage = R.curry(
+      (
+        parentTotal: number,
+        node: IBalanceSheetDataNode
+      ): IBalanceSheetDataNode => {
+        const percentage = this.getPercentageBasis(
+          parentTotal,
+          node.total.amount
+        );
+        return R.assoc(
+          'percentageColumn',
+          this.getPercentageAmountMeta(percentage),
+          node
+        );
+      }
+    );
+
+    /**
+     * Assoc percentage of row to report node.
+     * @param   {IBalanceSheetDataNode} node
+     * @returns {IBalanceSheetDataNode}
+     */
+    protected assocReportNodeRowPercentage = R.curry(
+      (
+        parentTotal: number,
+        node: IBalanceSheetDataNode
+      ): IBalanceSheetDataNode => {
+        const percenatage = this.getPercentageBasis(
+          parentTotal,
+          node.total.amount
+        );
+        return R.assoc(
+          'percentageRow',
+          this.getPercentageAmountMeta(percenatage),
+          node
+        );
+      }
+    );
+
+    /**
+     * Assoc percentage of row to horizontal total.
+     * @param   {number} parentTotal -
+     * @param   {IBalanceSheetDataNode} node
+     * @returns {IBalanceSheetDataNode}
+     */
+    protected assocRowPercentageHorizTotals = R.curry(
+      (
+        parentTotal: number,
+        node: IBalanceSheetDataNode
+      ): IBalanceSheetDataNode => {
+        const assocRowPercen = this.assocReportNodeRowPercentage(parentTotal);
+        const horTotals = R.map(assocRowPercen)(node.horizontalTotals);
+
+        return R.assoc('horizontalTotals', horTotals, node);
+      }
+    );
+
+    /**
+     *
+     * @param {} parentNode -
+     * @param {} horTotalNode -
+     * @param {number} index -
+     */
+    private assocColumnPercentageHorizTotal = R.curry(
+      (parentNode, horTotalNode, index) => {
+        const parentTotal = get(
+          parentNode,
+          `horizontalTotals[${index}].total.amount`,
+          0
+        );
+        return this.assocReportNodeColumnPercentage(parentTotal, horTotalNode);
+      }
+    );
+
+    /**
+     * Assoc column percentage to horizontal totals nodes.
+     * @param   {IBalanceSheetDataNode} node
+     * @returns {IBalanceSheetDataNode}
+     */
+    protected assocColumnPercentageHorizTotals = R.curry(
+      (
+        parentNode: IBalanceSheetDataNode,
+        node: IBalanceSheetDataNode
+      ): IBalanceSheetDataNode => {
+        // Horizontal totals.
+        const assocColPerc = this.assocColumnPercentageHorizTotal(parentNode);
+        const horTotals = R.addIndex(R.map)(assocColPerc)(
+          node.horizontalTotals
+        );
+        return R.assoc('horizontalTotals', horTotals, node);
+      }
+    );
+
+    /**
+     *
+     * @param {number} parentTotal -
+     * @param {} node
+     * @returns
+     */
+    protected reportNodeColumnPercentageComposer = R.curry(
+      (parentNode, node) => {
+        const parentTotal = parentNode.total.amount;
+
+        return R.compose(
+          R.when(
+            this.isNodeHasHorizoTotals,
+            this.assocColumnPercentageHorizTotals(parentNode)
+          ),
+          this.assocReportNodeColumnPercentage(parentTotal)
+        )(node);
+      }
+    );
+
+    /**
+     *
+     * @param node
+     * @returns
+     */
+    private reportNodeRowPercentageComposer = (node) => {
+      const total = node.total.amount;
+
+      return R.compose(
+        R.when(
+          this.isNodeHasHorizoTotals,
+          this.assocRowPercentageHorizTotals(total)
+        ),
+        this.assocReportNodeRowPercentage(total)
+      )(node);
+    };
+
+    /**
+     *
+     */
+    private assocNodeColumnPercentageChildren = (node) => {
+      const children = this.mapNodesDeep(
+        node.children,
+        this.reportNodeColumnPercentageComposer(node)
+      );
+      return R.assoc('children', children, node);
+    };
+
+    /**
+     *
+     * @param node
+     * @returns
+     */
+    private reportNodeColumnPercentageDeepMap = (node) => {
+      const parentTotal = node.total.amount;
+      const parentNode = node;
+
+      return R.compose(
+        R.when(
+          this.isNodeHasHorizoTotals,
+          this.assocColumnPercentageHorizTotals(parentNode)
+        ),
+        this.assocReportNodeColumnPercentage(parentTotal),
+        this.assocNodeColumnPercentageChildren
+      )(node);
+    };
+
+    /**
+     *
+     * @param   {IBalanceSheetDataNode[]} node
+     * @returns {IBalanceSheetDataNode[]}
+     */
+    private reportColumnsPercentageMapper = (
+      nodes: IBalanceSheetDataNode[]
+    ): IBalanceSheetDataNode[] => {
+      return R.map(this.reportNodeColumnPercentageDeepMap, nodes);
+    };
+
+    /**
+     *
+     * @param nodes
+     * @returns
+     */
+    private reportRowsPercentageMapper = (nodes) => {
+      return this.mapNodesDeep(nodes, this.reportNodeRowPercentageComposer);
+    };
+
+    /**
+     *
+     * @param nodes
+     * @returns
+     */
+    protected reportPercentageCompose = (nodes) => {
+      return R.compose(
+        R.when(
+          this.query.isColumnsPercentageActive,
+          this.reportColumnsPercentageMapper
+        ),
+        R.when(
+          this.query.isRowsPercentageActive,
+          this.reportRowsPercentageMapper
+        )
+      )(nodes);
+    };
+
+    /**
+     * Detarmines whether the given node has horizontal total.
+     * @param   {IBalanceSheetDataNode} node
+     * @returns {boolean}
+     */
+    protected isNodeHasHorizoTotals = (
+      node: IBalanceSheetDataNode
+    ): boolean => {
+      return (
+        !R.isEmpty(node.horizontalTotals) && !R.isNil(node.horizontalTotals)
+      );
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetQuery.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetQuery.ts
new file mode 100644
index 000000000..0692de8d9
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetQuery.ts
@@ -0,0 +1,177 @@
+import { merge } from 'lodash';
+import * as R from 'ramda';
+import { IBalanceSheetQuery, IFinancialDatePeriodsUnit } from '@/interfaces';
+import { FinancialDateRanges } from '../FinancialDateRanges';
+import { DISPLAY_COLUMNS_BY } from './constants';
+
+export class BalanceSheetQuery extends R.compose(FinancialDateRanges)(
+  class {}
+) {
+  /**
+   * Balance sheet query.
+   * @param {IBalanceSheetQuery}
+   */
+  public readonly query: IBalanceSheetQuery;
+  /**
+   * Previous year to date.
+   * @param {Date}
+   */
+  public readonly PYToDate: Date;
+  /**
+   * Previous year from date.
+   * @param {Date}
+   */
+  public readonly PYFromDate: Date;
+  /**
+   * Previous period to date.
+   * @param {Date}
+   */
+  public readonly PPToDate: Date;
+  /**
+   * Previous period from date.
+   * @param {Date}
+   */
+  public readonly PPFromDate: Date;
+  /**
+   * Constructor method
+   * @param {IBalanceSheetQuery} query
+   */
+  constructor(query: IBalanceSheetQuery) {
+    super();
+    this.query = query;
+
+    // Pervious Year (PY) Dates.
+    this.PYToDate = this.getPreviousYearDate(this.query.toDate);
+    this.PYFromDate = this.getPreviousYearDate(this.query.fromDate);
+
+    // Previous Period (PP) Dates for Total column.
+    if (this.isTotalColumnType()) {
+      const { fromDate, toDate } = this.getPPTotalDateRange(
+        this.query.fromDate,
+        this.query.toDate
+      );
+      this.PPToDate = toDate;
+      this.PPFromDate = fromDate;
+      // Previous Period (PP) Dates for Date period columns type.
+    } else if (this.isDatePeriodsColumnsType()) {
+      const { fromDate, toDate } = this.getPPDatePeriodDateRange(
+        this.query.fromDate,
+        this.query.toDate,
+        this.query.displayColumnsBy as IFinancialDatePeriodsUnit
+      );
+      this.PPToDate = toDate;
+      this.PPFromDate = fromDate;
+    }
+    return merge(this, query);
+  }
+
+  // ---------------------------
+  // # Columns Type/By.
+  // ---------------------------
+  /**
+   * Detarmines the given display columns type.
+   * @param   {string} displayColumnsBy
+   * @returns {boolean}
+   */
+  public isDisplayColumnsBy = (displayColumnsBy: string): boolean => {
+    return this.query.displayColumnsBy === displayColumnsBy;
+  };
+
+  /**
+   * Detarmines the given display columns by type.
+   * @param   {string} displayColumnsBy
+   * @returns {boolean}
+   */
+  public isDisplayColumnsType = (displayColumnsType: string): boolean => {
+    return this.query.displayColumnsType === displayColumnsType;
+  };
+
+  /**
+   * Detarmines whether the columns type is date periods.
+   * @returns {boolean}
+   */
+  public isDatePeriodsColumnsType = (): boolean => {
+    return this.isDisplayColumnsType(DISPLAY_COLUMNS_BY.DATE_PERIODS);
+  };
+
+  /**
+   * Detarmines whether the columns type is total.
+   * @returns {boolean}
+   */
+  public isTotalColumnType = (): boolean => {
+    return this.isDisplayColumnsType(DISPLAY_COLUMNS_BY.TOTAL);
+  };
+
+  // ---------------------------
+  // # Percentage column/row.
+  // ---------------------------
+  /**
+   * Detarmines whether the percentage of column active.
+   * @returns {boolean}
+   */
+  public isColumnsPercentageActive = (): boolean => {
+    return this.query.percentageOfColumn;
+  };
+
+  /**
+   * Detarmines whether the percentage of row active.
+   * @returns {boolean}
+   */
+  public isRowsPercentageActive = (): boolean => {
+    return this.query.percentageOfRow;
+  };
+
+  // ---------------------------
+  // # Previous Year (PY)
+  // ---------------------------
+  /**
+   * Detarmines the report query has previous year enabled.
+   * @returns {boolean}
+   */
+  public isPreviousYearActive = (): boolean => {
+    return this.query.previousYear;
+  };
+
+  /**
+   * Detarmines the report query has previous year percentage change active.
+   * @returns {boolean}
+   */
+  public isPreviousYearPercentageActive = (): boolean => {
+    return this.query.previousYearPercentageChange;
+  };
+
+  /**
+   * Detarmines the report query has previous year change active.
+   * @returns {boolean}
+   */
+  public isPreviousYearChangeActive = (): boolean => {
+    return this.query.previousYearAmountChange;
+  };
+
+  // ---------------------------
+  // # Previous Period (PP).
+  // ---------------------------
+  /**
+   * Detarmines the report query has previous period enabled.
+   * @returns {boolean}
+   */
+  public isPreviousPeriodActive = (): boolean => {
+    return this.query.previousPeriod;
+  };
+
+  /**
+   * Detarmines wether the preivous period percentage is active.
+   * @returns {boolean}
+   */
+  public isPreviousPeriodPercentageActive = (): boolean => {
+    return this.query.previousPeriodPercentageChange;
+  };
+
+  /**
+   * Detarmines wether the previous period change is active.
+   * @returns {boolean}
+   */
+  public isPreviousPeriodChangeActive = (): boolean => {
+    return this.query.previousPeriodAmountChange;
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetRepository.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetRepository.ts
new file mode 100644
index 000000000..e9de1be43
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetRepository.ts
@@ -0,0 +1,365 @@
+import { Service } from 'typedi';
+import * as R from 'ramda';
+import { Knex } from 'knex';
+import { isEmpty } from 'lodash';
+import {
+  IAccountTransactionsGroupBy,
+  IBalanceSheetQuery,
+  ILedger,
+} from '@/interfaces';
+import { transformToMapBy } from 'utils';
+import Ledger from '@/services/Accounting/Ledger';
+import { BalanceSheetQuery } from './BalanceSheetQuery';
+import { FinancialDatePeriods } from '../FinancialDatePeriods';
+
+@Service()
+export default class BalanceSheetRepository extends R.compose(
+  FinancialDatePeriods
+)(class {}) {
+  /**
+   *
+   */
+  private readonly models;
+
+  /**
+   * @param {number}
+   */
+  public readonly tenantId: number;
+
+  /**
+   * @param {BalanceSheetQuery}
+   */
+  public readonly query: BalanceSheetQuery;
+
+  /**
+   * @param {}
+   */
+  public accounts: any;
+
+  /**
+   *
+   */
+  public accountsByType: any;
+
+  /**
+   * PY from date.
+   * @param {Date}
+   */
+  public readonly PYFromDate: Date;
+
+  /**
+   * PY to date.
+   * @param {Date}
+   */
+  public readonly PYToDate: Date;
+
+  /**
+   * PP to date.
+   * @param {Date}
+   */
+  public readonly PPToDate: Date;
+
+  /**
+   * PP from date.
+   * @param {Date}
+   */
+  public readonly PPFromDate: Date;
+
+  public totalAccountsLedger: Ledger;
+
+  /**
+   * Transactions group type.
+   * @param {IAccountTransactionsGroupBy}
+   */
+  public transactionsGroupType: IAccountTransactionsGroupBy =
+    IAccountTransactionsGroupBy.Month;
+
+  // -----------------------
+  // # Date Periods
+  // -----------------------
+  /**
+   * @param {Ledger}
+   */
+  public periodsAccountsLedger: Ledger;
+
+  /**
+   * @param {Ledger}
+   */
+  public periodsOpeningAccountLedger: Ledger;
+
+  // -----------------------
+  // # Previous Year (PY).
+  // -----------------------
+  /**
+   * @param {Ledger}
+   */
+  public PYPeriodsOpeningAccountLedger: Ledger;
+
+  /**
+   * @param {Ledger}
+   */
+  public PYPeriodsAccountsLedger: Ledger;
+
+  /**
+   * @param {Ledger}
+   */
+  public PYTotalAccountsLedger: ILedger;
+
+  // -----------------------
+  // # Previous Period (PP).
+  // -----------------------
+  /**
+   * @param {Ledger}
+   */
+  public PPTotalAccountsLedger: Ledger;
+
+  /**
+   * @param {Ledger}
+   */
+  public PPPeriodsAccountsLedger: ILedger;
+
+  /**
+   * @param {Ledger}
+   */
+  public PPPeriodsOpeningAccountLedger: ILedger;
+
+  /**
+   * Constructor method.
+   * @param {number} tenantId
+   * @param {IBalanceSheetQuery} query
+   */
+  constructor(models: any, query: IBalanceSheetQuery) {
+    super();
+
+    this.query = new BalanceSheetQuery(query);
+    this.models = models;
+
+    this.transactionsGroupType = this.getGroupByFromDisplayColumnsBy(
+      this.query.displayColumnsBy
+    );
+  }
+
+  /**
+   * Async initialize.
+   * @returns {Promise<void>}
+   */
+  public asyncInitialize = async () => {
+    await this.initAccounts();
+    await this.initAccountsTotalLedger();
+
+    // Date periods.
+    if (this.query.isDatePeriodsColumnsType()) {
+      await this.initTotalDatePeriods();
+    }
+    // Previous Year (PY).
+    if (this.query.isPreviousYearActive()) {
+      await this.initTotalPreviousYear();
+    }
+    if (
+      this.query.isPreviousYearActive() &&
+      this.query.isDatePeriodsColumnsType()
+    ) {
+      await this.initPeriodsPreviousYear();
+    }
+    // Previous Period (PP).
+    if (this.query.isPreviousPeriodActive()) {
+      await this.initTotalPreviousPeriod();
+    }
+    if (
+      this.query.isPreviousPeriodActive() &&
+      this.query.isDatePeriodsColumnsType()
+    ) {
+      await this.initPeriodsPreviousPeriod();
+    }
+  };
+
+  // ----------------------------
+  // # Accounts
+  // ----------------------------
+  public initAccounts = async () => {
+    const accounts = await this.getAccounts();
+
+    this.accounts = accounts;
+    this.accountsByType = transformToMapBy(accounts, 'accountType');
+  };
+
+  // ----------------------------
+  // # Closing Total
+  // ----------------------------
+  /**
+   * Initialize accounts closing total based on the given query.
+   * @returns {Promise<void>}
+   */
+  private initAccountsTotalLedger = async (): Promise<void> => {
+    const totalByAccount = await this.closingAccountsTotal(this.query.toDate);
+
+    // Inject to the repository.
+    this.totalAccountsLedger = Ledger.fromTransactions(totalByAccount);
+  };
+
+  // ----------------------------
+  // # Date periods.
+  // ----------------------------
+  /**
+   * Initialize date periods total.
+   * @returns {Promise<void>}
+   */
+  public initTotalDatePeriods = async (): Promise<void> => {
+    // Retrieves grouped transactions by given date group.
+    const periodsByAccount = await this.accountsDatePeriods(
+      this.query.fromDate,
+      this.query.toDate,
+      this.transactionsGroupType
+    );
+    // Retrieves opening balance of grouped transactions.
+    const periodsOpeningByAccount = await this.closingAccountsTotal(
+      this.query.fromDate
+    );
+    // Inject to the repository.
+    this.periodsAccountsLedger = Ledger.fromTransactions(periodsByAccount);
+    this.periodsOpeningAccountLedger = Ledger.fromTransactions(
+      periodsOpeningByAccount
+    );
+  };
+
+  // ----------------------------
+  // # Previous Year (PY).
+  // ----------------------------
+  /**
+   * Initialize total of previous year.
+   * @returns {Promise<void>}
+   */
+  private initTotalPreviousYear = async (): Promise<void> => {
+    const PYTotalsByAccounts = await this.closingAccountsTotal(
+      this.query.PYToDate
+    );
+    // Inject to the repository.
+    this.PYTotalAccountsLedger = Ledger.fromTransactions(PYTotalsByAccounts);
+  };
+
+  /**
+   * Initialize date periods of previous year.
+   * @returns {Promise<void>}
+   */
+  private initPeriodsPreviousYear = async (): Promise<void> => {
+    const PYPeriodsBYAccounts = await this.accountsDatePeriods(
+      this.query.PYFromDate,
+      this.query.PYToDate,
+      this.transactionsGroupType
+    );
+    // Retrieves opening balance of grouped transactions.
+    const periodsOpeningByAccount = await this.closingAccountsTotal(
+      this.query.PYFromDate
+    );
+    // Inject to the repository.
+    this.PYPeriodsAccountsLedger = Ledger.fromTransactions(PYPeriodsBYAccounts);
+    this.PYPeriodsOpeningAccountLedger = Ledger.fromTransactions(
+      periodsOpeningByAccount
+    );
+  };
+
+  // ----------------------------
+  // # Previous Year (PP).
+  // ----------------------------
+  /**
+   * Initialize total of previous year.
+   * @returns {Promise<void>}
+   */
+  private initTotalPreviousPeriod = async (): Promise<void> => {
+    const PPTotalsByAccounts = await this.closingAccountsTotal(
+      this.query.PPToDate
+    );
+    // Inject to the repository.
+    this.PPTotalAccountsLedger = Ledger.fromTransactions(PPTotalsByAccounts);
+  };
+
+  /**
+   * Initialize date periods of previous year.
+   * @returns {Promise<void>}
+   */
+  private initPeriodsPreviousPeriod = async (): Promise<void> => {
+    const PPPeriodsBYAccounts = await this.accountsDatePeriods(
+      this.query.PPFromDate,
+      this.query.PPToDate,
+      this.transactionsGroupType
+    );
+    // Retrieves opening balance of grouped transactions.
+    const periodsOpeningByAccount = await this.closingAccountsTotal(
+      this.query.PPFromDate
+    );
+    // Inject to the repository.
+    this.PPPeriodsAccountsLedger = Ledger.fromTransactions(PPPeriodsBYAccounts);
+    this.PPPeriodsOpeningAccountLedger = Ledger.fromTransactions(
+      periodsOpeningByAccount
+    );
+  };
+
+  // ----------------------------
+  // # Utils
+  // ----------------------------
+  /**
+   * Retrieve accounts of the report.
+   * @return {Promise<IAccount[]>}
+   */
+  private getAccounts = () => {
+    const { Account } = this.models;
+
+    return Account.query();
+  };
+
+  /**
+   * Closing accounts date periods.
+   * @param openingDate
+   * @param datePeriodsType
+   * @returns
+   */
+  public accountsDatePeriods = async (
+    fromDate: Date,
+    toDate: Date,
+    datePeriodsType
+  ) => {
+    const { AccountTransaction } = this.models;
+
+    return AccountTransaction.query().onBuild((query) => {
+      query.sum('credit as credit');
+      query.sum('debit as debit');
+      query.groupBy('accountId');
+      query.select(['accountId']);
+
+      query.modify('groupByDateFormat', datePeriodsType);
+      query.modify('filterDateRange', fromDate, toDate);
+      query.withGraphFetched('account');
+
+      this.commonFilterBranchesQuery(query);
+    });
+  };
+
+  /**
+   * Retrieve the opening balance transactions of the report.
+   */
+  public closingAccountsTotal = async (openingDate: Date | string) => {
+    const { AccountTransaction } = this.models;
+
+    return AccountTransaction.query().onBuild((query) => {
+      query.sum('credit as credit');
+      query.sum('debit as debit');
+      query.groupBy('accountId');
+      query.select(['accountId']);
+
+      query.modify('filterDateRange', null, openingDate);
+      query.withGraphFetched('account');
+
+      this.commonFilterBranchesQuery(query);
+    });
+  };
+
+  /**
+   * Common branches filter query.
+   * @param {Knex.QueryBuilder} query
+   */
+  private commonFilterBranchesQuery = (query: Knex.QueryBuilder) => {
+    if (!isEmpty(this.query.branchesIds)) {
+      query.modify('filterByBranches', this.query.branchesIds);
+    }
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetSchema.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetSchema.ts
new file mode 100644
index 000000000..a7faa81c5
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetSchema.ts
@@ -0,0 +1,122 @@
+/* eslint-disable import/prefer-default-export */
+import * as R from 'ramda';
+import {
+  BALANCE_SHEET_SCHEMA_NODE_ID,
+  BALANCE_SHEET_SCHEMA_NODE_TYPE,
+} from '@/interfaces';
+import { ACCOUNT_TYPE } from '@/data/AccountTypes';
+import { FinancialSchema } from '../FinancialSchema';
+
+
+export const BalanceSheetSchema = (Base) =>
+  class extends R.compose(FinancialSchema)(Base) {
+    /**
+     * Retrieves the balance sheet schema.
+     * @returns 
+     */
+    getSchema = () => {
+      return getBalanceSheetSchema();
+    };
+  };
+
+/**
+ * Retrieve the balance sheet report schema.
+ */
+export const getBalanceSheetSchema = () => [
+  {
+    name: 'balance_sheet.assets',
+    id: BALANCE_SHEET_SCHEMA_NODE_ID.ASSETS,
+    type: BALANCE_SHEET_SCHEMA_NODE_TYPE.AGGREGATE,
+    children: [
+      {
+        name: 'balance_sheet.current_asset',
+        id: BALANCE_SHEET_SCHEMA_NODE_ID.CURRENT_ASSETS,
+        type: BALANCE_SHEET_SCHEMA_NODE_TYPE.AGGREGATE,
+        children: [
+          {
+            name: 'balance_sheet.cash_and_cash_equivalents',
+            id: BALANCE_SHEET_SCHEMA_NODE_ID.CASH_EQUIVALENTS,
+            type: BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNTS,
+            accountsTypes: [ACCOUNT_TYPE.CASH, ACCOUNT_TYPE.BANK],
+          },
+          {
+            name: 'balance_sheet.accounts_receivable',
+            id: BALANCE_SHEET_SCHEMA_NODE_ID.ACCOUNTS_RECEIVABLE,
+            type: BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNTS,
+            accountsTypes: [ACCOUNT_TYPE.ACCOUNTS_RECEIVABLE],
+          },
+          {
+            name: 'balance_sheet.inventory',
+            id: BALANCE_SHEET_SCHEMA_NODE_ID.INVENTORY,
+            type: BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNTS,
+            accountsTypes: [ACCOUNT_TYPE.INVENTORY],
+          },
+          {
+            name: 'balance_sheet.other_current_assets',
+            id: BALANCE_SHEET_SCHEMA_NODE_ID.OTHER_CURRENT_ASSET,
+            type: BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNTS,
+            accountsTypes: [ACCOUNT_TYPE.OTHER_CURRENT_ASSET],
+          },
+        ],
+        alwaysShow: true,
+      },
+      {
+        name: 'balance_sheet.fixed_asset',
+        id: BALANCE_SHEET_SCHEMA_NODE_ID.FIXED_ASSET,
+        type: BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNTS,
+        accountsTypes: [ACCOUNT_TYPE.FIXED_ASSET],
+      },
+      {
+        name: 'balance_sheet.non_current_assets',
+        id: BALANCE_SHEET_SCHEMA_NODE_ID.NON_CURRENT_ASSET,
+        type: BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNTS,
+        accountsTypes: [ACCOUNT_TYPE.NON_CURRENT_ASSET],
+      },
+    ],
+    alwaysShow: true,
+  },
+  {
+    name: 'balance_sheet.liabilities_and_equity',
+    id: BALANCE_SHEET_SCHEMA_NODE_ID.LIABILITY_EQUITY,
+    type: BALANCE_SHEET_SCHEMA_NODE_TYPE.AGGREGATE,
+    children: [
+      {
+        name: 'balance_sheet.liabilities',
+        id: BALANCE_SHEET_SCHEMA_NODE_ID.LIABILITY,
+        type: BALANCE_SHEET_SCHEMA_NODE_TYPE.AGGREGATE,
+        children: [
+          {
+            name: 'balance_sheet.current_liabilties',
+            id: BALANCE_SHEET_SCHEMA_NODE_ID.CURRENT_LIABILITY,
+            type: BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNTS,
+            accountsTypes: [
+              ACCOUNT_TYPE.ACCOUNTS_PAYABLE,
+              ACCOUNT_TYPE.TAX_PAYABLE,
+              ACCOUNT_TYPE.CREDIT_CARD,
+              ACCOUNT_TYPE.OTHER_CURRENT_LIABILITY,
+            ],
+          },
+          {
+            name: 'balance_sheet.long_term_liabilities',
+            id: BALANCE_SHEET_SCHEMA_NODE_ID.LOGN_TERM_LIABILITY,
+            type: BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNTS,
+            accountsTypes: [ACCOUNT_TYPE.LOGN_TERM_LIABILITY],
+          },
+          {
+            name: 'balance_sheet.non_current_liabilities',
+            id: BALANCE_SHEET_SCHEMA_NODE_ID.NON_CURRENT_LIABILITY,
+            type: BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNTS,
+            accountsTypes: [ACCOUNT_TYPE.NON_CURRENT_LIABILITY],
+          },
+        ],
+      },
+      {
+        name: 'balance_sheet.equity',
+        id: BALANCE_SHEET_SCHEMA_NODE_ID.EQUITY,
+        type: BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNTS,
+        accountsTypes: [ACCOUNT_TYPE.EQUITY],
+      },
+    ],
+    alwaysShow: true,
+  },
+];
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetService.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetService.ts
new file mode 100644
index 000000000..f674048bc
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetService.ts
@@ -0,0 +1,138 @@
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import {
+  IBalanceSheetStatementService,
+  IBalanceSheetQuery,
+  IBalanceSheetStatement,
+  IBalanceSheetMeta,
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import Journal from '@/services/Accounting/JournalPoster';
+import BalanceSheetStatement from './BalanceSheet';
+import InventoryService from '@/services/Inventory/Inventory';
+import { parseBoolean } from 'utils';
+import { Tenant } from '@/system/models';
+import BalanceSheetRepository from './BalanceSheetRepository';
+
+@Service()
+export default class BalanceSheetStatementService
+  implements IBalanceSheetStatementService
+{
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  inventoryService: InventoryService;
+
+  /**
+   * Defaults balance sheet filter query.
+   * @return {IBalanceSheetQuery}
+   */
+  get defaultQuery(): IBalanceSheetQuery {
+    return {
+      displayColumnsType: 'total',
+      displayColumnsBy: 'month',
+
+      fromDate: moment().startOf('year').format('YYYY-MM-DD'),
+      toDate: moment().endOf('year').format('YYYY-MM-DD'),
+
+      numberFormat: {
+        precision: 2,
+        divideOn1000: false,
+        showZero: false,
+        formatMoney: 'total',
+        negativeFormat: 'mines',
+      },
+      noneZero: false,
+      noneTransactions: false,
+
+      basis: 'cash',
+      accountIds: [],
+
+      percentageOfColumn: false,
+      percentageOfRow: false,
+
+      previousPeriod: false,
+      previousPeriodAmountChange: false,
+      previousPeriodPercentageChange: false,
+
+      previousYear: false,
+      previousYearAmountChange: false,
+      previousYearPercentageChange: false,
+    };
+  }
+
+  /**
+   * Retrieve the balance sheet meta.
+   * @param {number} tenantId -
+   * @returns {IBalanceSheetMeta}
+   */
+  private reportMetadata(tenantId: number): IBalanceSheetMeta {
+    const settings = this.tenancy.settings(tenantId);
+
+    const isCostComputeRunning =
+      this.inventoryService.isItemsCostComputeRunning(tenantId);
+
+    const organizationName = settings.get({
+      group: 'organization',
+      key: 'name',
+    });
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+
+    return {
+      isCostComputeRunning: parseBoolean(isCostComputeRunning, false),
+      organizationName,
+      baseCurrency,
+    };
+  }
+
+  /**
+   * Retrieve balance sheet statement.
+   * -------------
+   * @param {number} tenantId
+   * @param {IBalanceSheetQuery} query
+   *
+   * @return {IBalanceSheetStatement}
+   */
+  public async balanceSheet(
+    tenantId: number,
+    query: IBalanceSheetQuery
+  ): Promise<IBalanceSheetStatement> {
+    const i18n = this.tenancy.i18n(tenantId);
+
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const filter = {
+      ...this.defaultQuery,
+      ...query,
+    };
+    const models = this.tenancy.models(tenantId);
+    const balanceSheetRepo = new BalanceSheetRepository(models, filter);
+
+    await balanceSheetRepo.asyncInitialize();
+
+    // Balance sheet report instance.
+    const balanceSheetInstanace = new BalanceSheetStatement(
+      filter,
+      balanceSheetRepo,
+      tenant.metadata.baseCurrency,
+      i18n
+    );
+    // Balance sheet data.
+    const balanceSheetData = balanceSheetInstanace.reportData();
+
+    return {
+      data: balanceSheetData,
+      query: filter,
+      meta: this.reportMetadata(tenantId),
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTable.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTable.ts
new file mode 100644
index 000000000..43bf9c1b5
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTable.ts
@@ -0,0 +1,247 @@
+import * as R from 'ramda';
+import {
+  IBalanceSheetStatementData,
+  ITableColumnAccessor,
+  IBalanceSheetQuery,
+  ITableColumn,
+  ITableRow,
+  BALANCE_SHEET_SCHEMA_NODE_TYPE,
+  IBalanceSheetDataNode,
+  IBalanceSheetSchemaNode,
+} from '@/interfaces';
+import { tableRowMapper } from 'utils';
+import FinancialSheet from '../FinancialSheet';
+import { BalanceSheetComparsionPreviousYear } from './BalanceSheetComparsionPreviousYear';
+import { IROW_TYPE, DISPLAY_COLUMNS_BY } from './constants';
+import { BalanceSheetComparsionPreviousPeriod } from './BalanceSheetComparsionPreviousPeriod';
+import { BalanceSheetPercentage } from './BalanceSheetPercentage';
+import { FinancialSheetStructure } from '../FinancialSheetStructure';
+import { BalanceSheetBase } from './BalanceSheetBase';
+import { BalanceSheetTablePercentage } from './BalanceSheetTablePercentage';
+import { BalanceSheetTablePreviousYear } from './BalanceSheetTablePreviousYear';
+import { BalanceSheetTablePreviousPeriod } from './BalanceSheetTablePreviousPeriod';
+import { FinancialTable } from '../FinancialTable';
+import { BalanceSheetQuery } from './BalanceSheetQuery';
+import { BalanceSheetTableDatePeriods } from './BalanceSheetTableDatePeriods';
+
+export default class BalanceSheetTable extends R.compose(
+  BalanceSheetTablePreviousPeriod,
+  BalanceSheetTablePreviousYear,
+  BalanceSheetTableDatePeriods,
+  BalanceSheetTablePercentage,
+  BalanceSheetComparsionPreviousYear,
+  BalanceSheetComparsionPreviousPeriod,
+  BalanceSheetPercentage,
+  FinancialSheetStructure,
+  FinancialTable,
+  BalanceSheetBase
+)(FinancialSheet) {
+  /**
+   * @param {}
+   */
+  reportData: IBalanceSheetStatementData;
+
+  /**
+   * Balance sheet query.
+   * @parma {}
+   */
+  query: BalanceSheetQuery;
+
+  /**
+   * Constructor method.
+   * @param {IBalanceSheetStatementData} reportData -
+   * @param {IBalanceSheetQuery} query -
+   */
+  constructor(
+    reportData: IBalanceSheetStatementData,
+    query: IBalanceSheetQuery,
+    i18n: any
+  ) {
+    super();
+
+    this.reportData = reportData;
+    this.query = new BalanceSheetQuery(query);
+    this.i18n = i18n;
+  }
+
+  /**
+   * Detarmines the node type of the given schema node.
+   * @param  {IBalanceSheetStructureSection} node -
+   * @param  {string} type -
+   * @return {boolean}
+   */
+  protected isNodeType = R.curry(
+    (type: string, node: IBalanceSheetSchemaNode): boolean => {
+      return node.nodeType === type;
+    }
+  );
+
+  // -------------------------
+  // # Accessors.
+  // -------------------------
+  /**
+   * Retrieve the common columns for all report nodes.
+   * @param {ITableColumnAccessor[]}
+   */
+  private commonColumnsAccessors = (): ITableColumnAccessor[] => {
+    return R.compose(
+      R.concat([{ key: 'name', accessor: 'name' }]),
+      R.ifElse(
+        R.always(this.isDisplayColumnsBy(DISPLAY_COLUMNS_BY.DATE_PERIODS)),
+        R.concat(this.datePeriodsColumnsAccessors()),
+        R.concat(this.totalColumnAccessor())
+      )
+    )([]);
+  };
+
+  /**
+   * Retrieve the total column accessor.
+   * @return {ITableColumnAccessor[]}
+   */
+  private totalColumnAccessor = (): ITableColumnAccessor[] => {
+    return R.pipe(
+      R.concat(this.previousPeriodColumnAccessor()),
+      R.concat(this.previousYearColumnAccessor()),
+      R.concat(this.percentageColumnsAccessor()),
+      R.concat([{ key: 'total', accessor: 'total.formattedAmount' }])
+    )([]);
+  };
+
+  /**
+   *
+   * @param node
+   * @returns {ITableRow}
+   */
+  private aggregateNodeTableRowsMapper = (node): ITableRow => {
+    const columns = this.commonColumnsAccessors();
+    const meta = {
+      rowTypes: [IROW_TYPE.AGGREGATE],
+      id: node.id,
+    };
+    return tableRowMapper(node, columns, meta);
+  };
+
+  /**
+   *
+   * @param node
+   * @returns {ITableRow}
+   */
+  private accountsNodeTableRowsMapper = (node): ITableRow => {
+    const columns = this.commonColumnsAccessors();
+    const meta = {
+      rowTypes: [IROW_TYPE.ACCOUNTS],
+      id: node.id,
+    };
+    return tableRowMapper(node, columns, meta);
+  };
+
+  /**
+   *
+   * @param {} node
+   * @returns {ITableRow}
+   */
+  private accountNodeTableRowsMapper = (node): ITableRow => {
+    const columns = this.commonColumnsAccessors();
+
+    const meta = {
+      rowTypes: [IROW_TYPE.ACCOUNT],
+      id: node.id,
+    };
+    return tableRowMapper(node, columns, meta);
+  };
+
+  /**
+   * Mappes the given report node to table rows.
+   * @param   {IBalanceSheetDataNode} node -
+   * @returns {ITableRow}
+   */
+  private nodeToTableRowsMapper = (node: IBalanceSheetDataNode): ITableRow => {
+    return R.cond([
+      [
+        this.isNodeType(BALANCE_SHEET_SCHEMA_NODE_TYPE.AGGREGATE),
+        this.aggregateNodeTableRowsMapper,
+      ],
+      [
+        this.isNodeType(BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNTS),
+        this.accountsNodeTableRowsMapper,
+      ],
+      [
+        this.isNodeType(BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNT),
+        this.accountNodeTableRowsMapper,
+      ],
+    ])(node);
+  };
+
+  /**
+   * Mappes the given report sections to table rows.
+   * @param  {IBalanceSheetDataNode[]} nodes -
+   * @return {ITableRow}
+   */
+  private nodesToTableRowsMapper = (
+    nodes: IBalanceSheetDataNode[]
+  ): ITableRow[] => {
+    return this.mapNodesDeep(nodes, this.nodeToTableRowsMapper);
+  };
+
+  /**
+   * Retrieves the total children columns.
+   * @returns {ITableColumn[]}
+   */
+  private totalColumnChildren = (): ITableColumn[] => {
+    return R.compose(
+      R.unless(
+        R.isEmpty,
+        R.concat([{ key: 'total', Label: this.i18n.__('balance_sheet.total') }])
+      ),
+      R.concat(this.percentageColumns()),
+      R.concat(this.getPreviousYearColumns()),
+      R.concat(this.previousPeriodColumns())
+    )([]);
+  };
+
+  /**
+   * Retrieve the total column.
+   * @returns {ITableColumn[]}
+   */
+  private totalColumn = (): ITableColumn[] => {
+    return [
+      {
+        key: 'total',
+        label: this.i18n.__('balance_sheet.total'),
+        children: this.totalColumnChildren(),
+      },
+    ];
+  };
+
+  /**
+   * Retrieve the report table rows.
+   * @returns {ITableRow[]}
+   */
+  public tableRows = (): ITableRow[] => {
+    return R.compose(
+      this.addTotalRows,
+      this.nodesToTableRowsMapper
+    )(this.reportData);
+  };
+
+  // -------------------------
+  // # Columns.
+  // -------------------------
+  /**
+   * Retrieve the report table columns.
+   * @returns {ITableColumn[]}
+   */
+  public tableColumns = (): ITableColumn[] => {
+    return R.compose(
+      this.tableColumnsCellIndexing,
+      R.concat([
+        { key: 'name', label: this.i18n.__('balance_sheet.account_name') },
+      ]),
+      R.ifElse(
+        this.query.isDatePeriodsColumnsType,
+        R.concat(this.datePeriodsColumns()),
+        R.concat(this.totalColumn())
+      )
+    )([]);
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTableDatePeriods.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTableDatePeriods.ts
new file mode 100644
index 000000000..3e195aa24
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTableDatePeriods.ts
@@ -0,0 +1,137 @@
+import * as R from 'ramda';
+import moment from 'moment';
+import {
+  ITableColumn,
+  IDateRange,
+  ICashFlowDateRange,
+  ITableColumnAccessor,
+} from '@/interfaces';
+import { FinancialDatePeriods } from '../FinancialDatePeriods';
+
+export const BalanceSheetTableDatePeriods = (Base) =>
+  class extends R.compose(FinancialDatePeriods)(Base) {
+    /**
+     * Retrieves the date periods based on the report query.
+     * @returns {IDateRange[]}
+     */
+    get datePeriods() {
+      return this.getDateRanges(
+        this.query.fromDate,
+        this.query.toDate,
+        this.query.displayColumnsBy
+      );
+    }
+
+    /**
+     * Retrieve the formatted column label from the given date range.
+     * @param {ICashFlowDateRange} dateRange -
+     * @return {string}
+     */
+    private formatColumnLabel = (dateRange: ICashFlowDateRange) => {
+      const monthFormat = (range) => moment(range.toDate).format('YYYY-MM');
+      const yearFormat = (range) => moment(range.toDate).format('YYYY');
+      const dayFormat = (range) => moment(range.toDate).format('YYYY-MM-DD');
+
+      const conditions = [
+        ['month', monthFormat],
+        ['year', yearFormat],
+        ['day', dayFormat],
+        ['quarter', monthFormat],
+        ['week', dayFormat],
+      ];
+      const conditionsPairs = R.map(
+        ([type, formatFn]) => [
+          R.always(this.query.isDisplayColumnsBy(type)),
+          formatFn,
+        ],
+        conditions
+      );
+      return R.compose(R.cond(conditionsPairs))(dateRange);
+    };
+
+    // -------------------------
+    // # Accessors.
+    // -------------------------
+    /**
+     * Date period columns accessor.
+     * @param {IDateRange} dateRange -
+     * @param {number} index -
+     */
+    private datePeriodColumnsAccessor = R.curry(
+      (dateRange: IDateRange, index: number) => {
+        return R.pipe(
+          R.concat(this.previousPeriodHorizColumnAccessors(index)),
+          R.concat(this.previousYearHorizontalColumnAccessors(index)),
+          R.concat(this.percetangeDatePeriodColumnsAccessor(index)),
+          R.concat([
+            {
+              key: `date-range-${index}`,
+              accessor: `horizontalTotals[${index}].total.formattedAmount`,
+            },
+          ])
+        )([]);
+      }
+    );
+
+    /**
+     * Retrieve the date periods columns accessors.
+     * @returns {ITableColumnAccessor[]}
+     */
+    protected datePeriodsColumnsAccessors = (): ITableColumnAccessor[] => {
+      return R.compose(
+        R.flatten,
+        R.addIndex(R.map)(this.datePeriodColumnsAccessor)
+      )(this.datePeriods);
+    };
+
+    // -------------------------
+    // # Columns.
+    // -------------------------
+    /**
+     *
+     * @param {number} index
+     * @param {} dateRange
+     * @returns {}
+     */
+    private datePeriodChildrenColumns = (
+      index: number,
+      dateRange: IDateRange
+    ) => {
+      return R.compose(
+        R.unless(
+          R.isEmpty,
+          R.concat([
+            { key: `total`, label: this.i18n.__('balance_sheet.total') },
+          ])
+        ),
+        R.concat(this.percentageColumns()),
+        R.concat(this.getPreviousYearHorizontalColumns(dateRange)),
+        R.concat(this.previousPeriodHorizontalColumns(dateRange))
+      )([]);
+    };
+
+    /**
+     *
+     * @param dateRange
+     * @param index
+     * @returns
+     */
+    private datePeriodColumn = (
+      dateRange: IDateRange,
+      index: number
+    ): ITableColumn => {
+      return {
+        key: `date-range-${index}`,
+        label: this.formatColumnLabel(dateRange),
+        children: this.datePeriodChildrenColumns(index, dateRange),
+      };
+    };
+
+    /**
+     * Date periods columns.
+     * @returns {ITableColumn[]}
+     */
+    protected datePeriodsColumns = (): ITableColumn[] => {
+      return this.datePeriods.map(this.datePeriodColumn);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTablePercentage.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTablePercentage.ts
new file mode 100644
index 000000000..a7d3f82c4
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTablePercentage.ts
@@ -0,0 +1,83 @@
+import * as R from 'ramda';
+import { ITableColumn } from '@/interfaces';
+
+export const BalanceSheetTablePercentage = (Base) =>
+  class extends Base {
+    // --------------------
+    // # Columns
+    // --------------------
+    /**
+     * Retrieve percentage of column/row columns.
+     * @returns {ITableColumn[]}
+     */
+    protected percentageColumns = (): ITableColumn[] => {
+      return R.pipe(
+        R.when(
+          this.query.isColumnsPercentageActive,
+          R.append({
+            key: 'percentage_of_column',
+            label: this.i18n.__('balance_sheet.percentage_of_column'),
+          })
+        ),
+        R.when(
+          this.query.isRowsPercentageActive,
+          R.append({
+            key: 'percentage_of_row',
+            label: this.i18n.__('balance_sheet.percentage_of_row'),
+          })
+        )
+      )([]);
+    };
+
+    // --------------------
+    // # Accessors
+    // --------------------
+    /**
+     * Retrieves percentage of column/row accessors.
+     * @returns {ITableColumn[]}
+     */
+    protected percentageColumnsAccessor = (): ITableColumn[] => {
+      return R.pipe(
+        R.when(
+          this.query.isColumnsPercentageActive,
+          R.append({
+            key: 'percentage_of_column',
+            accessor: 'percentageColumn.formattedAmount',
+          })
+        ),
+        R.when(
+          this.query.isRowsPercentageActive,
+          R.append({
+            key: 'percentage_of_row',
+            accessor: 'percentageRow.formattedAmount',
+          })
+        )
+      )([]);
+    };
+
+    /**
+     * Percentage columns accessors for date period columns.
+     * @param   {number} index
+     * @returns {ITableColumn[]}
+     */
+    protected percetangeDatePeriodColumnsAccessor = (
+      index: number
+    ): ITableColumn[] => {
+      return R.pipe(
+        R.when(
+          this.query.isColumnsPercentageActive,
+          R.append({
+            key: `percentage_of_column-${index}`,
+            accessor: `horizontalTotals[${index}].percentageColumn.formattedAmount`,
+          })
+        ),
+        R.when(
+          this.query.isRowsPercentageActive,
+          R.append({
+            key: `percentage_of_row-${index}`,
+            accessor: `horizontalTotals[${index}].percentageRow.formattedAmount`,
+          })
+        )
+      )([]);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTablePreviousPeriod.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTablePreviousPeriod.ts
new file mode 100644
index 000000000..1541df9c2
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTablePreviousPeriod.ts
@@ -0,0 +1,109 @@
+import * as R from 'ramda';
+import { IDateRange, ITableColumn } from '@/interfaces';
+import { BalanceSheetQuery } from './BalanceSheetQuery';
+import { FinancialTablePreviousPeriod } from '../FinancialTablePreviousPeriod';
+import { FinancialDateRanges } from '../FinancialDateRanges';
+
+export const BalanceSheetTablePreviousPeriod = (Base) =>
+  class extends R.compose(
+    FinancialTablePreviousPeriod,
+    FinancialDateRanges
+  )(Base) {
+    readonly query: BalanceSheetQuery;
+
+    // --------------------
+    // # Columns
+    // --------------------
+    /**
+     * Retrieves the previous period columns.
+     * @returns {ITableColumn[]}
+     */
+    protected previousPeriodColumns = (
+      dateRange?: IDateRange
+    ): ITableColumn[] => {
+      return R.pipe(
+        // Previous period columns.
+        R.when(
+          this.query.isPreviousPeriodActive,
+          R.append(this.getPreviousPeriodTotalColumn(dateRange))
+        ),
+        R.when(
+          this.query.isPreviousPeriodChangeActive,
+          R.append(this.getPreviousPeriodChangeColumn())
+        ),
+        R.when(
+          this.query.isPreviousPeriodPercentageActive,
+          R.append(this.getPreviousPeriodPercentageColumn())
+        )
+      )([]);
+    };
+
+    /**
+     * Previous period for date periods
+     * @param   {IDateRange} dateRange
+     * @returns {ITableColumn}
+     */
+    protected previousPeriodHorizontalColumns = (
+      dateRange: IDateRange
+    ): ITableColumn[] => {
+      const PPDateRange = this.getPPDatePeriodDateRange(
+        dateRange.fromDate,
+        dateRange.toDate,
+        this.query.displayColumnsBy
+      );
+      return this.previousPeriodColumns({
+        fromDate: PPDateRange.fromDate,
+        toDate: PPDateRange.toDate,
+      });
+    };
+
+    // --------------------
+    // # Accessors
+    // --------------------
+    /**
+     * Retrieves previous period columns accessors.
+     * @returns {ITableColumn[]}
+     */
+    protected previousPeriodColumnAccessor = (): ITableColumn[] => {
+      return R.pipe(
+        // Previous period columns.
+        R.when(
+          this.query.isPreviousPeriodActive,
+          R.append(this.getPreviousPeriodTotalAccessor())
+        ),
+        R.when(
+          this.query.isPreviousPeriodChangeActive,
+          R.append(this.getPreviousPeriodChangeAccessor())
+        ),
+        R.when(
+          this.query.isPreviousPeriodPercentageActive,
+          R.append(this.getPreviousPeriodPercentageAccessor())
+        )
+      )([]);
+    };
+
+    /**
+     *
+     * @param   {number} index
+     * @returns
+     */
+    protected previousPeriodHorizColumnAccessors = (
+      index: number
+    ): ITableColumn[] => {
+      return R.pipe(
+        // Previous period columns.
+        R.when(
+          this.query.isPreviousPeriodActive,
+          R.append(this.getPreviousPeriodTotalHorizAccessor(index))
+        ),
+        R.when(
+          this.query.isPreviousPeriodChangeActive,
+          R.append(this.getPreviousPeriodChangeHorizAccessor(index))
+        ),
+        R.when(
+          this.query.isPreviousPeriodPercentageActive,
+          R.append(this.getPreviousPeriodPercentageHorizAccessor(index))
+        )
+      )([]);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTablePreviousYear.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTablePreviousYear.ts
new file mode 100644
index 000000000..fdc51877b
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTablePreviousYear.ts
@@ -0,0 +1,97 @@
+import * as R from 'ramda';
+import { IDateRange, ITableColumn } from '@/interfaces';
+import { FinancialTablePreviousYear } from '../FinancialTablePreviousYear';
+import { FinancialDateRanges } from '../FinancialDateRanges';
+
+export const BalanceSheetTablePreviousYear = (Base) =>
+  class extends R.compose(FinancialTablePreviousYear, FinancialDateRanges)(Base) {
+    // --------------------
+    // # Columns.
+    // --------------------
+    /**
+     * Retrieves pervious year comparison columns.
+     * @returns {ITableColumn[]}
+     */
+    protected getPreviousYearColumns = (
+      dateRange?: IDateRange
+    ): ITableColumn[] => {
+      return R.pipe(
+        // Previous year columns.
+        R.when(
+          this.query.isPreviousYearActive,
+          R.append(this.getPreviousYearTotalColumn(dateRange))
+        ),
+        R.when(
+          this.query.isPreviousYearChangeActive,
+          R.append(this.getPreviousYearChangeColumn())
+        ),
+        R.when(
+          this.query.isPreviousYearPercentageActive,
+          R.append(this.getPreviousYearPercentageColumn())
+        )
+      )([]);
+    };
+
+    /**
+     * 
+     * @param {IDateRange} dateRange
+     * @returns
+     */
+    protected getPreviousYearHorizontalColumns = (dateRange: IDateRange) => {
+      const PYDateRange = this.getPreviousYearDateRange(
+        dateRange.fromDate,
+        dateRange.toDate
+      );
+      return this.getPreviousYearColumns(PYDateRange);
+    };
+
+    // --------------------
+    // # Accessors.
+    // --------------------
+    /**
+     * Retrieves previous year columns accessors.
+     * @returns {ITableColumn[]}
+     */
+    protected previousYearColumnAccessor = (): ITableColumn[] => {
+      return R.pipe(
+        // Previous year columns.
+        R.when(
+          this.query.isPreviousYearActive,
+          R.append(this.getPreviousYearTotalAccessor())
+        ),
+        R.when(
+          this.query.isPreviousYearChangeActive,
+          R.append(this.getPreviousYearChangeAccessor())
+        ),
+        R.when(
+          this.query.isPreviousYearPercentageActive,
+          R.append(this.getPreviousYearPercentageAccessor())
+        )
+      )([]);
+    };
+
+    /**
+     * Previous year period column accessor.
+     * @param   {number} index
+     * @returns {ITableColumn[]}
+     */
+    protected previousYearHorizontalColumnAccessors = (
+      index: number
+    ): ITableColumn[] => {
+      return R.pipe(
+        // Previous year columns.
+        R.when(
+          this.query.isPreviousYearActive,
+          R.append(this.getPreviousYearTotalHorizAccessor(index))
+        ),
+        R.when(
+          this.query.isPreviousYearChangeActive,
+          R.append(this.getPreviousYearChangeHorizAccessor(index))
+        ),
+        R.when(
+          this.query.isPreviousYearPercentageActive,
+          R.append(this.getPreviousYearPercentageHorizAccessor(index))
+        )
+      )([]);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTotal.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTotal.ts
new file mode 100644
index 000000000..c04fd6d7b
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/BalanceSheetTotal.ts
@@ -0,0 +1,3 @@
+import * as R from 'ramda';
+
+export const BalanceSheetTotal = (Base: any) => class extends Base {};
diff --git a/packages/server/src/services/FinancialStatements/BalanceSheet/constants.ts b/packages/server/src/services/FinancialStatements/BalanceSheet/constants.ts
new file mode 100644
index 000000000..ad447a199
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/BalanceSheet/constants.ts
@@ -0,0 +1,13 @@
+export const MAP_CONFIG = { childrenPath: 'children', pathFormat: 'array' };
+
+export const DISPLAY_COLUMNS_BY = {
+  DATE_PERIODS: 'date_periods',
+  TOTAL: 'total',
+};
+
+export enum IROW_TYPE {
+  AGGREGATE = 'AGGREGATE',
+  ACCOUNTS = 'ACCOUNTS',
+  ACCOUNT = 'ACCOUNT',
+  TOTAL = 'TOTAL',
+}
diff --git a/packages/server/src/services/FinancialStatements/CashFlow/CashFlow.ts b/packages/server/src/services/FinancialStatements/CashFlow/CashFlow.ts
new file mode 100644
index 000000000..fe2717fea
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/CashFlow/CashFlow.ts
@@ -0,0 +1,703 @@
+import * as R from 'ramda';
+import { defaultTo, map, set, sumBy, isEmpty, mapValues, get } from 'lodash';
+import * as mathjs from 'mathjs';
+import moment from 'moment';
+import { compose } from 'lodash/fp';
+import {
+  IAccount,
+  ILedger,
+  INumberFormatQuery,
+  ICashFlowSchemaSection,
+  ICashFlowStatementQuery,
+  ICashFlowStatementNetIncomeSection,
+  ICashFlowStatementAccountSection,
+  ICashFlowSchemaSectionAccounts,
+  ICashFlowStatementAccountMeta,
+  ICashFlowSchemaAccountRelation,
+  ICashFlowStatementSectionType,
+  ICashFlowStatementData,
+  ICashFlowSchemaTotalSection,
+  ICashFlowStatementTotalSection,
+  ICashFlowStatementSection,
+  ICashFlowCashBeginningNode,
+  ICashFlowStatementAggregateSection,
+} from '@/interfaces';
+import CASH_FLOW_SCHEMA from './schema';
+import FinancialSheet from '../FinancialSheet';
+import { transformToMapBy, accumSum } from 'utils';
+import { ACCOUNT_ROOT_TYPE } from '@/data/AccountTypes';
+import { CashFlowStatementDatePeriods } from './CashFlowDatePeriods';
+import I18nService from '@/services/I18n/I18nService';
+import { DISPLAY_COLUMNS_BY } from './constants';
+import { FinancialSheetStructure } from '../FinancialSheetStructure';
+
+export default class CashFlowStatement extends compose(
+  CashFlowStatementDatePeriods,
+  FinancialSheetStructure
+)(FinancialSheet) {
+  readonly baseCurrency: string;
+  readonly i18n: I18nService;
+  readonly sectionsByIds = {};
+  readonly cashFlowSchemaMap: Map<string, ICashFlowSchemaSection>;
+  readonly cashFlowSchemaSeq: Array<string>;
+  readonly accountByTypeMap: Map<string, IAccount[]>;
+  readonly accountsByRootType: Map<string, IAccount[]>;
+  readonly ledger: ILedger;
+  readonly cashLedger: ILedger;
+  readonly netIncomeLedger: ILedger;
+  readonly query: ICashFlowStatementQuery;
+  readonly numberFormat: INumberFormatQuery;
+  readonly comparatorDateType: string;
+  readonly dateRangeSet: { fromDate: Date; toDate: Date }[];
+
+  /**
+   * Constructor method.
+   * @constructor
+   */
+  constructor(
+    accounts: IAccount[],
+    ledger: ILedger,
+    cashLedger: ILedger,
+    netIncomeLedger: ILedger,
+    query: ICashFlowStatementQuery,
+    baseCurrency: string,
+    i18n
+  ) {
+    super();
+
+    this.baseCurrency = baseCurrency;
+    this.i18n = i18n;
+    this.ledger = ledger;
+    this.cashLedger = cashLedger;
+    this.netIncomeLedger = netIncomeLedger;
+    this.accountByTypeMap = transformToMapBy(accounts, 'accountType');
+    this.accountsByRootType = transformToMapBy(accounts, 'accountRootType');
+    this.query = query;
+    this.numberFormat = this.query.numberFormat;
+    this.dateRangeSet = [];
+    this.comparatorDateType =
+      query.displayColumnsType === 'total' ? 'day' : query.displayColumnsBy;
+
+    this.initDateRangeCollection();
+  }
+
+  // --------------------------------------------
+  // # GENERAL UTILITIES
+  // --------------------------------------------
+  /**
+   * Retrieve the expense accounts ids.
+   * @return {number[]}
+   */
+  private getAccountsIdsByType = (accountType: string): number[] => {
+    const expenseAccounts = this.accountsByRootType.get(accountType);
+    const expenseAccountsIds = map(expenseAccounts, 'id');
+
+    return expenseAccountsIds;
+  };
+
+  /**
+   * Detarmines the given display columns by type.
+   * @param {string} displayColumnsBy
+   * @returns {boolean}
+   */
+  private isDisplayColumnsBy = (displayColumnsBy: string): boolean => {
+    return this.query.displayColumnsType === displayColumnsBy;
+  };
+
+  /**
+   * Adjustments the given amount.
+   * @param {string} direction
+   * @param {number} amount -
+   * @return {number}
+   */
+  private amountAdjustment = (direction: 'mines' | 'plus', amount): number => {
+    return R.when(
+      R.always(R.equals(direction, 'mines')),
+      R.multiply(-1)
+    )(amount);
+  };
+
+  // --------------------------------------------
+  // # NET INCOME NODE
+  // --------------------------------------------
+  /**
+   * Retrieve the accounts net income.
+   * @returns {number} - Amount of net income.
+   */
+  private getAccountsNetIncome(): number {
+    // Mapping income/expense accounts ids.
+    const incomeAccountsIds = this.getAccountsIdsByType(
+      ACCOUNT_ROOT_TYPE.INCOME
+    );
+    const expenseAccountsIds = this.getAccountsIdsByType(
+      ACCOUNT_ROOT_TYPE.EXPENSE
+    );
+    // Income closing balance.
+    const incomeClosingBalance = accumSum(incomeAccountsIds, (id) =>
+      this.netIncomeLedger.whereAccountId(id).getClosingBalance()
+    );
+    // Expense closing balance.
+    const expenseClosingBalance = accumSum(expenseAccountsIds, (id) =>
+      this.netIncomeLedger.whereAccountId(id).getClosingBalance()
+    );
+    // Net income = income - expenses.
+    const netIncome = incomeClosingBalance - expenseClosingBalance;
+
+    return netIncome;
+  }
+
+  /**
+   * Parses the net income section from the given section schema.
+   * @param   {ICashFlowSchemaSection} nodeSchema - Report section schema.
+   * @returns {ICashFlowStatementNetIncomeSection}
+   */
+  private netIncomeSectionMapper = (
+    nodeSchema: ICashFlowSchemaSection
+  ): ICashFlowStatementNetIncomeSection => {
+    const netIncome = this.getAccountsNetIncome();
+
+    const node = {
+      id: nodeSchema.id,
+      label: this.i18n.__(nodeSchema.label),
+      total: this.getAmountMeta(netIncome),
+      sectionType: ICashFlowStatementSectionType.NET_INCOME,
+    };
+    return R.compose(
+      R.when(
+        R.always(this.isDisplayColumnsBy(DISPLAY_COLUMNS_BY.DATE_PERIODS)),
+        this.assocPeriodsToNetIncomeNode
+      )
+    )(node);
+  };
+
+  // --------------------------------------------
+  // # ACCOUNT NODE
+  // --------------------------------------------
+  /**
+   * Retrieve account meta.
+   * @param   {ICashFlowSchemaAccountRelation} relation - Account relation.
+   * @param   {IAccount} account -
+   * @returns {ICashFlowStatementAccountMeta}
+   */
+  private accountMetaMapper = (
+    relation: ICashFlowSchemaAccountRelation,
+    account: IAccount
+  ): ICashFlowStatementAccountMeta => {
+    // Retrieve the closing balance of the given account.
+    const getClosingBalance = (id) =>
+      this.ledger.whereAccountId(id).getClosingBalance();
+
+    const closingBalance = R.compose(
+      // Multiplies the amount by -1 in case the relation in mines.
+      R.curry(this.amountAdjustment)(relation.direction)
+    )(getClosingBalance(account.id));
+
+    const node = {
+      id: account.id,
+      code: account.code,
+      label: account.name,
+      accountType: account.accountType,
+      adjusmentType: relation.direction,
+      total: this.getAmountMeta(closingBalance),
+      sectionType: ICashFlowStatementSectionType.ACCOUNT,
+    };
+    return R.compose(
+      R.when(
+        R.always(this.isDisplayColumnsBy(DISPLAY_COLUMNS_BY.DATE_PERIODS)),
+        this.assocPeriodsToAccountNode
+      )
+    )(node);
+  };
+
+  /**
+   * Retrieve accounts sections by the given schema relation.
+   * @param   {ICashFlowSchemaAccountRelation} relation
+   * @returns {ICashFlowStatementAccountMeta[]}
+   */
+  private getAccountsBySchemaRelation = (
+    relation: ICashFlowSchemaAccountRelation
+  ): ICashFlowStatementAccountMeta[] => {
+    const accounts = defaultTo(this.accountByTypeMap.get(relation.type), []);
+    const accountMetaMapper = R.curry(this.accountMetaMapper)(relation);
+    return R.map(accountMetaMapper)(accounts);
+  };
+
+  /**
+   * Retrieve the accounts meta.
+   * @param   {string[]} types
+   * @returns {ICashFlowStatementAccountMeta[]}
+   */
+  private getAccountsBySchemaRelations = (
+    relations: ICashFlowSchemaAccountRelation[]
+  ): ICashFlowStatementAccountMeta[] => {
+    return R.pipe(
+      R.append(R.map(this.getAccountsBySchemaRelation)(relations)),
+      R.flatten
+    )([]);
+  };
+
+  /**
+   * Calculates the accounts total
+   * @param   {ICashFlowStatementAccountMeta[]} accounts
+   * @returns {number}
+   */
+  private getAccountsMetaTotal = (
+    accounts: ICashFlowStatementAccountMeta[]
+  ): number => {
+    return sumBy(accounts, 'total.amount');
+  };
+
+  /**
+   * Retrieve the accounts section from the section schema.
+   * @param   {ICashFlowSchemaSectionAccounts} sectionSchema
+   * @returns {ICashFlowStatementAccountSection}
+   */
+  private accountsSectionParser = (
+    sectionSchema: ICashFlowSchemaSectionAccounts
+  ): ICashFlowStatementAccountSection => {
+    const { accountsRelations } = sectionSchema;
+
+    const accounts = this.getAccountsBySchemaRelations(accountsRelations);
+    const accountsTotal = this.getAccountsMetaTotal(accounts);
+    const total = this.getTotalAmountMeta(accountsTotal);
+
+    const node = {
+      sectionType: ICashFlowStatementSectionType.ACCOUNTS,
+      id: sectionSchema.id,
+      label: this.i18n.__(sectionSchema.label),
+      footerLabel: this.i18n.__(sectionSchema.footerLabel),
+      children: accounts,
+      total,
+    };
+    return R.compose(
+      R.when(
+        R.always(this.isDisplayColumnsBy(DISPLAY_COLUMNS_BY.DATE_PERIODS)),
+        this.assocPeriodsToAggregateNode
+      )
+    )(node);
+  };
+
+  /**
+   * Detarmines the schema section type.
+   * @param   {string} type
+   * @param   {ICashFlowSchemaSection} section
+   * @returns {boolean}
+   */
+  private isSchemaSectionType = R.curry(
+    (type: string, section: ICashFlowSchemaSection): boolean => {
+      return type === section.sectionType;
+    }
+  );
+
+  // --------------------------------------------
+  // # AGGREGATE NODE
+  // --------------------------------------------
+  /**
+   * Aggregate schema node parser to aggregate report node.
+   * @param   {ICashFlowSchemaSection} schemaSection
+   * @returns {ICashFlowStatementAggregateSection}
+   */
+  private regularSectionParser = R.curry(
+    (
+      children,
+      schemaSection: ICashFlowSchemaSection
+    ): ICashFlowStatementAggregateSection => {
+      const node = {
+        id: schemaSection.id,
+        label: this.i18n.__(schemaSection.label),
+        footerLabel: this.i18n.__(schemaSection.footerLabel),
+        sectionType: ICashFlowStatementSectionType.AGGREGATE,
+        children,
+      };
+      return R.compose(
+        R.when(
+          this.isSchemaSectionType(ICashFlowStatementSectionType.AGGREGATE),
+          this.assocRegularSectionTotal
+        ),
+        R.when(
+          this.isSchemaSectionType(ICashFlowStatementSectionType.AGGREGATE),
+          R.when(
+            R.always(this.isDisplayColumnsBy(DISPLAY_COLUMNS_BY.DATE_PERIODS)),
+            this.assocPeriodsToAggregateNode
+          )
+        )
+      )(node);
+    }
+  );
+
+  private transformSectionsToMap = (sections: ICashFlowSchemaSection[]) => {
+    return this.reduceNodesDeep(
+      sections,
+      (acc, section) => {
+        if (section.id) {
+          acc[`${section.id}`] = section;
+        }
+        return acc;
+      },
+      {}
+    );
+  };
+
+  // --------------------------------------------
+  // # TOTAL EQUATION NODE
+  // --------------------------------------------
+
+  private sectionsMapToTotal = (mappedSections: { [key: number]: any }) => {
+    return mapValues(mappedSections, (node) => get(node, 'total.amount') || 0);
+  };
+
+  /**
+   * Evauluate equaation string with the given scope table.
+   * @param  {string} equation -
+   * @param  {{ [key: string]: number }} scope -
+   * @return {number}
+   */
+  private evaluateEquation = (
+    equation: string,
+    scope: { [key: string | number]: number }
+  ): number => {
+    return mathjs.evaluate(equation, scope);
+  };
+
+  /**
+   * Retrieve the total section from the eqauation parser.
+   * @param   {ICashFlowSchemaTotalSection} sectionSchema
+   * @param   {ICashFlowSchemaSection[]} accumlatedSections
+   * @returns {ICashFlowStatementTotalSection}
+   */
+  private totalEquationSectionParser = (
+    accumlatedSections: ICashFlowSchemaSection[],
+    sectionSchema: ICashFlowSchemaTotalSection
+  ): ICashFlowStatementTotalSection => {
+    const mappedSectionsById = this.transformSectionsToMap(accumlatedSections);
+    const nodesTotalById = this.sectionsMapToTotal(mappedSectionsById);
+
+    const total = this.evaluateEquation(sectionSchema.equation, nodesTotalById);
+
+    return R.compose(
+      R.when(
+        R.always(this.isDisplayColumnsBy(DISPLAY_COLUMNS_BY.DATE_PERIODS)),
+        R.curry(this.assocTotalEquationDatePeriods)(
+          mappedSectionsById,
+          sectionSchema.equation
+        )
+      )
+    )({
+      sectionType: ICashFlowStatementSectionType.TOTAL,
+      id: sectionSchema.id,
+      label: this.i18n.__(sectionSchema.label),
+      total: this.getTotalAmountMeta(total),
+    });
+  };
+
+  /**
+   * Retrieve the beginning cash from date.
+   * @param  {Date|string} fromDate -
+   * @return {Date}
+   */
+  private beginningCashFrom = (fromDate: string | Date): Date => {
+    return moment(fromDate).subtract(1, 'days').toDate();
+  };
+
+  /**
+   * Retrieve account meta.
+   * @param   {ICashFlowSchemaAccountRelation} relation
+   * @param   {IAccount} account
+   * @returns {ICashFlowStatementAccountMeta}
+   */
+  private cashAccountMetaMapper = (
+    relation: ICashFlowSchemaAccountRelation,
+    account: IAccount
+  ): ICashFlowStatementAccountMeta => {
+    const cashToDate = this.beginningCashFrom(this.query.fromDate);
+
+    const closingBalance = this.cashLedger
+      .whereToDate(cashToDate)
+      .whereAccountId(account.id)
+      .getClosingBalance();
+
+    const node = {
+      id: account.id,
+      code: account.code,
+      label: account.name,
+      accountType: account.accountType,
+      adjusmentType: relation.direction,
+      total: this.getAmountMeta(closingBalance),
+      sectionType: ICashFlowStatementSectionType.ACCOUNT,
+    };
+    return R.compose(
+      R.when(
+        R.always(this.isDisplayColumnsBy(DISPLAY_COLUMNS_BY.DATE_PERIODS)),
+        this.assocCashAtBeginningAccountDatePeriods
+      )
+    )(node);
+  };
+
+  /**
+   * Retrieve accounts sections by the given schema relation.
+   * @param   {ICashFlowSchemaAccountRelation} relation
+   * @returns {ICashFlowStatementAccountMeta[]}
+   */
+  private getCashAccountsBySchemaRelation = (
+    relation: ICashFlowSchemaAccountRelation
+  ): ICashFlowStatementAccountMeta[] => {
+    const accounts = this.accountByTypeMap.get(relation.type) || [];
+    const accountMetaMapper = R.curry(this.cashAccountMetaMapper)(relation);
+    return accounts.map(accountMetaMapper);
+  };
+
+  /**
+   * Retrieve the accounts meta.
+   * @param {string[]} types
+   * @returns {ICashFlowStatementAccountMeta[]}
+   */
+  private getCashAccountsBySchemaRelations = (
+    relations: ICashFlowSchemaAccountRelation[]
+  ): ICashFlowStatementAccountMeta[] => {
+    return R.concat(...R.map(this.getCashAccountsBySchemaRelation)(relations));
+  };
+
+  /**
+   * Parses the cash at beginning section.
+   * @param  {ICashFlowSchemaTotalSection} sectionSchema -
+   * @return {ICashFlowCashBeginningNode}
+   */
+  private cashAtBeginningSectionParser = (
+    nodeSchema: ICashFlowSchemaSection
+  ): ICashFlowCashBeginningNode => {
+    const { accountsRelations } = nodeSchema;
+    const children = this.getCashAccountsBySchemaRelations(accountsRelations);
+    const total = this.getAccountsMetaTotal(children);
+
+    const node = {
+      sectionType: ICashFlowStatementSectionType.CASH_AT_BEGINNING,
+      id: nodeSchema.id,
+      label: this.i18n.__(nodeSchema.label),
+      children,
+      total: this.getTotalAmountMeta(total),
+    };
+    return R.compose(
+      R.when(
+        R.always(this.isDisplayColumnsBy(DISPLAY_COLUMNS_BY.DATE_PERIODS)),
+        this.assocCashAtBeginningDatePeriods
+      )
+    )(node);
+  };
+
+  /**
+   * Parses the schema section.
+   * @param   {ICashFlowSchemaSection} schemaNode
+   * @returns {ICashFlowSchemaSection}
+   */
+  private schemaSectionParser = (
+    schemaNode: ICashFlowSchemaSection,
+    children
+  ): ICashFlowSchemaSection | ICashFlowStatementSection => {
+    return R.compose(
+      // Accounts node.
+      R.when(
+        this.isSchemaSectionType(ICashFlowStatementSectionType.ACCOUNTS),
+        this.accountsSectionParser
+      ),
+      // Net income node.
+      R.when(
+        this.isSchemaSectionType(ICashFlowStatementSectionType.NET_INCOME),
+        this.netIncomeSectionMapper
+      ),
+      // Cash at beginning node.
+      R.when(
+        this.isSchemaSectionType(
+          ICashFlowStatementSectionType.CASH_AT_BEGINNING
+        ),
+        this.cashAtBeginningSectionParser
+      ),
+      // Aggregate node. (that has no section type).
+      R.when(
+        this.isSchemaSectionType(ICashFlowStatementSectionType.AGGREGATE),
+        this.regularSectionParser(children)
+      )
+    )(schemaNode);
+  };
+
+  /**
+   * Parses the schema section.
+   * @param   {ICashFlowSchemaSection | ICashFlowStatementSection} section
+   * @param   {number} key
+   * @param   {ICashFlowSchemaSection[]} parentValue
+   * @param   {(ICashFlowSchemaSection | ICashFlowStatementSection)[]} accumlatedSections
+   * @returns {ICashFlowSchemaSection}
+   */
+  private schemaSectionTotalParser = (
+    section: ICashFlowSchemaSection | ICashFlowStatementSection,
+    key: number,
+    parentValue: ICashFlowSchemaSection[],
+    context,
+    accumlatedSections: (ICashFlowSchemaSection | ICashFlowStatementSection)[]
+  ): ICashFlowSchemaSection | ICashFlowStatementSection => {
+    return R.compose(
+      // Total equation section.
+      R.when(
+        this.isSchemaSectionType(ICashFlowStatementSectionType.TOTAL),
+        R.curry(this.totalEquationSectionParser)(accumlatedSections)
+      )
+    )(section);
+  };
+
+  /**
+   * Schema sections parser.
+   * @param   {ICashFlowSchemaSection[]}schema
+   * @returns {ICashFlowStatementSection[]}
+   */
+  private schemaSectionsParser = (
+    schema: ICashFlowSchemaSection[]
+  ): ICashFlowStatementSection[] => {
+    return this.mapNodesDeepReverse(schema, this.schemaSectionParser);
+  };
+
+  /**
+   * Writes the `total` property to the aggregate node.
+   * @param  {ICashFlowStatementSection} section
+   * @return {ICashFlowStatementSection}
+   */
+  private assocRegularSectionTotal = (section: ICashFlowStatementSection) => {
+    const total = this.getAccountsMetaTotal(section.children);
+    return R.assoc('total', this.getTotalAmountMeta(total), section);
+  };
+
+  /**
+   * Parses total schema nodes.
+   * @param   {(ICashFlowSchemaSection | ICashFlowStatementSection)[]} sections
+   * @returns {(ICashFlowSchemaSection | ICashFlowStatementSection)[]}
+   */
+  private totalSectionsParser = (
+    sections: (ICashFlowSchemaSection | ICashFlowStatementSection)[]
+  ): (ICashFlowSchemaSection | ICashFlowStatementSection)[] => {
+    return this.reduceNodesDeep(
+      sections,
+      (acc, value, key, parentValue, context) => {
+        set(
+          acc,
+          context.path,
+          this.schemaSectionTotalParser(value, key, parentValue, context, acc)
+        );
+        return acc;
+      },
+      []
+    );
+  };
+
+  // --------------------------------------------
+  // REPORT FILTERING
+  // --------------------------------------------
+  /**
+   * Detarmines the given section has children and not empty.
+   * @param   {ICashFlowStatementSection} section
+   * @returns {boolean}
+   */
+  private isSectionHasChildren = (
+    section: ICashFlowStatementSection
+  ): boolean => {
+    return !isEmpty(section.children);
+  };
+
+  /**
+   * Detarmines whether the section has no zero amount.
+   * @param   {ICashFlowStatementSection} section
+   * @returns {boolean}
+   */
+  private isSectionNoneZero = (section: ICashFlowStatementSection): boolean => {
+    return section.total.amount !== 0;
+  };
+
+  /**
+   * Detarmines whether the parent accounts sections has children.
+   * @param   {ICashFlowStatementSection} section
+   * @returns {boolean}
+   */
+  private isAccountsSectionHasChildren = (
+    section: ICashFlowStatementSection[]
+  ): boolean => {
+    return R.ifElse(
+      this.isSchemaSectionType(ICashFlowStatementSectionType.ACCOUNTS),
+      this.isSectionHasChildren,
+      R.always(true)
+    )(section);
+  };
+
+  /**
+   * Detarmines the account section has no zero otherwise returns true.
+   * @param   {ICashFlowStatementSection} section
+   * @returns {boolean}
+   */
+  private isAccountLeafNoneZero = (
+    section: ICashFlowStatementSection[]
+  ): boolean => {
+    return R.ifElse(
+      this.isSchemaSectionType(ICashFlowStatementSectionType.ACCOUNT),
+      this.isSectionNoneZero,
+      R.always(true)
+    )(section);
+  };
+
+  /**
+   * Deep filters the non-zero accounts leafs of the report sections.
+   * @param   {ICashFlowStatementSection[]} sections
+   * @returns {ICashFlowStatementSection[]}
+   */
+  private filterNoneZeroAccountsLeafs = (
+    sections: ICashFlowStatementSection[]
+  ): ICashFlowStatementSection[] => {
+    return this.filterNodesDeep(sections, this.isAccountLeafNoneZero);
+  };
+
+  /**
+   * Deep filter the non-children sections of the report sections.
+   * @param   {ICashFlowStatementSection[]} sections
+   * @returns {ICashFlowStatementSection[]}
+   */
+  private filterNoneChildrenSections = (
+    sections: ICashFlowStatementSection[]
+  ): ICashFlowStatementSection[] => {
+    return this.filterNodesDeep(sections, this.isAccountsSectionHasChildren);
+  };
+
+  /**
+   * Filters the report data.
+   * @param   {ICashFlowStatementSection[]} sections
+   * @returns {ICashFlowStatementSection[]}
+   */
+  private filterReportData = (
+    sections: ICashFlowStatementSection[]
+  ): ICashFlowStatementSection[] => {
+    return R.compose(
+      this.filterNoneChildrenSections,
+      this.filterNoneZeroAccountsLeafs
+    )(sections);
+  };
+
+  /**
+   * Schema parser.
+   * @param   {ICashFlowSchemaSection[]} schema
+   * @returns {ICashFlowSchemaSection[]}
+   */
+  private schemaParser = (
+    schema: ICashFlowSchemaSection[]
+  ): ICashFlowSchemaSection[] => {
+    return R.compose(
+      R.when(
+        R.always(this.query.noneTransactions || this.query.noneZero),
+        this.filterReportData
+      ),
+      this.totalSectionsParser,
+      this.schemaSectionsParser
+    )(schema);
+  };
+
+  /**
+   * Retrieve the cashflow statement data.
+   * @return {ICashFlowStatementData}
+   */
+  public reportData = (): ICashFlowStatementData => {
+    return this.schemaParser(R.clone(CASH_FLOW_SCHEMA));
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/CashFlow/CashFlowDatePeriods.ts b/packages/server/src/services/FinancialStatements/CashFlow/CashFlowDatePeriods.ts
new file mode 100644
index 000000000..864180b26
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/CashFlow/CashFlowDatePeriods.ts
@@ -0,0 +1,411 @@
+import * as R from 'ramda';
+import { sumBy, mapValues, get } from 'lodash';
+import { ACCOUNT_ROOT_TYPE } from '@/data/AccountTypes';
+import { accumSum, dateRangeFromToCollection } from 'utils';
+import {
+  ICashFlowDatePeriod,
+  ICashFlowStatementNetIncomeSection,
+  ICashFlowStatementAccountSection,
+  ICashFlowStatementSection,
+  ICashFlowSchemaTotalSection,
+  IFormatNumberSettings,
+  ICashFlowStatementTotalSection,
+  IDateRange,
+  ICashFlowStatementQuery,
+} from '@/interfaces';
+
+export const CashFlowStatementDatePeriods = (Base) =>
+  class extends Base {
+    dateRangeSet: IDateRange[];
+    query: ICashFlowStatementQuery;
+
+    /**
+     * Initialize date range set.
+     */
+    private initDateRangeCollection() {
+      this.dateRangeSet = dateRangeFromToCollection(
+        this.query.fromDate,
+        this.query.toDate,
+        this.comparatorDateType
+      );
+    }
+
+    /**
+     * Retrieve the date period meta.
+     * @param {number} total - Total amount.
+     * @param {Date} fromDate - From date.
+     * @param {Date} toDate -  To date.
+     * @return {ICashFlowDatePeriod}
+     */
+    private getDatePeriodTotalMeta = (
+      total: number,
+      fromDate: Date,
+      toDate: Date,
+      overrideSettings: IFormatNumberSettings = {}
+    ): ICashFlowDatePeriod => {
+      return this.getDatePeriodMeta(total, fromDate, toDate, {
+        money: true,
+        ...overrideSettings,
+      });
+    };
+
+    /**
+     * Retrieve the date period meta.
+     * @param {number} total - Total amount.
+     * @param {Date} fromDate - From date.
+     * @param {Date} toDate -  To date.
+     * @return {ICashFlowDatePeriod}
+     */
+    private getDatePeriodMeta = (
+      total: number,
+      fromDate: Date,
+      toDate: Date,
+      overrideSettings?: IFormatNumberSettings
+    ): ICashFlowDatePeriod => {
+      return {
+        fromDate: this.getDateMeta(fromDate),
+        toDate: this.getDateMeta(toDate),
+        total: this.getAmountMeta(total, overrideSettings),
+      };
+    };
+
+    // Net income --------------------
+    /**
+     * Retrieve the net income between the given date range.
+     * @param {Date} fromDate
+     * @param {Date} toDate
+     * @returns {number}
+     */
+    private getNetIncomeDateRange = (fromDate: Date, toDate: Date) => {
+      // Mapping income/expense accounts ids.
+      const incomeAccountsIds = this.getAccountsIdsByType(
+        ACCOUNT_ROOT_TYPE.INCOME
+      );
+      const expenseAccountsIds = this.getAccountsIdsByType(
+        ACCOUNT_ROOT_TYPE.EXPENSE
+      );
+      // Income closing balance.
+      const incomeClosingBalance = accumSum(incomeAccountsIds, (id) =>
+        this.netIncomeLedger
+          .whereFromDate(fromDate)
+          .whereToDate(toDate)
+          .whereAccountId(id)
+          .getClosingBalance()
+      );
+      // Expense closing balance.
+      const expenseClosingBalance = accumSum(expenseAccountsIds, (id) =>
+        this.netIncomeLedger
+          .whereToDate(toDate)
+          .whereFromDate(fromDate)
+          .whereAccountId(id)
+          .getClosingBalance()
+      );
+      // Net income = income - expenses.
+      const netIncome = incomeClosingBalance - expenseClosingBalance;
+
+      return netIncome;
+    };
+
+    /**
+     * Retrieve the net income of date period.
+     * @param {IDateRange} dateRange -
+     * @retrun {ICashFlowDatePeriod}
+     */
+    private getNetIncomeDatePeriod = (dateRange): ICashFlowDatePeriod => {
+      const total = this.getNetIncomeDateRange(
+        dateRange.fromDate,
+        dateRange.toDate
+      );
+      return this.getDatePeriodMeta(
+        total,
+        dateRange.fromDate,
+        dateRange.toDate
+      );
+    };
+
+    /**
+     * Retrieve the net income node between the given date ranges.
+     * @param {Date} fromDate
+     * @param {Date} toDate
+     * @returns {ICashFlowDatePeriod[]}
+     */
+    private getNetIncomeDatePeriods = (
+      section: ICashFlowStatementNetIncomeSection
+    ): ICashFlowDatePeriod[] => {
+      return this.dateRangeSet.map(this.getNetIncomeDatePeriod.bind(this));
+    };
+
+    /**
+     * Writes periods property to net income section.
+     * @param {ICashFlowStatementNetIncomeSection} section
+     * @returns {ICashFlowStatementNetIncomeSection}
+     */
+    protected assocPeriodsToNetIncomeNode = (
+      section: ICashFlowStatementNetIncomeSection
+    ): ICashFlowStatementNetIncomeSection => {
+      const incomeDatePeriods = this.getNetIncomeDatePeriods(section);
+      return R.assoc('periods', incomeDatePeriods, section);
+    };
+
+    // Account nodes --------------------
+    /**
+     * Retrieve the account total between date range.
+     * @param {Date} fromDate - From date.
+     * @param {Date} toDate - To date.
+     * @return {number}
+     */
+    private getAccountTotalDateRange = (
+      node: ICashFlowStatementAccountSection,
+      fromDate: Date,
+      toDate: Date
+    ): number => {
+      const closingBalance = this.ledger
+        .whereFromDate(fromDate)
+        .whereToDate(toDate)
+        .whereAccountId(node.id)
+        .getClosingBalance();
+
+      return this.amountAdjustment(node.adjusmentType, closingBalance);
+    };
+
+    /**
+     * Retrieve the given account node total date period.
+     * @param {ICashFlowStatementAccountSection} node -
+     * @param {Date} fromDate - From date.
+     * @param {Date} toDate - To date.
+     * @return {ICashFlowDatePeriod}
+     */
+    private getAccountTotalDatePeriod = (
+      node: ICashFlowStatementAccountSection,
+      fromDate: Date,
+      toDate: Date
+    ): ICashFlowDatePeriod => {
+      const total = this.getAccountTotalDateRange(node, fromDate, toDate);
+      return this.getDatePeriodMeta(total, fromDate, toDate);
+    };
+
+    /**
+     * Retrieve the accounts date periods nodes of the give account node.
+     * @param {ICashFlowStatementAccountSection} node -
+     * @return {ICashFlowDatePeriod[]}
+     */
+    private getAccountDatePeriods = (
+      node: ICashFlowStatementAccountSection
+    ): ICashFlowDatePeriod[] => {
+      return this.getNodeDatePeriods(
+        node,
+        this.getAccountTotalDatePeriod.bind(this)
+      );
+    }
+
+    /**
+     * Writes `periods` property to account node.
+     * @param {ICashFlowStatementAccountSection} node -
+     * @return {ICashFlowStatementAccountSection}
+     */
+    protected assocPeriodsToAccountNode = (
+      node: ICashFlowStatementAccountSection
+    ): ICashFlowStatementAccountSection => {
+      const datePeriods = this.getAccountDatePeriods(node);
+      return R.assoc('periods', datePeriods, node);
+    }
+
+    // Aggregate node -------------------------
+    /**
+     * Retrieve total of the given period index for node that has children nodes.
+     * @return {number}
+     */
+    private getChildrenTotalPeriodByIndex = (
+      node: ICashFlowStatementSection,
+      index: number
+    ): number => {
+      return sumBy(node.children, `periods[${index}].total.amount`);
+    }
+
+    /**
+     * Retrieve date period meta of the given node index.
+     * @param {ICashFlowStatementSection} node -
+     * @param {number} index - Loop index.
+     * @param {Date} fromDate - From date.
+     * @param {Date} toDate - To date.
+     */
+    private getChildrenTotalPeriodMetaByIndex(
+      node: ICashFlowStatementSection,
+      index: number,
+      fromDate: Date,
+      toDate: Date
+    ) {
+      const total = this.getChildrenTotalPeriodByIndex(node, index);
+      return this.getDatePeriodTotalMeta(total, fromDate, toDate);
+    }
+
+    /**
+     * Retrieve the date periods of aggregate node.
+     * @param {ICashFlowStatementSection} node
+     */
+    private getAggregateNodeDatePeriods(node: ICashFlowStatementSection) {
+      const getChildrenTotalPeriodMetaByIndex = R.curry(
+        this.getChildrenTotalPeriodMetaByIndex.bind(this)
+      )(node);
+
+      return this.dateRangeSet.map((dateRange, index) =>
+        getChildrenTotalPeriodMetaByIndex(
+          index,
+          dateRange.fromDate,
+          dateRange.toDate
+        )
+      );
+    }
+
+    /**
+     * Writes `periods` property to aggregate section node.
+     * @param {ICashFlowStatementSection} node -
+     * @return {ICashFlowStatementSection}
+     */
+    protected assocPeriodsToAggregateNode = (
+      node: ICashFlowStatementSection
+    ): ICashFlowStatementSection => {
+      const datePeriods = this.getAggregateNodeDatePeriods(node);
+      return R.assoc('periods', datePeriods, node);
+    };
+
+    // Total equation node --------------------
+
+    private sectionsMapToTotalPeriod = (
+      mappedSections: { [key: number]: any },
+      index
+    ) => {
+      return mapValues(
+        mappedSections,
+        (node) => get(node, `periods[${index}].total.amount`) || 0
+      );
+    };
+
+    /**
+     * Retrieve the date periods of the given total equation.
+     * @param {ICashFlowSchemaTotalSection}
+     * @param {string} equation -
+     * @return {ICashFlowDatePeriod[]}
+     */
+    private getTotalEquationDatePeriods = (
+      node: ICashFlowSchemaTotalSection,
+      equation: string,
+      nodesTable
+    ): ICashFlowDatePeriod[] => {
+      return this.getNodeDatePeriods(node, (node, fromDate, toDate, index) => {
+        const periodScope = this.sectionsMapToTotalPeriod(nodesTable, index);
+        const total = this.evaluateEquation(equation, periodScope);
+
+        return this.getDatePeriodTotalMeta(total, fromDate, toDate);
+      });
+    };
+
+    /**
+     * Associates the total periods of total equation to the ginve total node..
+     * @param {ICashFlowSchemaTotalSection} totalSection -
+     * @return {ICashFlowStatementTotalSection}
+     */
+    protected assocTotalEquationDatePeriods = (
+      nodesTable: any,
+      equation: string,
+      node: ICashFlowSchemaTotalSection
+    ): ICashFlowStatementTotalSection => {
+      const datePeriods = this.getTotalEquationDatePeriods(
+        node,
+        equation,
+        nodesTable
+      );
+
+      return R.assoc('periods', datePeriods, node);
+    };
+
+    // Cash at beginning ----------------------
+
+    /**
+     * Retrieve the date preioods of the given node and accumlated function.
+     * @param {} node
+     * @param {}
+     * @return {}
+     */
+    private getNodeDatePeriods = (node, callback) => {
+      const curriedCallback = R.curry(callback)(node);
+
+      return this.dateRangeSet.map((dateRange, index) => {
+        return curriedCallback(dateRange.fromDate, dateRange.toDate, index);
+      });
+    };
+
+    /**
+     * Retrieve the account total between date range.
+     * @param {Date} fromDate - From date.
+     * @param {Date} toDate - To date.
+     * @return {number}
+     */
+    private getBeginningCashAccountDateRange = (
+      node: ICashFlowStatementSection,
+      fromDate: Date,
+      toDate: Date
+    ) => {
+      const cashToDate = this.beginningCashFrom(fromDate);
+
+      return this.cashLedger
+        .whereToDate(cashToDate)
+        .whereAccountId(node.id)
+        .getClosingBalance();
+    };
+
+    /**
+     * Retrieve the beginning cash date period.
+     * @param {ICashFlowStatementSection} node -
+     * @param {Date} fromDate - From date.
+     * @param {Date} toDate - To date.
+     * @return {ICashFlowDatePeriod}
+     */
+    private getBeginningCashDatePeriod = (
+      node: ICashFlowStatementSection,
+      fromDate: Date,
+      toDate: Date
+    ) => {
+      const total = this.getBeginningCashAccountDateRange(
+        node,
+        fromDate,
+        toDate
+      );
+      return this.getDatePeriodTotalMeta(total, fromDate, toDate);
+    };
+
+    /**
+     * Retrieve the beginning cash account periods.
+     * @param {ICashFlowStatementSection} node
+     * @return {ICashFlowDatePeriod}
+     */
+    private getBeginningCashAccountPeriods = (
+      node: ICashFlowStatementSection
+    ): ICashFlowDatePeriod => {
+      return this.getNodeDatePeriods(node, this.getBeginningCashDatePeriod);
+    };
+
+    /**
+     * Writes `periods` property to cash at beginning date periods.
+     * @param {ICashFlowStatementSection} section -
+     * @return {ICashFlowStatementSection}
+     */
+    protected assocCashAtBeginningDatePeriods = (
+      node: ICashFlowStatementSection
+    ): ICashFlowStatementSection => {
+      const datePeriods = this.getAggregateNodeDatePeriods(node);
+      return R.assoc('periods', datePeriods, node);
+    };
+
+    /**
+     * Associates `periods` propery to cash at beginning account node.
+     * @param {ICashFlowStatementSection} node -
+     * @return {ICashFlowStatementSection}
+     */
+    protected assocCashAtBeginningAccountDatePeriods = (
+      node: ICashFlowStatementSection
+    ): ICashFlowStatementSection => {
+      const datePeriods = this.getBeginningCashAccountPeriods(node);
+      return R.assoc('periods', datePeriods, node);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/CashFlow/CashFlowRepository.ts b/packages/server/src/services/FinancialStatements/CashFlow/CashFlowRepository.ts
new file mode 100644
index 000000000..d7e7532ac
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/CashFlow/CashFlowRepository.ts
@@ -0,0 +1,173 @@
+import { Inject, Service } from 'typedi';
+import moment from 'moment';
+import { Knex } from 'knex';
+import { isEmpty } from 'lodash';
+import {
+  ICashFlowStatementQuery,
+  IAccountTransaction,
+  IAccount,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export default class CashFlowRepository {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve the group type from periods type.
+   * @param {string} displayType
+   * @returns {string}
+   */
+  protected getGroupTypeFromPeriodsType(displayType: string) {
+    const displayTypes = {
+      year: 'year',
+      day: 'day',
+      month: 'month',
+      quarter: 'month',
+      week: 'day',
+    };
+    return displayTypes[displayType] || 'month';
+  }
+
+  /**
+   * Retrieve the cashflow accounts.
+   * @returns {Promise<IAccount[]>}
+   */
+  public async cashFlowAccounts(tenantId: number): Promise<IAccount[]> {
+    const { Account } = this.tenancy.models(tenantId);
+
+    const accounts = await Account.query();
+
+    return accounts;
+  }
+
+  /**
+   * Retrieve total of csah at beginning transactions.
+   * @param {number} tenantId -
+   * @param {ICashFlowStatementQuery} filter -
+   * @return {Promise<IAccountTransaction[]>}
+   */
+  public cashAtBeginningTotalTransactions(
+    tenantId: number,
+    filter: ICashFlowStatementQuery
+  ): Promise<IAccountTransaction[]> {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+    const cashBeginningPeriod = moment(filter.fromDate)
+      .subtract(1, 'day')
+      .toDate();
+
+    return AccountTransaction.query().onBuild((query) => {
+      query.modify('creditDebitSummation');
+
+      query.select('accountId');
+      query.groupBy('accountId');
+
+      query.withGraphFetched('account');
+      query.modify('filterDateRange', null, cashBeginningPeriod);
+
+      this.commonFilterBranchesQuery(filter, query);
+    });
+  }
+
+  /**
+   * Retrieve accounts transactions.
+   * @param {number} tenantId -
+   * @param {ICashFlowStatementQuery} filter
+   * @return {Promise<IAccountTransaction>}
+   */
+  public getAccountsTransactions(
+    tenantId: number,
+    filter: ICashFlowStatementQuery
+  ): Promise<IAccountTransaction[]> {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+    const groupByDateType = this.getGroupTypeFromPeriodsType(
+      filter.displayColumnsBy
+    );
+
+    return AccountTransaction.query().onBuild((query) => {
+      query.modify('creditDebitSummation');
+      query.modify('groupByDateFormat', groupByDateType);
+
+      query.select('accountId');
+
+      query.groupBy('accountId');
+      query.withGraphFetched('account');
+
+      query.modify('filterDateRange', filter.fromDate, filter.toDate);
+
+      this.commonFilterBranchesQuery(filter, query);
+    });
+  }
+
+  /**
+   * Retrieve the net income tranasctions.
+   * @param {number} tenantId -
+   * @param {ICashFlowStatementQuery} query -
+   * @return {Promise<IAccountTransaction[]>}
+   */
+  public getNetIncomeTransactions(
+    tenantId: number,
+    filter: ICashFlowStatementQuery
+  ): Promise<IAccountTransaction[]> {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+    const groupByDateType = this.getGroupTypeFromPeriodsType(
+      filter.displayColumnsBy
+    );
+
+    return AccountTransaction.query().onBuild((query) => {
+      query.modify('creditDebitSummation');
+      query.modify('groupByDateFormat', groupByDateType);
+
+      query.select('accountId');
+      query.groupBy('accountId');
+
+      query.withGraphFetched('account');
+      query.modify('filterDateRange', filter.fromDate, filter.toDate);
+
+      this.commonFilterBranchesQuery(filter, query);
+    });
+  }
+
+  /**
+   * Retrieve peridos of cash at beginning transactions.
+   * @param {number} tenantId -
+   * @param {ICashFlowStatementQuery} filter -
+   * @return {Promise<IAccountTransaction[]>}
+   */
+  public cashAtBeginningPeriodTransactions(
+    tenantId: number,
+    filter: ICashFlowStatementQuery
+  ): Promise<IAccountTransaction[]> {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+    const groupByDateType = this.getGroupTypeFromPeriodsType(
+      filter.displayColumnsBy
+    );
+
+    return AccountTransaction.query().onBuild((query) => {
+      query.modify('creditDebitSummation');
+      query.modify('groupByDateFormat', groupByDateType);
+
+      query.select('accountId');
+      query.groupBy('accountId');
+
+      query.withGraphFetched('account');
+      query.modify('filterDateRange', filter.fromDate, filter.toDate);
+
+      this.commonFilterBranchesQuery(filter, query);
+    });
+  }
+
+  /**
+   * Common branches filter query.
+   * @param {Knex.QueryBuilder} query
+   */
+  private commonFilterBranchesQuery = (
+    query: ICashFlowStatementQuery,
+    knexQuery: Knex.QueryBuilder
+  ) => {
+    if (!isEmpty(query.branchesIds)) {
+      knexQuery.modify('filterByBranches', query.branchesIds);
+    }
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/CashFlow/CashFlowService.ts b/packages/server/src/services/FinancialStatements/CashFlow/CashFlowService.ts
new file mode 100644
index 000000000..58fd5d2ad
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/CashFlow/CashFlowService.ts
@@ -0,0 +1,175 @@
+import moment from 'moment';
+import { Service, Inject } from 'typedi';
+import * as R from 'ramda';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import FinancialSheet from '../FinancialSheet';
+import {
+  ICashFlowStatementService,
+  ICashFlowStatementQuery,
+  ICashFlowStatementDOO,
+  IAccountTransaction,
+  ICashFlowStatementMeta
+} from '@/interfaces';
+import CashFlowStatement from './CashFlow';
+import Ledger from '@/services/Accounting/Ledger';
+import CashFlowRepository from './CashFlowRepository';
+import InventoryService from '@/services/Inventory/Inventory';
+import { parseBoolean } from 'utils';
+import { Tenant } from '@/system/models';
+
+@Service()
+export default class CashFlowStatementService
+  extends FinancialSheet
+  implements ICashFlowStatementService
+{
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  cashFlowRepo: CashFlowRepository;
+
+  @Inject()
+  inventoryService: InventoryService;
+
+  /**
+   * Defaults balance sheet filter query.
+   * @return {IBalanceSheetQuery}
+   */
+  get defaultQuery(): ICashFlowStatementQuery {
+    return {
+      displayColumnsType: 'total',
+      displayColumnsBy: 'day',
+      fromDate: moment().startOf('year').format('YYYY-MM-DD'),
+      toDate: moment().endOf('year').format('YYYY-MM-DD'),
+      numberFormat: {
+        precision: 2,
+        divideOn1000: false,
+        showZero: false,
+        formatMoney: 'total',
+        negativeFormat: 'mines',
+      },
+      noneZero: false,
+      noneTransactions: false,
+      basis: 'cash',
+    };
+  }
+
+  /**
+   * Retrieve cash at beginning transactions.
+   * @param {number} tenantId -
+   * @param {ICashFlowStatementQuery} filter -
+   * @retrun {Promise<IAccountTransaction[]>}
+   */
+  private async cashAtBeginningTransactions(
+    tenantId: number,
+    filter: ICashFlowStatementQuery
+  ): Promise<IAccountTransaction[]> {
+    const appendPeriodsOperToChain = (trans) =>
+      R.append(
+        this.cashFlowRepo.cashAtBeginningPeriodTransactions(tenantId, filter),
+        trans
+      );
+
+    const promisesChain = R.pipe(
+      R.append(
+        this.cashFlowRepo.cashAtBeginningTotalTransactions(tenantId, filter)
+      ),
+      R.when(
+        R.always(R.equals(filter.displayColumnsType, 'date_periods')),
+        appendPeriodsOperToChain
+      )
+    )([]);
+    const promisesResults = await Promise.all(promisesChain);
+    const transactions = R.flatten(promisesResults);
+
+    return transactions;
+  }
+
+  /**
+   * Retrieve the cash flow sheet statement.
+   * @param {number} tenantId
+   * @param {ICashFlowStatementQuery} query
+   * @returns {Promise<ICashFlowStatementDOO>}
+   */
+  public async cashFlow(
+    tenantId: number,
+    query: ICashFlowStatementQuery
+  ): Promise<ICashFlowStatementDOO> {
+    const i18n = this.tenancy.i18n(tenantId);
+
+    // Retrieve all accounts on the storage.
+    const accounts = await this.cashFlowRepo.cashFlowAccounts(tenantId);
+
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const filter = {
+      ...this.defaultQuery,
+      ...query,
+    };
+    // Retrieve the accounts transactions.
+    const transactions = await this.cashFlowRepo.getAccountsTransactions(
+      tenantId,
+      filter
+    );
+    // Retrieve the net income transactions.
+    const netIncome = await this.cashFlowRepo.getNetIncomeTransactions(
+      tenantId,
+      filter
+    );
+    // Retrieve the cash at beginning transactions.
+    const cashAtBeginningTransactions = await this.cashAtBeginningTransactions(
+      tenantId,
+      filter
+    );
+    // Transformes the transactions to ledgers.
+    const ledger = Ledger.fromTransactions(transactions);
+    const cashLedger = Ledger.fromTransactions(cashAtBeginningTransactions);
+    const netIncomeLedger = Ledger.fromTransactions(netIncome);
+
+    // Cash flow statement.
+    const cashFlowInstance = new CashFlowStatement(
+      accounts,
+      ledger,
+      cashLedger,
+      netIncomeLedger,
+      filter,
+      tenant.metadata.baseCurrency,
+      i18n
+    );
+
+    return {
+      data: cashFlowInstance.reportData(),
+      query: filter,
+      meta: this.reportMetadata(tenantId),
+    };
+  }
+
+    /**
+   * Retrieve the balance sheet meta.
+   * @param {number} tenantId - 
+   * @returns {ICashFlowStatementMeta}
+   */
+     private reportMetadata(tenantId: number): ICashFlowStatementMeta {
+      const settings = this.tenancy.settings(tenantId);
+  
+      const isCostComputeRunning = this.inventoryService
+        .isItemsCostComputeRunning(tenantId);
+  
+      const organizationName = settings.get({
+        group: 'organization',
+        key: 'name',
+      });
+      const baseCurrency = settings.get({
+        group: 'organization',
+        key: 'base_currency',
+      });
+  
+      return {
+        isCostComputeRunning: parseBoolean(isCostComputeRunning, false),
+        organizationName,
+        baseCurrency
+      };
+    }
+}
diff --git a/packages/server/src/services/FinancialStatements/CashFlow/CashFlowTable.ts b/packages/server/src/services/FinancialStatements/CashFlow/CashFlowTable.ts
new file mode 100644
index 000000000..b3470e1a4
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/CashFlow/CashFlowTable.ts
@@ -0,0 +1,373 @@
+import * as R from 'ramda';
+import { isEmpty, times } from 'lodash';
+import moment from 'moment';
+import {
+  ICashFlowStatementSection,
+  ICashFlowStatementSectionType,
+  ICashFlowStatement,
+  ITableRow,
+  ITableColumn,
+  ICashFlowStatementQuery,
+  IDateRange,
+  ICashFlowStatementDOO,
+} from '@/interfaces';
+import { dateRangeFromToCollection, tableRowMapper } from 'utils';
+import { mapValuesDeep } from 'utils/deepdash';
+
+enum IROW_TYPE {
+  AGGREGATE = 'AGGREGATE',
+  NET_INCOME = 'NET_INCOME',
+  ACCOUNTS = 'ACCOUNTS',
+  ACCOUNT = 'ACCOUNT',
+  TOTAL = 'TOTAL',
+}
+const DEEP_CONFIG = { childrenPath: 'children', pathFormat: 'array' };
+const DISPLAY_COLUMNS_BY = {
+  DATE_PERIODS: 'date_periods',
+  TOTAL: 'total',
+};
+
+export default class CashFlowTable implements ICashFlowTable {
+  private report: ICashFlowStatementDOO;
+  private i18n;
+  private dateRangeSet: IDateRange[];
+
+  /**
+   * Constructor method.
+   * @param {ICashFlowStatement} reportStatement
+   */
+  constructor(reportStatement: ICashFlowStatementDOO, i18n) {
+    this.report = reportStatement;
+    this.i18n = i18n;
+    this.dateRangeSet = [];
+    this.initDateRangeCollection();
+  }
+
+  /**
+   * Initialize date range set.
+   */
+  private initDateRangeCollection() {
+    this.dateRangeSet = dateRangeFromToCollection(
+      this.report.query.fromDate,
+      this.report.query.toDate,
+      this.report.query.displayColumnsBy
+    );
+  }
+
+  /**
+   * Retrieve the date periods columns accessors.
+   */
+  private datePeriodsColumnsAccessors = () => {
+    return this.dateRangeSet.map((dateRange: IDateRange, index) => ({
+      key: `date-range-${index}`,
+      accessor: `periods[${index}].total.formattedAmount`,
+    }));
+  };
+
+  /**
+   * Retrieve the total column accessor.
+   */
+  private totalColumnAccessor = () => {
+    return [{ key: 'total', accessor: 'total.formattedAmount' }];
+  };
+
+  /**
+   * Retrieve the common columns for all report nodes.
+   */
+  private commonColumns = () => {
+    return R.compose(
+      R.concat([{ key: 'label', accessor: 'label' }]),
+      R.when(
+        R.always(this.isDisplayColumnsBy(DISPLAY_COLUMNS_BY.DATE_PERIODS)),
+        R.concat(this.datePeriodsColumnsAccessors())
+      ),
+      R.concat(this.totalColumnAccessor())
+    )([]);
+  };
+
+  /**
+   * Retrieve the table rows of regular section.
+   * @param {ICashFlowStatementSection} section
+   * @returns {ITableRow[]}
+   */
+  private regularSectionMapper = (
+    section: ICashFlowStatementSection
+  ): ITableRow => {
+    const columns = this.commonColumns();
+
+    return tableRowMapper(section, columns, {
+      rowTypes: [IROW_TYPE.AGGREGATE],
+      id: section.id,
+    });
+  };
+
+  /**
+   * Retrieve the net income table rows of the section.
+   * @param {ICashFlowStatementSection} section
+   * @returns {ITableRow}
+   */
+  private netIncomeSectionMapper = (
+    section: ICashFlowStatementSection
+  ): ITableRow => {
+    const columns = this.commonColumns();
+
+    return tableRowMapper(section, columns, {
+      rowTypes: [IROW_TYPE.NET_INCOME, IROW_TYPE.TOTAL],
+      id: section.id,
+    });
+  };
+
+  /**
+   * Retrieve the accounts table rows of the section.
+   * @param {ICashFlowStatementSection} section
+   * @returns {ITableRow}
+   */
+  private accountsSectionMapper = (
+    section: ICashFlowStatementSection
+  ): ITableRow => {
+    const columns = this.commonColumns();
+
+    return tableRowMapper(section, columns, {
+      rowTypes: [IROW_TYPE.ACCOUNTS],
+      id: section.id,
+    });
+  };
+
+  /**
+   * Retrieve the account table row of account section.
+   * @param {ICashFlowStatementSection} section
+   * @returns {ITableRow}
+   */
+  private accountSectionMapper = (
+    section: ICashFlowStatementSection
+  ): ITableRow => {
+    const columns = this.commonColumns();
+
+    return tableRowMapper(section, columns, {
+      rowTypes: [IROW_TYPE.ACCOUNT],
+      id: `account-${section.id}`,
+    });
+  };
+
+  /**
+   * Retrieve the total table rows from the given total section.
+   * @param {ICashFlowStatementSection} section
+   * @returns {ITableRow}
+   */
+  private totalSectionMapper = (
+    section: ICashFlowStatementSection
+  ): ITableRow => {
+    const columns = this.commonColumns();
+
+    return tableRowMapper(section, columns, {
+      rowTypes: [IROW_TYPE.TOTAL],
+      id: section.id,
+    });
+  };
+
+  /**
+   * Detarmines the schema section type.
+   * @param {string} type
+   * @param {ICashFlowSchemaSection} section
+   * @returns {boolean}
+   */
+  private isSectionHasType = (
+    type: string,
+    section: ICashFlowStatementSection
+  ): boolean => {
+    return type === section.sectionType;
+  };
+
+  /**
+   * The report section mapper.
+   * @param {ICashFlowStatementSection} section
+   * @returns {ITableRow}
+   */
+  private sectionMapper = (
+    section: ICashFlowStatementSection,
+    key: string,
+    parentSection: ICashFlowStatementSection
+  ): ITableRow => {
+    const isSectionHasType = R.curry(this.isSectionHasType);
+
+    return R.pipe(
+      R.when(
+        isSectionHasType(ICashFlowStatementSectionType.AGGREGATE),
+        this.regularSectionMapper
+      ),
+      R.when(
+        isSectionHasType(ICashFlowStatementSectionType.CASH_AT_BEGINNING),
+        this.regularSectionMapper
+      ),
+      R.when(
+        isSectionHasType(ICashFlowStatementSectionType.NET_INCOME),
+        this.netIncomeSectionMapper
+      ),
+      R.when(
+        isSectionHasType(ICashFlowStatementSectionType.ACCOUNTS),
+        this.accountsSectionMapper
+      ),
+      R.when(
+        isSectionHasType(ICashFlowStatementSectionType.ACCOUNT),
+        this.accountSectionMapper
+      ),
+      R.when(
+        isSectionHasType(ICashFlowStatementSectionType.TOTAL),
+        this.totalSectionMapper
+      )
+    )(section);
+  };
+
+  /**
+   * Mappes the sections to the table rows.
+   * @param {ICashFlowStatementSection[]} sections
+   * @returns {ITableRow[]}
+   */
+  private mapSectionsToTableRows = (
+    sections: ICashFlowStatementSection[]
+  ): ITableRow[] => {
+    return mapValuesDeep(sections, this.sectionMapper.bind(this), DEEP_CONFIG);
+  };
+
+  /**
+   * Appends the total to section's children.
+   * @param {ICashFlowStatementSection} section
+   * @returns {ICashFlowStatementSection}
+   */
+  private appendTotalToSectionChildren = (
+    section: ICashFlowStatementSection
+  ): ICashFlowStatementSection => {
+    const label = section.footerLabel
+      ? section.footerLabel
+      : this.i18n.__('Total {{accountName}}', { accountName: section.label });
+
+    section.children.push({
+      sectionType: ICashFlowStatementSectionType.TOTAL,
+      label,
+      periods: section.periods,
+      total: section.total,
+    });
+    return section;
+  };
+
+  /**
+   *
+   * @param {ICashFlowStatementSection} section
+   * @returns {ICashFlowStatementSection}
+   */
+  private mapSectionsToAppendTotalChildren = (
+    section: ICashFlowStatementSection
+  ): ICashFlowStatementSection => {
+    const isSectionHasChildren = (section) => !isEmpty(section.children);
+
+    return R.compose(
+      R.when(isSectionHasChildren, this.appendTotalToSectionChildren.bind(this))
+    )(section);
+  };
+
+  /**
+   * Appends total node to children section.
+   * @param {ICashFlowStatementSection[]} sections
+   * @returns {ICashFlowStatementSection[]}
+   */
+  private appendTotalToChildren = (sections: ICashFlowStatementSection[]) => {
+    return mapValuesDeep(
+      sections,
+      this.mapSectionsToAppendTotalChildren.bind(this),
+      DEEP_CONFIG
+    );
+  };
+
+  /**
+   * Retrieve the table rows of cash flow statement.
+   * @param {ICashFlowStatementSection[]} sections
+   * @returns {ITableRow[]}
+   */
+  public tableRows = (): ITableRow[] => {
+    const sections = this.report.data;
+
+    return R.pipe(
+      this.appendTotalToChildren,
+      this.mapSectionsToTableRows
+    )(sections);
+  };
+
+  /**
+   * Retrieve the total columns.
+   * @returns {ITableColumn}
+   */
+  private totalColumns = (): ITableColumn[] => {
+    return [{ key: 'total', label: this.i18n.__('Total') }];
+  };
+
+  /**
+   * Retrieve the formatted column label from the given date range.
+   * @param {ICashFlowDateRange} dateRange -
+   * @return {string}
+   */
+  private formatColumnLabel = (dateRange: ICashFlowDateRange) => {
+    const monthFormat = (range) => moment(range.toDate).format('YYYY-MM');
+    const yearFormat = (range) => moment(range.toDate).format('YYYY');
+    const dayFormat = (range) => moment(range.toDate).format('YYYY-MM-DD');
+
+    const conditions = [
+      ['month', monthFormat],
+      ['year', yearFormat],
+      ['day', dayFormat],
+      ['quarter', monthFormat],
+      ['week', dayFormat],
+    ];
+    const conditionsPairs = R.map(
+      ([type, formatFn]) => [
+        R.always(this.isDisplayColumnsType(type)),
+        formatFn,
+      ],
+      conditions
+    );
+
+    return R.compose(R.cond(conditionsPairs))(dateRange);
+  };
+
+  /**
+   * Date periods columns.
+   * @returns {ITableColumn[]}
+   */
+  private datePeriodsColumns = (): ITableColumn[] => {
+    return this.dateRangeSet.map((dateRange, index) => ({
+      key: `date-range-${index}`,
+      label: this.formatColumnLabel(dateRange),
+    }));
+  };
+
+  /**
+   * Detarmines the given column type is the current.
+   * @reutrns {boolean}
+   */
+  private isDisplayColumnsBy = (displayColumnsType: string): Boolean => {
+    return this.report.query.displayColumnsType === displayColumnsType;
+  };
+
+  /**
+   * Detarmines whether the given display columns type is the current.
+   * @param {string} displayColumnsBy
+   * @returns {boolean}
+   */
+  private isDisplayColumnsType = (displayColumnsBy: string): Boolean => {
+    return this.report.query.displayColumnsBy === displayColumnsBy;
+  };
+
+  /**
+   * Retrieve the table columns.
+   * @return {ITableColumn[]}
+   */
+  public tableColumns = (): ITableColumn[] => {
+    return R.compose(
+      R.concat([{ key: 'name', label: this.i18n.__('Account name') }]),
+      R.when(
+        R.always(this.isDisplayColumnsBy(DISPLAY_COLUMNS_BY.DATE_PERIODS)),
+        R.concat(this.datePeriodsColumns())
+      ),
+      R.concat(this.totalColumns())
+    )([]);
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/CashFlow/constants.ts b/packages/server/src/services/FinancialStatements/CashFlow/constants.ts
new file mode 100644
index 000000000..58a92ec19
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/CashFlow/constants.ts
@@ -0,0 +1,8 @@
+
+
+export const DISPLAY_COLUMNS_BY = {
+  DATE_PERIODS: 'date_periods',
+  TOTAL: 'total',
+};
+
+export const MAP_CONFIG = { childrenPath: 'children', pathFormat: 'array' };
\ No newline at end of file
diff --git a/packages/server/src/services/FinancialStatements/CashFlow/schema.ts b/packages/server/src/services/FinancialStatements/CashFlow/schema.ts
new file mode 100644
index 000000000..f12520e63
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/CashFlow/schema.ts
@@ -0,0 +1,75 @@
+import { ICashFlowSchemaSection, CASH_FLOW_SECTION_ID, ICashFlowStatementSectionType } from '@/interfaces';
+import { ACCOUNT_TYPE } from '@/data/AccountTypes';
+
+export default [
+  {
+    id: CASH_FLOW_SECTION_ID.OPERATING,
+    label: 'OPERATING ACTIVITIES',
+    sectionType: ICashFlowStatementSectionType.AGGREGATE,
+    children: [
+      {
+        id: CASH_FLOW_SECTION_ID.NET_INCOME,
+        label: 'Net income',
+        sectionType: ICashFlowStatementSectionType.NET_INCOME,
+      },
+      {
+        id: CASH_FLOW_SECTION_ID.OPERATING_ACCOUNTS,
+        label: 'Adjustments net income by operating activities.',
+        sectionType: ICashFlowStatementSectionType.ACCOUNTS,
+        accountsRelations: [
+          { type: ACCOUNT_TYPE.ACCOUNTS_RECEIVABLE, direction: 'mines' },
+          { type: ACCOUNT_TYPE.INVENTORY, direction: 'mines' },
+          { type: ACCOUNT_TYPE.NON_CURRENT_ASSET, direction: 'mines' },
+          { type: ACCOUNT_TYPE.ACCOUNTS_PAYABLE, direction: 'plus' },
+          { type: ACCOUNT_TYPE.CREDIT_CARD, direction: 'plus' },
+          { type: ACCOUNT_TYPE.TAX_PAYABLE, direction: 'plus' },
+          { type: ACCOUNT_TYPE.OTHER_CURRENT_ASSET, direction: 'mines' },
+          { type: ACCOUNT_TYPE.OTHER_CURRENT_LIABILITY, direction: 'plus' },
+          { type: ACCOUNT_TYPE.NON_CURRENT_LIABILITY, direction: 'plus' },
+        ],
+        showAlways: true,
+      },
+    ],
+    footerLabel: 'Net cash provided by operating activities',
+  },
+  {
+    id: CASH_FLOW_SECTION_ID.INVESTMENT,
+    sectionType: ICashFlowStatementSectionType.ACCOUNTS,
+    label: 'INVESTMENT ACTIVITIES',
+    accountsRelations: [
+      { type: ACCOUNT_TYPE.FIXED_ASSET, direction: 'mines' }
+    ],
+    footerLabel: 'Net cash provided by investing activities',
+  },
+  {
+    id: CASH_FLOW_SECTION_ID.FINANCIAL,
+    label: 'FINANCIAL ACTIVITIES',
+    sectionType: ICashFlowStatementSectionType.ACCOUNTS,
+    accountsRelations: [
+      { type: ACCOUNT_TYPE.LOGN_TERM_LIABILITY, direction: 'plus' },
+      { type: ACCOUNT_TYPE.EQUITY, direction: 'plus' },
+    ],
+    footerLabel: 'Net cash provided by financing activities',
+  },
+  {
+    id: CASH_FLOW_SECTION_ID.CASH_BEGINNING_PERIOD,
+    sectionType: ICashFlowStatementSectionType.CASH_AT_BEGINNING,
+    label: 'Cash at beginning of period',
+    accountsRelations: [
+      { type: ACCOUNT_TYPE.CASH, direction: 'plus' },
+      { type: ACCOUNT_TYPE.BANK, direction: 'plus' },
+    ],
+  },
+  {
+    id: CASH_FLOW_SECTION_ID.NET_CASH_INCREASE,
+    sectionType: ICashFlowStatementSectionType.TOTAL,
+    equation: 'OPERATING + INVESTMENT + FINANCIAL',
+    label: 'NET CASH INCREASE FOR PERIOD',
+  },
+  {
+    id: CASH_FLOW_SECTION_ID.CASH_END_PERIOD,
+    label: 'CASH AT END OF PERIOD',
+    sectionType: ICashFlowStatementSectionType.TOTAL,
+    equation: 'NET_CASH_INCREASE + CASH_BEGINNING_PERIOD',
+  },
+] as ICashFlowSchemaSection[];
diff --git a/packages/server/src/services/FinancialStatements/CashflowAccountTransactions/CashflowAccountTransactions.ts b/packages/server/src/services/FinancialStatements/CashflowAccountTransactions/CashflowAccountTransactions.ts
new file mode 100644
index 000000000..7fc1d00e2
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/CashflowAccountTransactions/CashflowAccountTransactions.ts
@@ -0,0 +1,151 @@
+import R from 'ramda';
+import moment from 'moment';
+import {
+  ICashflowAccountTransaction,
+  ICashflowAccountTransactionsQuery,
+  INumberFormatQuery,
+} from '@/interfaces';
+import FinancialSheet from '../FinancialSheet';
+import { runningAmount } from 'utils';
+
+export default class CashflowAccountTransactionReport extends FinancialSheet {
+  private transactions: any;
+  private openingBalance: number;
+  private runningBalance: any;
+  private numberFormat: INumberFormatQuery;
+  private baseCurrency: string;
+  private query: ICashflowAccountTransactionsQuery;
+
+  /**
+   * Constructor method.
+   * @param {IAccountTransaction[]} transactions -
+   * @param {number} openingBalance -
+   * @param {ICashflowAccountTransactionsQuery} query -
+   */
+  constructor(
+    transactions,
+    openingBalance: number,
+    query: ICashflowAccountTransactionsQuery
+  ) {
+    super();
+
+    this.transactions = transactions;
+    this.openingBalance = openingBalance;
+
+    this.runningBalance = runningAmount(this.openingBalance);
+    this.query = query;
+    this.numberFormat = query.numberFormat;
+    this.baseCurrency = 'USD';
+  }
+
+  /**
+   *Transformes the account transaction to to cashflow transaction node.
+   * @param {IAccountTransaction} transaction
+   * @returns {ICashflowAccountTransaction}
+   */
+  private transactionNode = (transaction: any): ICashflowAccountTransaction => {
+    return {
+      date: transaction.date,
+      formattedDate: moment(transaction.date).format('YYYY-MM-DD'),
+
+      withdrawal: transaction.credit,
+      deposit: transaction.debit,
+
+      formattedDeposit: this.formatNumber(transaction.debit),
+      formattedWithdrawal: this.formatNumber(transaction.credit),
+
+      referenceId: transaction.referenceId,
+      referenceType: transaction.referenceType,
+
+      formattedTransactionType: transaction.referenceTypeFormatted,
+
+      transactionNumber: transaction.transactionNumber,
+      referenceNumber: transaction.referenceNumber,
+
+      runningBalance: this.runningBalance.amount(),
+      formattedRunningBalance: this.formatNumber(this.runningBalance.amount()),
+
+      balance: 0,
+      formattedBalance: '',
+    };
+  };
+
+  /**
+   * Associate cashflow transaction node with running balance attribute.
+   * @param {IAccountTransaction} transaction
+   * @returns {ICashflowAccountTransaction}
+   */
+  private transactionRunningBalance = (
+    transaction: ICashflowAccountTransaction
+  ): ICashflowAccountTransaction => {
+    const amount = transaction.deposit - transaction.withdrawal;
+
+    const biggerThanZero = R.lt(0, amount);
+    const lowerThanZero = R.gt(0, amount);
+
+    const absAmount = Math.abs(amount);
+
+    R.when(R.always(biggerThanZero), this.runningBalance.decrement)(absAmount);
+    R.when(R.always(lowerThanZero), this.runningBalance.increment)(absAmount);
+
+    const runningBalance = this.runningBalance.amount();
+
+    return {
+      ...transaction,
+      runningBalance,
+      formattedRunningBalance: this.formatNumber(runningBalance),
+    };
+  };
+
+  /**
+   * Associate to balance attribute to cashflow transaction node.
+   * @param {ICashflowAccountTransaction} transaction
+   * @returns {ICashflowAccountTransaction}
+   */
+  private transactionBalance = (
+    transaction: ICashflowAccountTransaction
+  ): ICashflowAccountTransaction => {
+    const balance =
+      transaction.runningBalance +
+      transaction.withdrawal * -1 +
+      transaction.deposit;
+
+    return {
+      ...transaction,
+      balance,
+      formattedBalance: this.formatNumber(balance),
+    };
+  };
+
+  /**
+   * Transformes the given account transaction to cashflow report transaction.
+   * @param {ICashflowAccountTransaction} transaction
+   * @returns {ICashflowAccountTransaction}
+   */
+  private transactionTransformer = (
+    transaction
+  ): ICashflowAccountTransaction => {
+    return R.compose(
+      this.transactionBalance,
+      this.transactionRunningBalance,
+      this.transactionNode
+    )(transaction);
+  };
+
+  /**
+   * Retrieve the report transactions node.
+   * @param {} transactions
+   * @returns {ICashflowAccountTransaction[]}
+   */
+  private transactionsNode = (transactions): ICashflowAccountTransaction[] => {
+    return R.map(this.transactionTransformer)(transactions);
+  };
+
+  /**
+   * Retrieve the reprot data node.
+   * @returns {ICashflowAccountTransaction[]}
+   */
+  public reportData(): ICashflowAccountTransaction[] {
+    return this.transactionsNode(this.transactions);
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/CashflowAccountTransactions/CashflowAccountTransactionsRepo.ts b/packages/server/src/services/FinancialStatements/CashflowAccountTransactions/CashflowAccountTransactionsRepo.ts
new file mode 100644
index 000000000..55049836a
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/CashflowAccountTransactions/CashflowAccountTransactionsRepo.ts
@@ -0,0 +1,65 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ICashflowAccountTransactionsQuery, IPaginationMeta } from '@/interfaces';
+
+@Service()
+export default class CashflowAccountTransactionsRepo {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve the cashflow account transactions.
+   * @param {number} tenantId -
+   * @param {ICashflowAccountTransactionsQuery} query -
+   */
+  async getCashflowAccountTransactions(
+    tenantId: number,
+    query: ICashflowAccountTransactionsQuery
+  ) {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+
+    return AccountTransaction.query()
+      .where('account_id', query.accountId)
+      .orderBy([
+        { column: 'date', order: 'desc' },
+        { column: 'created_at', order: 'desc' },
+      ])
+      .pagination(query.page - 1, query.pageSize);
+  }
+
+  /**
+   * Retrieve the cashflow account opening balance.
+   * @param {number} tenantId
+   * @param {number} accountId
+   * @param {IPaginationMeta} pagination
+   * @return {Promise<number>}
+   */
+  async getCashflowAccountOpeningBalance(
+    tenantId: number,
+    accountId: number,
+    pagination: IPaginationMeta
+  ): Promise<number> {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+
+    // Retrieve the opening balance of credit and debit balances.
+    const openingBalancesSubquery = AccountTransaction.query()
+      .where('account_id', accountId)
+      .orderBy([
+        { column: 'date', order: 'desc' },
+        { column: 'created_at', order: 'desc' },
+      ])
+      .limit(pagination.total)
+      .offset(pagination.pageSize * (pagination.page - 1));
+
+    // Sumation of credit and debit balance.
+    const openingBalances = await AccountTransaction.query()
+      .sum('credit as credit')
+      .sum('debit as debit')
+      .from(openingBalancesSubquery.as('T'))
+      .first();
+
+    const openingBalance = openingBalances.debit - openingBalances.credit;
+
+    return openingBalance;
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/CashflowAccountTransactions/CashflowAccountTransactionsService.ts b/packages/server/src/services/FinancialStatements/CashflowAccountTransactions/CashflowAccountTransactionsService.ts
new file mode 100644
index 000000000..7a41cef41
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/CashflowAccountTransactions/CashflowAccountTransactionsService.ts
@@ -0,0 +1,108 @@
+import { Service, Inject } from 'typedi';
+import { includes } from 'lodash';
+import * as qim from 'qim';
+import { ICashflowAccountTransactionsQuery, IAccount } from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import FinancialSheet from '../FinancialSheet';
+import CashflowAccountTransactionsRepo from './CashflowAccountTransactionsRepo';
+import CashflowAccountTransactionsReport from './CashflowAccountTransactions';
+import { ACCOUNT_TYPE } from '@/data/AccountTypes';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+import I18nService from '@/services/I18n/I18nService';
+
+@Service()
+export default class CashflowAccountTransactionsService extends FinancialSheet {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  cashflowTransactionsRepo: CashflowAccountTransactionsRepo;
+
+  @Inject()
+  i18nService: I18nService;
+
+  /**
+   * Defaults balance sheet filter query.
+   * @return {IBalanceSheetQuery}
+   */
+  private get defaultQuery(): Partial<ICashflowAccountTransactionsQuery> {
+    return {
+      pageSize: 50,
+      page: 1,
+      numberFormat: {
+        precision: 2,
+        divideOn1000: false,
+        showZero: false,
+        formatMoney: 'total',
+        negativeFormat: 'mines',
+      },
+    };
+  }
+
+  /**
+   * Retrieve the cashflow accouynt transactions report data.
+   * @param {number} tenantId -
+   * @param {ICashflowAccountTransactionsQuery} query -
+   * @return {Promise<IInvetoryItemDetailDOO>}
+   */
+  public async cashflowAccountTransactions(
+    tenantId: number,
+    query: ICashflowAccountTransactionsQuery
+  ) {
+    const { Account } = this.tenancy.models(tenantId);
+    const parsedQuery = { ...this.defaultQuery, ...query };
+
+    // Retrieve the given account or throw not found service error.
+    const account = await Account.query().findById(parsedQuery.accountId);
+
+    // Validates the cashflow account type.
+    this.validateCashflowAccountType(account);
+
+    // Retrieve the cashflow account transactions.
+    const { results: transactions, pagination } =
+      await this.cashflowTransactionsRepo.getCashflowAccountTransactions(
+        tenantId,
+        parsedQuery
+      );
+    // Retrieve the cashflow account opening balance.
+    const openingBalance =
+      await this.cashflowTransactionsRepo.getCashflowAccountOpeningBalance(
+        tenantId,
+        parsedQuery.accountId,
+        pagination
+      );
+    // Retrieve the computed report.
+    const report = new CashflowAccountTransactionsReport(
+      transactions,
+      openingBalance,
+      parsedQuery
+    );
+    const reportTranasctions = report.reportData();
+
+    return {
+      transactions: this.i18nService.i18nApply(
+        [[qim.$each, 'formattedTransactionType']],
+        reportTranasctions,
+        tenantId
+      ),
+      pagination,
+    };
+  }
+
+  /**
+   * Validates the cashflow account type.
+   * @param {IAccount} account -
+   */
+  private validateCashflowAccountType(account: IAccount) {
+    const cashflowTypes = [
+      ACCOUNT_TYPE.CASH,
+      ACCOUNT_TYPE.CREDIT_CARD,
+      ACCOUNT_TYPE.BANK,
+    ];
+
+    if (!includes(cashflowTypes, account.accountType)) {
+      throw new ServiceError(ERRORS.ACCOUNT_ID_HAS_INVALID_TYPE);
+    }
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/CashflowAccountTransactions/constants.ts b/packages/server/src/services/FinancialStatements/CashflowAccountTransactions/constants.ts
new file mode 100644
index 000000000..bf0a0eead
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/CashflowAccountTransactions/constants.ts
@@ -0,0 +1,3 @@
+export const ERRORS = {
+  ACCOUNT_ID_HAS_INVALID_TYPE: 'ACCOUNT_ID_HAS_INVALID_TYPE',
+};
diff --git a/packages/server/src/services/FinancialStatements/ContactBalanceSummary/ContactBalanceSummary.ts b/packages/server/src/services/FinancialStatements/ContactBalanceSummary/ContactBalanceSummary.ts
new file mode 100644
index 000000000..dee1fbb5e
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ContactBalanceSummary/ContactBalanceSummary.ts
@@ -0,0 +1,204 @@
+import { sumBy, isEmpty } from 'lodash';
+import * as R from 'ramda';
+import FinancialSheet from '../FinancialSheet';
+import {
+  IContactBalanceSummaryContact,
+  IContactBalanceSummaryTotal,
+  IContactBalanceSummaryAmount,
+  IContactBalanceSummaryPercentage,
+  ILedger,
+  IContactBalanceSummaryQuery,
+} from '@/interfaces';
+import { allPassedConditionsPass } from 'utils';
+
+export class ContactBalanceSummaryReport extends FinancialSheet {
+  readonly baseCurrency: string;
+  readonly ledger: ILedger;
+  readonly filter: IContactBalanceSummaryQuery;
+
+  /**
+   * Calculates the contact percentage of column.
+   * @param   {number} customerBalance - Contact balance.
+   * @param   {number} totalBalance - Total contacts balance.
+   * @returns {number}
+   */
+  protected getContactPercentageOfColumn = (
+    customerBalance: number,
+    totalBalance: number
+  ): number => {
+    return totalBalance / customerBalance;
+  };
+
+  /**
+   * Retrieve the contacts total.
+   * @param   {IContactBalanceSummaryContact} contacts
+   * @returns {number}
+   */
+  protected getContactsTotal = (
+    contacts: IContactBalanceSummaryContact[]
+  ): number => {
+    return sumBy(
+      contacts,
+      (contact: IContactBalanceSummaryContact) => contact.total.amount
+    );
+  };
+
+  /**
+   * Assoc total percentage of column.
+   * @param {IContactBalanceSummaryTotal} node
+   * @returns {IContactBalanceSummaryTotal}
+   */
+  protected assocTotalPercentageOfColumn = (
+    node: IContactBalanceSummaryTotal
+  ): IContactBalanceSummaryTotal => {
+    return R.assoc('percentageOfColumn', this.getPercentageMeta(1), node);
+  };
+
+  /**
+   * Retrieve the contacts total section.
+   * @param   {IContactBalanceSummaryContact[]} contacts
+   * @returns {IContactBalanceSummaryTotal}
+   */
+  protected getContactsTotalSection = (
+    contacts: IContactBalanceSummaryContact[]
+  ): IContactBalanceSummaryTotal => {
+    const customersTotal = this.getContactsTotal(contacts);
+    const node = {
+      total: this.getTotalFormat(customersTotal),
+    };
+    return R.compose(
+      R.when(
+        R.always(this.filter.percentageColumn),
+        this.assocTotalPercentageOfColumn
+      )
+    )(node);
+  };
+
+  /**
+   * Retrieve the contact summary section with percentage of column.
+   * @param   {number} total
+   * @param   {IContactBalanceSummaryContact} contact
+   * @returns {IContactBalanceSummaryContact}
+   */
+  private contactCamparsionPercentageOfColumnMapper = (
+    total: number,
+    contact: IContactBalanceSummaryContact
+  ): IContactBalanceSummaryContact => {
+    const amount = this.getContactPercentageOfColumn(
+      total,
+      contact.total.amount
+    );
+    return {
+      ...contact,
+      percentageOfColumn: this.getPercentageMeta(amount),
+    };
+  };
+
+  /**
+   * Mappes the contacts summary sections with percentage of column.
+   * @param  {IContactBalanceSummaryContact[]} contacts -
+   * @return {IContactBalanceSummaryContact[]}
+   */
+  protected contactCamparsionPercentageOfColumn = (
+    contacts: IContactBalanceSummaryContact[]
+  ): IContactBalanceSummaryContact[] => {
+    const customersTotal = this.getContactsTotal(contacts);
+    const camparsionPercentageOfColummn = R.curry(
+      this.contactCamparsionPercentageOfColumnMapper
+    )(customersTotal);
+
+    return contacts.map(camparsionPercentageOfColummn);
+  };
+
+  /**
+   * Retrieve the contact total format.
+   * @param  {number} amount -
+   * @return {IContactBalanceSummaryAmount}
+   */
+  protected getContactTotalFormat = (
+    amount: number
+  ): IContactBalanceSummaryAmount => {
+    return {
+      amount,
+      formattedAmount: this.formatNumber(amount, { money: true }),
+      currencyCode: this.baseCurrency,
+    };
+  };
+
+  /**
+   * Retrieve the total amount of contacts sections.
+   * @param   {number} amount
+   * @returns {IContactBalanceSummaryAmount}
+   */
+  protected getTotalFormat = (amount: number): IContactBalanceSummaryAmount => {
+    return {
+      amount,
+      formattedAmount: this.formatTotalNumber(amount, { money: true }),
+      currencyCode: this.baseCurrency,
+    };
+  };
+
+  /**
+   * Retrieve the percentage amount object.
+   * @param   {number} amount
+   * @returns {IContactBalanceSummaryPercentage}
+   */
+  protected getPercentageMeta = (
+    amount: number
+  ): IContactBalanceSummaryPercentage => {
+    return {
+      amount,
+      formattedAmount: this.formatPercentage(amount),
+    };
+  };
+
+  /**
+   * Filters customer has none transactions.
+   * @param {ICustomerBalanceSummaryCustomer} customer -
+   * @returns {boolean}
+   */
+  private filterContactNoneTransactions = (
+    contact: IContactBalanceSummaryContact
+  ): boolean => {
+    const entries = this.ledger.whereContactId(contact.id).getEntries();
+
+    return !isEmpty(entries);
+  };
+
+  /**
+   * Filters the customer that has zero total amount.
+   * @param   {ICustomerBalanceSummaryCustomer} customer
+   * @returns {boolean}
+   */
+  private filterContactNoneZero = (
+    node: IContactBalanceSummaryContact
+  ): boolean => {
+    return node.total.amount !== 0;
+  };
+
+  /**
+   * Filters the given customer node;
+   * @param {ICustomerBalanceSummaryCustomer} customer
+   */
+  private contactNodeFilter = (contact: IContactBalanceSummaryContact) => {
+    const { noneTransactions, noneZero } = this.filter;
+
+    // Conditions pair filter detarminer.
+    const condsPairFilters = [
+      [noneTransactions, this.filterContactNoneTransactions],
+      [noneZero, this.filterContactNoneZero],
+    ];
+    return allPassedConditionsPass(condsPairFilters)(contact);
+  };
+
+  /**
+   * Filters the given customers nodes.
+   * @param   {ICustomerBalanceSummaryCustomer[]} nodes
+   * @returns {ICustomerBalanceSummaryCustomer[]}
+   */
+  protected contactsFilter = (
+    nodes: IContactBalanceSummaryContact[]
+  ): IContactBalanceSummaryContact[] => {
+    return nodes.filter(this.contactNodeFilter);
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummary.ts b/packages/server/src/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummary.ts
new file mode 100644
index 000000000..15eafb739
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummary.ts
@@ -0,0 +1,111 @@
+import { isEmpty } from 'lodash';
+import * as R from 'ramda';
+import {
+  ILedger,
+  ICustomer,
+  ICustomerBalanceSummaryCustomer,
+  ICustomerBalanceSummaryQuery,
+  ICustomerBalanceSummaryData,
+  INumberFormatQuery,
+} from '@/interfaces';
+import { ContactBalanceSummaryReport } from '../ContactBalanceSummary/ContactBalanceSummary';
+
+export class CustomerBalanceSummaryReport extends ContactBalanceSummaryReport {
+  readonly ledger: ILedger;
+  readonly baseCurrency: string;
+  readonly customers: ICustomer[];
+  readonly filter: ICustomerBalanceSummaryQuery;
+  readonly numberFormat: INumberFormatQuery;
+
+  /**
+   * Constructor method.
+   * @param {IJournalPoster} receivableLedger
+   * @param {ICustomer[]} customers
+   * @param {ICustomerBalanceSummaryQuery} filter
+   * @param {string} baseCurrency
+   */
+  constructor(
+    ledger: ILedger,
+    customers: ICustomer[],
+    filter: ICustomerBalanceSummaryQuery,
+    baseCurrency: string
+  ) {
+    super();
+
+    this.ledger = ledger;
+    this.baseCurrency = baseCurrency;
+    this.customers = customers;
+    this.filter = filter;
+    this.numberFormat = this.filter.numberFormat;
+  }
+
+  /**
+   * Customer section mapper.
+   * @param   {ICustomer} customer
+   * @returns {ICustomerBalanceSummaryCustomer}
+   */
+  private customerMapper = (
+    customer: ICustomer
+  ): ICustomerBalanceSummaryCustomer => {
+    const closingBalance = this.ledger
+      .whereContactId(customer.id)
+      .getClosingBalance();
+
+    return {
+      id: customer.id,
+      customerName: customer.displayName,
+      total: this.getContactTotalFormat(closingBalance),
+    };
+  };
+
+  /**
+   * Mappes the customer model object to customer balance summary section.
+   * @param   {ICustomer[]} customers - Customers.
+   * @returns {ICustomerBalanceSummaryCustomer[]}
+   */
+  private customersMapper = (
+    customers: ICustomer[]
+  ): ICustomerBalanceSummaryCustomer[] => {
+    return customers.map(this.customerMapper);
+  };
+
+  /**
+   * Detarmines whether the customers post filter is active.
+   * @returns {boolean}
+   */
+  private isCustomersPostFilter = () => {
+    return isEmpty(this.filter.customersIds);
+  };
+
+  /**
+   * Retrieve the customers sections of the report.
+   * @param   {ICustomer} customers
+   * @returns {ICustomerBalanceSummaryCustomer[]}
+   */
+  private getCustomersSection = (
+    customers: ICustomer[]
+  ): ICustomerBalanceSummaryCustomer[] => {
+    return R.compose(
+      R.when(this.isCustomersPostFilter, this.contactsFilter),
+      R.when(
+        R.always(this.filter.percentageColumn),
+        this.contactCamparsionPercentageOfColumn
+      ),
+      this.customersMapper
+    )(customers);
+  };
+
+  /**
+   * Retrieve the report statement data.
+   * @returns {ICustomerBalanceSummaryData}
+   */
+  public reportData = (): ICustomerBalanceSummaryData => {
+    const customersSections = this.getCustomersSection(this.customers);
+    const customersTotal = this.getContactsTotalSection(customersSections);
+
+    return {
+      customers: customersSections,
+      total: customersTotal,
+    };
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummaryRepository.ts b/packages/server/src/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummaryRepository.ts
new file mode 100644
index 000000000..6de7bf54d
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummaryRepository.ts
@@ -0,0 +1,69 @@
+import { Inject, Service } from 'typedi';
+import { map, isEmpty } from 'lodash';
+import { ICustomer, IAccount } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ACCOUNT_TYPE } from '@/data/AccountTypes';
+
+@Service()
+export default class CustomerBalanceSummaryRepository {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve the report customers.
+   * @param {number} tenantId
+   * @param {number[]} customersIds
+   * @returns {ICustomer[]}
+   */
+  public getCustomers(tenantId: number, customersIds: number[]): ICustomer[] {
+    const { Customer } = this.tenancy.models(tenantId);
+
+    return Customer.query()
+      .orderBy('displayName')
+      .onBuild((query) => {
+        if (!isEmpty(customersIds)) {
+          query.whereIn('id', customersIds);
+        }
+      });
+  }
+
+  /**
+   * Retrieve the A/R accounts.
+   * @param {number} tenantId
+   * @returns {Promise<IAccount[]>}
+   */
+  public getReceivableAccounts(tenantId: number): Promise<IAccount> {
+    const { Account } = this.tenancy.models(tenantId);
+
+    return Account.query().where(
+      'accountType',
+      ACCOUNT_TYPE.ACCOUNTS_RECEIVABLE
+    );
+  }
+
+  /**
+   * Retrieve the customers credit/debit totals
+   * @param {number} tenantId
+   * @returns
+   */
+  public async getCustomersTransactions(tenantId: number, asDate: any) {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+
+    // Retrieve the receivable accounts A/R.
+    const receivableAccounts = await this.getReceivableAccounts(tenantId);
+    const receivableAccountsIds = map(receivableAccounts, 'id');
+
+    // Retrieve the customers transactions of A/R accounts.
+    const customersTranasctions = await AccountTransaction.query().onBuild(
+      (query) => {
+        query.whereIn('accountId', receivableAccountsIds);
+        query.modify('filterDateRange', null, asDate);
+        query.groupBy('contactId');
+        query.sum('credit as credit');
+        query.sum('debit as debit');
+        query.select('contactId');
+      }
+    );
+    return customersTranasctions;
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummaryService.ts b/packages/server/src/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummaryService.ts
new file mode 100644
index 000000000..01ec0e050
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummaryService.ts
@@ -0,0 +1,122 @@
+import { Inject } from 'typedi';
+import moment from 'moment';
+import { isEmpty, map } from 'lodash';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import * as R from 'ramda';
+import {
+  ICustomerBalanceSummaryService,
+  ICustomerBalanceSummaryQuery,
+  ICustomerBalanceSummaryStatement,
+  ICustomer,
+  ILedgerEntry,
+} from '@/interfaces';
+import { CustomerBalanceSummaryReport } from './CustomerBalanceSummary';
+
+import Ledger from '@/services/Accounting/Ledger';
+import CustomerBalanceSummaryRepository from './CustomerBalanceSummaryRepository';
+import { Tenant } from '@/system/models';
+
+export default class CustomerBalanceSummaryService
+  implements ICustomerBalanceSummaryService
+{
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  reportRepository: CustomerBalanceSummaryRepository;
+
+  /**
+   * Defaults balance sheet filter query.
+   * @return {ICustomerBalanceSummaryQuery}
+   */
+  get defaultQuery(): ICustomerBalanceSummaryQuery {
+    return {
+      asDate: moment().format('YYYY-MM-DD'),
+      numberFormat: {
+        precision: 2,
+        divideOn1000: false,
+        showZero: false,
+        formatMoney: 'total',
+        negativeFormat: 'mines',
+      },
+      percentageColumn: false,
+      
+      noneZero: false,
+      noneTransactions: true,
+    };
+  }
+
+
+  /**
+   * Retrieve the customers ledger entries mapped from accounts transactions.
+   * @param {number} tenantId
+   * @param {Date|string} asDate
+   * @returns {Promise<ILedgerEntry[]>}
+   */
+  private async getReportCustomersEntries(
+    tenantId: number,
+    asDate: Date | string
+  ): Promise<ILedgerEntry[]> {
+    const transactions = await this.reportRepository.getCustomersTransactions(
+      tenantId,
+      asDate
+    );
+    const commonProps = { accountNormal: 'debit', date: asDate };
+
+    return R.map(R.merge(commonProps))(transactions);
+  }
+
+  /**
+   * Retrieve the statment of customer balance summary report.
+   * @param {number} tenantId
+   * @param {ICustomerBalanceSummaryQuery} query
+   * @return {Promise<ICustomerBalanceSummaryStatement>}
+   */
+  async customerBalanceSummary(
+    tenantId: number,
+    query: ICustomerBalanceSummaryQuery
+  ): Promise<ICustomerBalanceSummaryStatement> {
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    // Merges the default query and request query.
+    const filter = { ...this.defaultQuery, ...query };
+
+    this.logger.info(
+      '[customer_balance_summary] trying to calculate the report.',
+      {
+        filter,
+        tenantId,
+      }
+    );
+    // Retrieve the customers list ordered by the display name.
+    const customers = await this.reportRepository.getCustomers(
+      tenantId,
+      query.customersIds
+    );
+    // Retrieve the customers debit/credit totals.
+    const customersEntries = await this.getReportCustomersEntries(
+      tenantId,
+      filter.asDate
+    );
+    // Ledger query.
+    const ledger = new Ledger(customersEntries);
+
+    // Report instance.
+    const report = new CustomerBalanceSummaryReport(
+      ledger,
+      customers,
+      filter,
+      tenant.metadata.baseCurrency,
+    );
+
+    return {
+      data: report.reportData(),
+      query: filter,
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummaryTableRows.ts b/packages/server/src/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummaryTableRows.ts
new file mode 100644
index 000000000..b55a12613
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummaryTableRows.ts
@@ -0,0 +1,150 @@
+import * as R from 'ramda';
+import {
+  ICustomerBalanceSummaryData,
+  ICustomerBalanceSummaryCustomer,
+  ICustomerBalanceSummaryTotal,
+  ITableRow,
+  IColumnMapperMeta,
+  ICustomerBalanceSummaryQuery,
+  ITableColumn,
+} from '@/interfaces';
+import { tableMapper, tableRowMapper } from 'utils';
+
+enum TABLE_ROWS_TYPES {
+  CUSTOMER = 'CUSTOMER',
+  TOTAL = 'TOTAL',
+}
+
+export default class CustomerBalanceSummaryTable {
+  report: ICustomerBalanceSummaryData;
+  query: ICustomerBalanceSummaryQuery;
+  i18n: any;
+
+  /**
+   * Constructor method.
+   */
+  constructor(
+    report: ICustomerBalanceSummaryData,
+    query: ICustomerBalanceSummaryQuery,
+    i18n
+  ) {
+    this.report = report;
+    this.i18n = i18n;
+    this.query = query;
+  }
+
+  /**
+   * Retrieve percentage columns accessor.
+   * @returns {IColumnMapperMeta[]}
+   */
+  private getPercentageColumnsAccessor = (): IColumnMapperMeta[] => {
+    return [
+      {
+        key: 'percentageOfColumn',
+        accessor: 'percentageOfColumn.formattedAmount',
+      },
+    ];
+  };
+
+  /**
+   * Retrieve customer node columns accessor.
+   * @returns {IColumnMapperMeta[]}
+   */
+  private getCustomerColumnsAccessor = (): IColumnMapperMeta[] => {
+    const columns = [
+      { key: 'customerName', accessor: 'customerName' },
+      { key: 'total', accessor: 'total.formattedAmount' },
+    ];
+    return R.compose(
+      R.concat(columns),
+      R.when(
+        R.always(this.query.percentageColumn),
+        R.concat(this.getPercentageColumnsAccessor())
+      )
+    )([]);
+  };
+
+  /**
+   * Transformes the customers to table rows.
+   * @param   {ICustomerBalanceSummaryCustomer[]} customers
+   * @returns {ITableRow[]}
+   */
+  private customersTransformer(
+    customers: ICustomerBalanceSummaryCustomer[]
+  ): ITableRow[] {
+    const columns = this.getCustomerColumnsAccessor();
+
+    return tableMapper(customers, columns, {
+      rowTypes: [TABLE_ROWS_TYPES.CUSTOMER],
+    });
+  }
+
+  /**
+   * Retrieve total node columns accessor.
+   * @returns {IColumnMapperMeta[]}
+   */
+  private getTotalColumnsAccessor = (): IColumnMapperMeta[] => {
+    const columns = [
+      { key: 'total', value: this.i18n.__('Total') },
+      { key: 'total', accessor: 'total.formattedAmount' },
+    ];
+    return R.compose(
+      R.concat(columns),
+      R.when(
+        R.always(this.query.percentageColumn),
+        R.concat(this.getPercentageColumnsAccessor())
+      )
+    )([]);
+  };
+
+  /**
+   * Transformes the total to table row.
+   * @param   {ICustomerBalanceSummaryTotal} total
+   * @returns {ITableRow}
+   */
+  private totalTransformer = (
+    total: ICustomerBalanceSummaryTotal
+  ): ITableRow => {
+    const columns = this.getTotalColumnsAccessor();
+
+    return tableRowMapper(total, columns, {
+      rowTypes: [TABLE_ROWS_TYPES.TOTAL],
+    });
+  };
+
+  /**
+   * Transformes the customer balance summary to table rows.
+   * @param   {ICustomerBalanceSummaryData} customerBalanceSummary
+   * @returns {ITableRow[]}
+   */
+  public tableRows(): ITableRow[] {
+    const customers = this.customersTransformer(this.report.customers);
+    const total = this.totalTransformer(this.report.total);
+
+    return customers.length > 0 ? [...customers, total] : [];
+  }
+
+  /**
+   * Retrieve the report statement columns
+   * @returns {ITableColumn[]}
+   */
+   public tableColumns = (): ITableColumn[] => {
+    const columns = [
+      {
+        key: 'name',
+        label: this.i18n.__('contact_summary_balance.account_name'),
+      },
+      { key: 'total', label: this.i18n.__('contact_summary_balance.total') },
+    ];
+    return R.compose(
+      R.when(
+        R.always(this.query.percentageColumn),
+        R.append({
+          key: 'percentage_of_column',
+          label: this.i18n.__('contact_summary_balance.percentage_column'),
+        })
+      ),
+      R.concat(columns)
+    )([]);
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/FinancialDatePeriods.ts b/packages/server/src/services/FinancialStatements/FinancialDatePeriods.ts
new file mode 100644
index 000000000..e1c05e64e
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/FinancialDatePeriods.ts
@@ -0,0 +1,113 @@
+import * as R from 'ramda';
+import { memoize } from 'lodash';
+import { compose } from 'lodash/fp';
+import {
+  IAccountTransactionsGroupBy,
+  IFinancialDatePeriodsUnit,
+  IFinancialSheetTotalPeriod,
+  IFormatNumberSettings,
+} from '@/interfaces';
+import { dateRangeFromToCollection } from 'utils';
+import { FinancialDateRanges } from './FinancialDateRanges';
+
+export const FinancialDatePeriods = (Base) =>
+  class extends compose(FinancialDateRanges)(Base) {
+    /**
+     *
+     * @param {Date} fromDate -
+     * @param {Date} toDate
+     * @param {string} unit
+     */
+    protected getDateRanges = memoize(
+      (fromDate: Date, toDate: Date, unit: string) => {
+        return dateRangeFromToCollection(fromDate, toDate, unit);
+      }
+    );
+
+    /**
+     * Retrieve the date period meta.
+     * @param  {number} total - Total amount.
+     * @param  {Date} fromDate - From date.
+     * @param  {Date} toDate -  To date.
+     * @return {ICashFlowDatePeriod}
+     */
+    protected getDatePeriodMeta = (
+      total: number,
+      fromDate: Date,
+      toDate: Date,
+      overrideSettings?: IFormatNumberSettings
+    ): IFinancialSheetTotalPeriod => {
+      return {
+        fromDate: this.getDateMeta(fromDate),
+        toDate: this.getDateMeta(toDate),
+        total: this.getAmountMeta(total, overrideSettings),
+      };
+    };
+
+    /**
+     * Retrieve the date period meta.
+     * @param  {number} total - Total amount.
+     * @param  {Date} fromDate - From date.
+     * @param  {Date} toDate -  To date.
+     * @return {ICashFlowDatePeriod}
+     */
+    protected getDatePeriodTotalMeta = (
+      total: number,
+      fromDate: Date,
+      toDate: Date,
+      overrideSettings: IFormatNumberSettings = {}
+    ) => {
+      return this.getDatePeriodMeta(total, fromDate, toDate, {
+        money: true,
+        ...overrideSettings,
+      });
+    };
+
+    /**
+     * Retrieve the date preioods of the given node and accumlated function.
+     * @param  {IBalanceSheetAccountNode} node
+     * @param  {(fromDate: Date, toDate: Date, index: number) => any}
+     * @return {}
+     */
+    protected getNodeDatePeriods = R.curry(
+      (
+        fromDate: Date,
+        toDate: Date,
+        periodsUnit: string,
+        node: any,
+        callback: (
+          node: any,
+          fromDate: Date,
+          toDate: Date,
+          index: number
+        ) => any
+      ) => {
+        const curriedCallback = R.curry(callback)(node);
+
+        // Retrieves memorized date ranges.
+        const dateRanges = this.getDateRanges(fromDate, toDate, periodsUnit);
+
+        return dateRanges.map((dateRange, index) => {
+          return curriedCallback(dateRange.fromDate, dateRange.toDate, index);
+        });
+      }
+    );
+
+    /**
+     * Retrieve the accounts transactions group type from display columns by.
+     * @param   {IAccountTransactionsGroupBy} columnsBy
+     * @returns {IAccountTransactionsGroupBy}
+     */
+    protected getGroupByFromDisplayColumnsBy = (
+      columnsBy: IFinancialDatePeriodsUnit
+    ): IAccountTransactionsGroupBy => {
+      const paris = {
+        week: IAccountTransactionsGroupBy.Day,
+        quarter: IAccountTransactionsGroupBy.Month,
+        year: IAccountTransactionsGroupBy.Year,
+        month: IAccountTransactionsGroupBy.Month,
+        day: IAccountTransactionsGroupBy.Day,
+      };
+      return paris[columnsBy];
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/FinancialDateRanges.ts b/packages/server/src/services/FinancialStatements/FinancialDateRanges.ts
new file mode 100644
index 000000000..f6c419605
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/FinancialDateRanges.ts
@@ -0,0 +1,110 @@
+import { IDateRange, IFinancialDatePeriodsUnit } from '@/interfaces';
+import moment from 'moment';
+
+export const FinancialDateRanges = (Base) =>
+  class extends Base {
+    /**
+     * Retrieve previous period (PP) date of the given date.
+     * @param   {Date} fromDate -
+     * @param   {Date} toDate -
+     * @param   {IFinancialDatePeriodsUnit} unit -
+     * @returns {Date}
+     */
+    protected getPreviousPeriodDate = (
+      date: Date,
+      value: number = 1,
+      unit: IFinancialDatePeriodsUnit = IFinancialDatePeriodsUnit.Day
+    ): Date => {
+      return moment(date).subtract(value, unit).toDate();
+    };
+
+    /**
+     * Retrieves the different 
+     * @param {Date} fromDate
+     * @param {Date} toDate
+     * @returns
+     */
+    protected getPreviousPeriodDiff = (fromDate: Date, toDate: Date) => {
+      return moment(toDate).diff(fromDate, 'days') + 1;
+    };
+
+    /**
+     * Retrieves the periods period dates.
+     * @param {Date} fromDate -
+     * @param {Date} toDate -
+     */
+    protected getPreviousPeriodDateRange = (
+      fromDate: Date,
+      toDate: Date,
+      unit: IFinancialDatePeriodsUnit,
+      amount: number = 1
+    ): IDateRange => {
+      const PPToDate = this.getPreviousPeriodDate(toDate, amount, unit);
+      const PPFromDate = this.getPreviousPeriodDate(fromDate, amount, unit);
+
+      return { toDate: PPToDate, fromDate: PPFromDate };
+    };
+
+    /**
+     * Retrieves the previous period (PP) date range of total column.
+     * @param   {Date} fromDate
+     * @param   {Date} toDate
+     * @returns {IDateRange}
+     */
+    protected getPPTotalDateRange = (
+      fromDate: Date,
+      toDate: Date
+    ): IDateRange => {
+      const unit = this.getPreviousPeriodDiff(fromDate, toDate);
+
+      return this.getPreviousPeriodDateRange(
+        fromDate,
+        toDate,
+        IFinancialDatePeriodsUnit.Day,
+        unit
+      );
+    };
+
+    /**
+     * Retrieves the previous period (PP) date range of date periods columns.
+     * @param   {Date} fromDate -
+     * @param   {Date} toDate -
+     * @param   {IFinancialDatePeriodsUnit}
+     * @returns {IDateRange}
+     */
+    protected getPPDatePeriodDateRange = (
+      fromDate: Date,
+      toDate: Date,
+      unit: IFinancialDatePeriodsUnit
+    ): IDateRange => {
+      return this.getPreviousPeriodDateRange(fromDate, toDate, unit, 1);
+    };
+
+    // ------------------------
+    // Previous Year (PY).
+    // ------------------------
+    /**
+     * Retrieve the previous year of the given date.
+     * @params  {Date} date
+     * @returns {Date}
+     */
+    getPreviousYearDate = (date: Date) => {
+      return moment(date).subtract(1, 'years').toDate();
+    };
+
+    /**
+     * Retrieves previous year date range.
+     * @param   {Date} fromDate
+     * @param   {Date} toDate
+     * @returns {IDateRange}
+     */
+    protected getPreviousYearDateRange = (
+      fromDate: Date,
+      toDate: Date
+    ): IDateRange => {
+      const PYFromDate = this.getPreviousYearDate(fromDate);
+      const PYToDate = this.getPreviousYearDate(toDate);
+
+      return { fromDate: PYFromDate, toDate: PYToDate };
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/FinancialEvaluateEquation.ts b/packages/server/src/services/FinancialStatements/FinancialEvaluateEquation.ts
new file mode 100644
index 000000000..230dc7209
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/FinancialEvaluateEquation.ts
@@ -0,0 +1,62 @@
+import * as mathjs from 'mathjs';
+import * as R from 'ramda';
+import { compose } from 'lodash/fp';
+import { omit, get, mapValues } from 'lodash';
+import { FinancialSheetStructure } from './FinancialSheetStructure';
+
+export const FinancialEvaluateEquation = (Base) =>
+  class extends compose(FinancialSheetStructure)(Base) {
+    /**
+     * Evauluate equaation string with the given scope table.
+     * @param {string} equation -
+     * @param {{ [key: string]: number }} scope -
+     * @return {number}
+     */
+    protected evaluateEquation = (
+      equation: string,
+      scope: { [key: string | number]: number }
+    ): number => {
+      return mathjs.evaluate(equation, scope);
+    };
+
+    /**
+     * Transformes the given nodes nested array to object key/value by id.
+     * @param nodes
+     * @returns
+     */
+    private transformNodesToMap = (nodes: any[]) => {
+      return this.mapAccNodesDeep(
+        nodes,
+        (node, key, parentValue, acc, context) => {
+          if (node.id) {
+            acc[`${node.id}`] = omit(node, ['children']);
+          }
+          return acc;
+        },
+        {}
+      );
+    };
+
+    /**
+     *
+     * @param nodesById
+     * @returns
+     */
+    private mapNodesToTotal = R.curry(
+      (path: string, nodesById: { [key: number]: any }) => {
+        return mapValues(nodesById, (node) => get(node, path, 0));
+      }
+    );
+
+    /**
+     *
+     */
+    protected getNodesTableForEvaluating = R.curry(
+      (path = 'total.amount', nodes) => {
+        return R.compose(
+          this.mapNodesToTotal(path),
+          this.transformNodesToMap
+        )(nodes);
+      }
+    );
+  };
diff --git a/packages/server/src/services/FinancialStatements/FinancialFilter.ts b/packages/server/src/services/FinancialStatements/FinancialFilter.ts
new file mode 100644
index 000000000..daf90d949
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/FinancialFilter.ts
@@ -0,0 +1,22 @@
+
+import { isEmpty } from 'lodash';
+
+export const FinancialFilter = (Base) =>
+  class extends Base {
+    /**
+     * Detarmines whether the given node has children.
+     * @param   {IBalanceSheetCommonNode} node
+     * @returns {boolean}
+     */
+    protected isNodeHasChildren = (node: IBalanceSheetCommonNode): boolean =>
+      !isEmpty(node.children);
+
+    /**
+     * Detarmines whether the given node has no zero amount.
+     * @param   {IBalanceSheetCommonNode} node
+     * @returns {boolean}
+     */
+    public isNodeNoneZero = (node) =>{
+      return node.total.amount !== 0;
+    }
+  };
diff --git a/packages/server/src/services/FinancialStatements/FinancialHorizTotals.ts b/packages/server/src/services/FinancialStatements/FinancialHorizTotals.ts
new file mode 100644
index 000000000..b7ab8d987
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/FinancialHorizTotals.ts
@@ -0,0 +1,96 @@
+import * as R from 'ramda';
+import { get, isEmpty } from 'lodash';
+
+export const FinancialHorizTotals = (Base) =>
+  class extends Base {
+    /**
+     *
+     */
+    protected assocNodePercentage = R.curry(
+      (assocPath, parentTotal: number, node: any) => {
+        const percentage = this.getPercentageBasis(
+          parentTotal,
+          node.total.amount
+        );
+        return R.assoc(
+          assocPath,
+          this.getPercentageAmountMeta(percentage),
+          node
+        );
+      }
+    );
+
+    /**
+     *
+     * @param {} parentNode -
+     * @param {} horTotalNode -
+     * @param {number} index -
+     */
+    protected assocPercentageHorizTotal = R.curry(
+      (assocPercentagePath: string, parentNode, horTotalNode, index) => {
+        const parentTotal = get(
+          parentNode,
+          `horizontalTotals[${index}].total.amount`,
+          0
+        );
+        return this.assocNodePercentage(
+          assocPercentagePath,
+          parentTotal,
+          horTotalNode
+        );
+      }
+    );
+
+    /**
+     *
+     * @param assocPercentagePath
+     * @param parentNode
+     * @param node
+     * @returns
+     */
+    protected assocPercentageHorizTotals = R.curry(
+      (assocPercentagePath: string, parentNode, node) => {
+        const assocColPerc = this.assocPercentageHorizTotal(
+          assocPercentagePath,
+          parentNode
+        );
+        return R.addIndex(R.map)(assocColPerc)(node.horizontalTotals);
+      }
+    );
+
+    /**
+     *
+     */
+    assocRowPercentageHorizTotal = R.curry(
+      (assocPercentagePath: string, node, horizTotalNode) => {
+        return this.assocNodePercentage(
+          assocPercentagePath,
+          node.total.amount,
+          horizTotalNode
+        );
+      }
+    );
+
+    /**
+     *
+     */
+    protected assocHorizontalPercentageTotals = R.curry(
+      (assocPercentagePath: string, node) => {
+        const assocColPerc = this.assocRowPercentageHorizTotal(
+          assocPercentagePath,
+          node
+        );
+
+        return R.map(assocColPerc)(node.horizontalTotals);
+      }
+    );
+
+    /**
+     * 
+     * @param node 
+     * @returns 
+     */
+    protected isNodeHasHorizTotals = (node) => {
+      return !isEmpty(node.horizontalTotals);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/FinancialPreviousPeriod.ts b/packages/server/src/services/FinancialStatements/FinancialPreviousPeriod.ts
new file mode 100644
index 000000000..c0406a9b3
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/FinancialPreviousPeriod.ts
@@ -0,0 +1,127 @@
+import { sumBy } from 'lodash';
+import {
+  IFinancialDatePeriodsUnit,
+  IFinancialNodeWithPreviousPeriod,
+} from '@/interfaces';
+import * as R from 'ramda';
+
+export const FinancialPreviousPeriod = (Base) =>
+  class extends Base {
+    // ---------------------------
+    // # Common Node.
+    // ---------------------------
+    /**
+     * Assoc previous period percentage attribute to account node.
+     * @param   {IProfitLossSheetAccountNode} accountNode
+     * @returns {IFinancialNodeWithPreviousPeriod}
+     */
+    protected assocPreviousPeriodPercentageNode = (
+      accountNode: IProfitLossSheetAccountNode
+    ): IFinancialNodeWithPreviousPeriod => {
+      const percentage = this.getPercentageBasis(
+        accountNode.previousPeriod.amount,
+        accountNode.previousPeriodChange.amount
+      );
+      return R.assoc(
+        'previousPeriodPercentage',
+        this.getPercentageAmountMeta(percentage),
+        accountNode
+      );
+    };
+
+    /**
+     * Assoc previous period total attribute to account node.
+     * @param   {IProfitLossSheetAccountNode} accountNode
+     * @returns {IFinancialNodeWithPreviousPeriod}
+     */
+    protected assocPreviousPeriodChangeNode = (
+      accountNode: IProfitLossSheetAccountNode
+    ): IFinancialNodeWithPreviousPeriod => {
+      const change = this.getAmountChange(
+        accountNode.total.amount,
+        accountNode.previousPeriod.amount
+      );
+      return R.assoc(
+        'previousPeriodChange',
+        this.getAmountMeta(change),
+        accountNode
+      );
+    };
+
+    /**
+     * Assoc previous period percentage attribute to account node.
+     *
+     * % change = Change ÷ Original Number × 100.
+     *
+     * @param   {IProfitLossSheetAccountNode} accountNode
+     * @returns {IFinancialNodeWithPreviousPeriod}
+     */
+    protected assocPreviousPeriodTotalPercentageNode = (
+      accountNode: IProfitLossSheetAccountNode
+    ): IFinancialNodeWithPreviousPeriod => {
+      const percentage = this.getPercentageBasis(
+        accountNode.previousPeriod.amount,
+        accountNode.previousPeriodChange.amount
+      );
+      return R.assoc(
+        'previousPeriodPercentage',
+        this.getPercentageTotalAmountMeta(percentage),
+        accountNode
+      );
+    };
+
+    /**
+     * Assoc previous period total attribute to account node.
+     * @param   {IProfitLossSheetAccountNode} accountNode
+     * @returns {IFinancialNodeWithPreviousPeriod}
+     */
+    protected assocPreviousPeriodTotalChangeNode = (
+      accountNode: any
+    ): IFinancialNodeWithPreviousPeriod => {
+      const change = this.getAmountChange(
+        accountNode.total.amount,
+        accountNode.previousPeriod.amount
+      );
+      return R.assoc(
+        'previousPeriodChange',
+        this.getTotalAmountMeta(change),
+        accountNode
+      );
+    };
+
+    /**
+     * Assoc previous year from/to date to horizontal nodes.
+     * @param horizNode
+     * @returns {IFinancialNodeWithPreviousPeriod}
+     */
+    protected assocPreviousPeriodHorizNodeFromToDates = R.curry(
+      (
+        periodUnit: IFinancialDatePeriodsUnit,
+        horizNode: any
+      ): IFinancialNodeWithPreviousPeriod => {
+        const { fromDate: PPFromDate, toDate: PPToDate } =
+          this.getPreviousPeriodDateRange(
+            horizNode.fromDate.date,
+            horizNode.toDate.date,
+            periodUnit
+          );
+        return R.compose(
+          R.assoc('previousPeriodToDate', this.getDateMeta(PPToDate)),
+          R.assoc('previousPeriodFromDate', this.getDateMeta(PPFromDate))
+        )(horizNode);
+      }
+    );
+
+    /**
+     * Retrieves PP total sumation of the given horiz index node.
+     * @param {number} index
+     * @param node
+     * @returns {number}
+     */
+    protected getPPHorizNodesTotalSumation = (index: number, node): number => {
+      return sumBy(
+        node.children,
+        `horizontalTotals[${index}].previousPeriod.amount`
+      );
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/FinancialPreviousYear.ts b/packages/server/src/services/FinancialStatements/FinancialPreviousYear.ts
new file mode 100644
index 000000000..a55b7cb47
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/FinancialPreviousYear.ts
@@ -0,0 +1,118 @@
+import * as R from 'ramda';
+import { sumBy } from 'lodash'
+import {
+  IFinancialCommonHorizDatePeriodNode,
+  IFinancialCommonNode,
+  IFinancialNodeWithPreviousYear,
+} from '@/interfaces';
+
+export const FinancialPreviousYear = (Base) =>
+  class extends Base {
+    // ---------------------------
+    // # Common Node
+    // ---------------------------
+    /**
+     * Assoc previous year change attribute to account node.
+     * @param    {IProfitLossSheetAccountNode} accountNode
+     * @returns  {IProfitLossSheetAccountNode}
+     */
+    protected assocPreviousYearChangetNode = (
+      node: IFinancialCommonNode & IFinancialNodeWithPreviousYear
+    ): IFinancialNodeWithPreviousYear => {
+      const change = this.getAmountChange(
+        node.total.amount,
+        node.previousYear.amount
+      );
+      return R.assoc('previousYearChange', this.getAmountMeta(change), node);
+    };
+
+    /**
+     * Assoc previous year percentage attribute to account node.
+     *
+     * % increase = Increase ÷ Original Number × 100.
+     *
+     * @param   {IProfitLossSheetAccountNode} accountNode
+     * @returns {IProfitLossSheetAccountNode}
+     */
+    protected assocPreviousYearPercentageNode = (
+      node: IFinancialCommonNode & IFinancialNodeWithPreviousYear
+    ): IFinancialNodeWithPreviousYear => {
+      const percentage = this.getPercentageBasis(
+        node.previousYear.amount,
+        node.previousYearChange.amount
+      );
+      return R.assoc(
+        'previousYearPercentage',
+        this.getPercentageAmountMeta(percentage),
+        node
+      );
+    };
+
+    /**
+     * Assoc previous year change attribute to account node.
+     * @param    {IProfitLossSheetAccountNode} accountNode
+     * @returns  {IProfitLossSheetAccountNode}
+     */
+    protected assocPreviousYearTotalChangeNode = (
+      node: IFinancialCommonNode & IFinancialNodeWithPreviousYear
+    ): IFinancialNodeWithPreviousYear => {
+      const change = this.getAmountChange(
+        node.total.amount,
+        node.previousYear.amount
+      );
+      return R.assoc(
+        'previousYearChange',
+        this.getTotalAmountMeta(change),
+        node
+      );
+    };
+
+    /**
+     * Assoc previous year percentage attribute to account node.
+     * @param   {IProfitLossSheetAccountNode} accountNode
+     * @returns {IProfitLossSheetAccountNode}
+     */
+    protected assocPreviousYearTotalPercentageNode = (
+      node: IFinancialCommonNode & IFinancialNodeWithPreviousYear
+    ): IFinancialNodeWithPreviousYear => {
+      const percentage = this.getPercentageBasis(
+        node.previousYear.amount,
+        node.previousYearChange.amount
+      );
+      return R.assoc(
+        'previousYearPercentage',
+        this.getPercentageTotalAmountMeta(percentage),
+        node
+      );
+    };
+
+    /**
+     * Assoc previous year from/to date to horizontal nodes.
+     * @param horizNode
+     * @returns
+     */
+    protected assocPreviousYearHorizNodeFromToDates = (
+      horizNode: IFinancialCommonHorizDatePeriodNode
+    ) => {
+      const PYFromDate = this.getPreviousYearDate(horizNode.fromDate.date);
+      const PYToDate = this.getPreviousYearDate(horizNode.toDate.date);
+
+      return R.compose(
+        R.assoc('previousYearToDate', this.getDateMeta(PYToDate)),
+        R.assoc('previousYearFromDate', this.getDateMeta(PYFromDate))
+      )(horizNode);
+    };
+
+    /**
+     * Retrieves PP total sumation of the given horiz index node. 
+     * @param   {number} index 
+     * @param   {} node 
+     * @returns {number}
+     */
+    protected getPYHorizNodesTotalSumation = (index: number, node): number => {
+      return sumBy(
+        node.children,
+        `horizontalTotals[${index}].previousYear.amount`
+      )
+    }
+  };
diff --git a/packages/server/src/services/FinancialStatements/FinancialReportService.ts b/packages/server/src/services/FinancialStatements/FinancialReportService.ts
new file mode 100644
index 000000000..ad05715ff
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/FinancialReportService.ts
@@ -0,0 +1,8 @@
+export default class FinancialReportService {
+  transformOrganizationMeta(tenant) {
+    return {
+      organizationName: tenant.metadata?.name,
+      baseCurrency: tenant.metadata?.baseCurrency,
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/FinancialSchema.ts b/packages/server/src/services/FinancialStatements/FinancialSchema.ts
new file mode 100644
index 000000000..6d676ce28
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/FinancialSchema.ts
@@ -0,0 +1,24 @@
+import * as R from 'ramda';
+import { FinancialSheetStructure } from './FinancialSheetStructure';
+
+export const FinancialSchema = (Base) =>
+  class extends R.compose(FinancialSheetStructure)(Base) {
+    /**
+     *
+     * @returns
+     */
+    getSchema() {
+      return [];
+    }
+
+    /**
+     *
+     * @param {string|number} id
+     * @returns
+     */
+    getSchemaNodeById = (id: string | number) => {
+      const schema = this.getSchema();
+
+      return this.findNodeDeep(schema, (node) => node.id === id);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/FinancialSheet.ts b/packages/server/src/services/FinancialStatements/FinancialSheet.ts
new file mode 100644
index 000000000..682804bb1
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/FinancialSheet.ts
@@ -0,0 +1,177 @@
+import moment from 'moment';
+import {
+  ICashFlowStatementTotal,
+  IFormatNumberSettings,
+  INumberFormatQuery,
+} from '@/interfaces';
+import { formatNumber } from 'utils';
+
+export default class FinancialSheet {
+  readonly numberFormat: INumberFormatQuery = {
+    precision: 2,
+    divideOn1000: false,
+    showZero: false,
+    formatMoney: 'total',
+    negativeFormat: 'mines',
+  };
+  readonly baseCurrency: string;
+
+  /**
+   * Transformes the number format query to settings
+   */
+  protected transfromFormatQueryToSettings(): IFormatNumberSettings {
+    const { numberFormat } = this;
+
+    return {
+      precision: numberFormat.precision,
+      divideOn1000: numberFormat.divideOn1000,
+      excerptZero: !numberFormat.showZero,
+      negativeFormat: numberFormat.negativeFormat,
+      money: numberFormat.formatMoney === 'always',
+      currencyCode: this.baseCurrency,
+    };
+  }
+
+  /**
+   * Formating amount based on the given report query.
+   * @param  {number} number -
+   * @param  {IFormatNumberSettings} overrideSettings -
+   * @return {string}
+   */
+  protected formatNumber(
+    number,
+    overrideSettings: IFormatNumberSettings = {}
+  ): string {
+    const settings = {
+      ...this.transfromFormatQueryToSettings(),
+      ...overrideSettings,
+    };
+    return formatNumber(number, settings);
+  }
+
+  /**
+   * Formatting full amount with different format settings.
+   * @param {number} amount -
+   * @param {IFormatNumberSettings} settings -
+   */
+  protected formatTotalNumber = (
+    amount: number,
+    settings: IFormatNumberSettings = {}
+  ): string => {
+    const { numberFormat } = this;
+
+    return this.formatNumber(amount, {
+      money: numberFormat.formatMoney === 'none' ? false : true,
+      excerptZero: false,
+      ...settings,
+    });
+  };
+
+  /**
+   * Formates the amount to the percentage string.
+   * @param   {number} amount
+   * @returns {string}
+   */
+  protected formatPercentage = (
+    amount: number,
+    overrideSettings: IFormatNumberSettings = {}
+  ): string => {
+    const percentage = amount * 100;
+    const settings = {
+      excerptZero: true,
+      ...overrideSettings,
+      symbol: '%',
+      money: false,
+    };
+    return formatNumber(percentage, settings);
+  };
+
+  /**
+   * Format the given total percentage.
+   * @param {number} amount -
+   * @param {IFormatNumberSettings} settings -
+   */
+  protected formatTotalPercentage = (
+    amount: number,
+    settings: IFormatNumberSettings = {}
+  ): string => {
+    return this.formatPercentage(amount, {
+      ...settings,
+      excerptZero: false,
+    });
+  };
+
+  /**
+   * Retrieve the amount meta object.
+   * @param {number} amount
+   * @returns {ICashFlowStatementTotal}
+   */
+  protected getAmountMeta(
+    amount: number,
+    overrideSettings?: IFormatNumberSettings
+  ): ICashFlowStatementTotal {
+    return {
+      amount,
+      formattedAmount: this.formatNumber(amount, overrideSettings),
+      currencyCode: this.baseCurrency,
+    };
+  }
+
+  /**
+   * Retrieve the total amount meta object.
+   * @param {number} amount
+   * @returns {ICashFlowStatementTotal}
+   */
+  protected getTotalAmountMeta(
+    amount: number,
+    title?: string
+  ): ICashFlowStatementTotal {
+    return {
+      ...(title ? { title } : {}),
+      amount,
+      formattedAmount: this.formatTotalNumber(amount),
+      currencyCode: this.baseCurrency,
+    };
+  }
+
+  /**
+   * Retrieve the date meta.
+   * @param {Date} date
+   * @param {string} format
+   * @returns
+   */
+  protected getDateMeta(date: Date, format = 'YYYY-MM-DD') {
+    return {
+      formattedDate: moment(date).format(format),
+      date: moment(date).toDate(),
+    };
+  }
+
+  getPercentageBasis = (base, amount) => {
+    return base ? amount / base : 0;
+  };
+
+  getAmountChange = (base, amount) => {
+    return base - amount;
+  };
+
+  protected getPercentageAmountMeta = (amount) => {
+    const formattedAmount = this.formatPercentage(amount);
+
+    return {
+      amount,
+      formattedAmount,
+    };
+  };
+
+  /**
+   * Re
+   * @param {number} amount
+   * @returns
+   */
+  protected getPercentageTotalAmountMeta = (amount: number) => {
+    const formattedAmount = this.formatTotalPercentage(amount);
+
+    return { amount, formattedAmount };
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/FinancialSheetStructure.ts b/packages/server/src/services/FinancialStatements/FinancialSheetStructure.ts
new file mode 100644
index 000000000..722635d9a
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/FinancialSheetStructure.ts
@@ -0,0 +1,107 @@
+import * as R from 'ramda';
+import { set, sumBy } from 'lodash';
+import {
+  mapValuesDeepReverse,
+  mapValuesDeep,
+  mapValues,
+  condense,
+  filterDeep,
+  reduceDeep,
+  findValueDeep,
+  filterNodesDeep,
+} from 'utils/deepdash';
+
+export const FinancialSheetStructure = (Base: Class) =>
+  class extends Base {
+    /**
+     *
+     * @param nodes
+     * @param callback
+     * @returns
+     */
+    public mapNodesDeepReverse = (nodes, callback) => {
+      return mapValuesDeepReverse(nodes, callback, {
+        childrenPath: 'children',
+        pathFormat: 'array',
+      });
+    };
+
+    /**
+     *
+     * @param nodes
+     * @param callback
+     * @returns
+     */
+    public mapNodesDeep = (nodes, callback) => {
+      return mapValuesDeep(nodes, callback, {
+        childrenPath: 'children',
+        pathFormat: 'array',
+      });
+    };
+
+    public mapNodes = (nodes, callback) => {
+      return mapValues(nodes, callback, {
+        childrenPath: 'children',
+        pathFormat: 'array',
+      });
+    };
+
+    public filterNodesDeep2 = R.curry((predicate, nodes) => {
+      return filterNodesDeep(predicate, nodes);
+    });
+
+    /**
+     *
+     * @param
+     */
+    public filterNodesDeep = (nodes, callback) => {
+      return filterDeep(nodes, callback, {
+        childrenPath: 'children',
+        pathFormat: 'array',
+      });
+    };
+
+    findNodeDeep = (nodes, callback) => {
+      return findValueDeep(nodes, callback, {
+        childrenPath: 'children',
+        pathFormat: 'array',
+      });
+    };
+
+    mapAccNodesDeep = (nodes, callback) => {
+      return reduceDeep(
+        nodes,
+        (acc, value, key, parentValue, context) => {
+          set(
+            acc,
+            context.path,
+            callback(value, key, parentValue, acc, context)
+          );
+          return acc;
+        },
+        [],
+        {
+          childrenPath: 'children',
+          pathFormat: 'array',
+        }
+      );
+    };
+
+    /**
+     *
+     */
+    public reduceNodesDeep = (nodes, iteratee, accumulator) => {
+      return reduceDeep(nodes, iteratee, accumulator, {
+        childrenPath: 'children',
+        pathFormat: 'array',
+      });
+    };
+
+    getTotalOfChildrenNodes = (node) => {
+      return this.getTotalOfNodes(node.children);
+    };
+
+    getTotalOfNodes = (nodes) => {
+      return sumBy(nodes, 'total.amount');
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/FinancialTable.ts b/packages/server/src/services/FinancialStatements/FinancialTable.ts
new file mode 100644
index 000000000..20ae528a2
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/FinancialTable.ts
@@ -0,0 +1,48 @@
+import * as R from 'ramda';
+import { ITableColumn } from '@/interfaces';
+import { isEmpty, clone, cloneDeep, omit } from 'lodash';
+import { increment } from 'utils';
+import { ITableRow } from '@/interfaces';
+import { IROW_TYPE, DISPLAY_COLUMNS_BY } from './BalanceSheet/constants';
+
+export const FinancialTable = (Base) =>
+  class extends Base {
+    /**
+     * Table columns cell indexing.
+     * @param   {ITableColumn[]} columns
+     * @returns {ITableColumn[]}
+     */
+    protected tableColumnsCellIndexing = (
+      columns: ITableColumn[]
+    ): ITableColumn[] => {
+      const cellIndex = increment(-1);
+
+      return this.mapNodesDeep(columns, (column) => {
+        return isEmpty(column.children)
+          ? R.assoc('cellIndex', cellIndex(), column)
+          : column;
+      });
+    };
+
+    addTotalRow = (node: ITableRow) => {
+      const clonedNode = clone(node);
+
+      if (clonedNode.children) {
+        const cells = cloneDeep(node.cells);
+        cells[0].value = this.i18n.__('financial_sheet.total_row', {
+          value: cells[0].value,
+        });
+
+        clonedNode.children.push({
+          ...omit(clonedNode, 'children'),
+          cells,
+          rowTypes: [IROW_TYPE.TOTAL],
+        });
+      }
+      return clonedNode;
+    };
+
+    private addTotalRows = (nodes: ITableRow[]) => {
+      return this.mapNodesDeep(nodes, this.addTotalRow);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/FinancialTablePreviousPeriod.ts b/packages/server/src/services/FinancialStatements/FinancialTablePreviousPeriod.ts
new file mode 100644
index 000000000..107431340
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/FinancialTablePreviousPeriod.ts
@@ -0,0 +1,130 @@
+import moment from 'moment';
+import { ITableColumn, IDateRange, ITableColumnAccessor } from '@/interfaces';
+
+export const FinancialTablePreviousPeriod = (Base) =>
+  class extends Base {
+    getTotalPreviousPeriod = () => {
+      return this.query.PPToDate;
+    };
+    // ----------------------------
+    // # Columns
+    // ----------------------------
+    /**
+     * Retrive previous period total column.
+     * @param   {IDateRange} dateRange -
+     * @returns {ITableColumn}
+     */
+    protected getPreviousPeriodTotalColumn = (
+      dateRange?: IDateRange
+    ): ITableColumn => {
+      const PPDate = dateRange
+        ? dateRange.toDate
+        : this.getTotalPreviousPeriod();
+      const PPFormatted = moment(PPDate).format('YYYY-MM-DD');
+
+      return {
+        key: 'previous_period',
+        label: this.i18n.__(`financial_sheet.previoud_period_date`, {
+          date: PPFormatted,
+        }),
+      };
+    };
+
+    /**
+     * Retrieve previous period change column.
+     * @returns {ITableColumn}
+     */
+    protected getPreviousPeriodChangeColumn = (): ITableColumn => {
+      return {
+        key: 'previous_period_change',
+        label: this.i18n.__('fianncial_sheet.previous_period_change'),
+      };
+    };
+
+    /**
+     * Retrieve previous period percentage column.
+     * @returns {ITableColumn}
+     */
+    protected getPreviousPeriodPercentageColumn = (): ITableColumn => {
+      return {
+        key: 'previous_period_percentage',
+        label: this.i18n.__('financial_sheet.previous_period_percentage'),
+      };
+    };
+
+    /**
+     * Retrieves previous period total accessor.
+     * @returns {ITableColumnAccessor}
+     */
+    protected getPreviousPeriodTotalAccessor = (): ITableColumnAccessor => {
+      return {
+        key: 'previous_period',
+        accessor: 'previousPeriod.formattedAmount',
+      };
+    };
+
+    /**
+     * Retrieves previous period change accessor.
+     * @returns
+     */
+    protected getPreviousPeriodChangeAccessor = () => {
+      return {
+        key: 'previous_period_change',
+        accessor: 'previousPeriodChange.formattedAmount',
+      };
+    };
+
+    /**
+     * Retrieves previous period percentage accessor.
+     * @returns {ITableColumnAccessor}
+     */
+    protected getPreviousPeriodPercentageAccessor =
+      (): ITableColumnAccessor => {
+        return {
+          key: 'previous_period_percentage',
+          accessor: 'previousPeriodPercentage.formattedAmount',
+        };
+      };
+
+    /**
+     * Retrieves previous period total horizontal column accessor.
+     * @param   {number} index
+     * @returns {ITableColumnAccessor}
+     */
+    protected getPreviousPeriodTotalHorizAccessor = (
+      index: number
+    ): ITableColumnAccessor => {
+      return {
+        key: 'previous_period',
+        accessor: `horizontalTotals[${index}].previousPeriod.formattedAmount`,
+      };
+    };
+
+    /**
+     * Retrieves previous period change horizontal column accessor.
+     * @param   {number} index
+     * @returns {ITableColumnAccessor}
+     */
+    protected getPreviousPeriodChangeHorizAccessor = (
+      index: number
+    ): ITableColumnAccessor => {
+      return {
+        key: 'previous_period_change',
+        accessor: `horizontalTotals[${index}].previousPeriodChange.formattedAmount`,
+      };
+    };
+
+    /**
+     * Retrieves pervious period percentage horizontal column accessor.
+     * @param   {number} index
+     * @returns {ITableColumnAccessor}
+     */
+    protected getPreviousPeriodPercentageHorizAccessor = (
+      index: number
+    ): ITableColumnAccessor => {
+      return {
+        key: 'previous_period_percentage',
+        accessor: `horizontalTotals[${index}].previousPeriodPercentage.formattedAmount`,
+      };
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/FinancialTablePreviousYear.ts b/packages/server/src/services/FinancialStatements/FinancialTablePreviousYear.ts
new file mode 100644
index 000000000..4924926d6
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/FinancialTablePreviousYear.ts
@@ -0,0 +1,130 @@
+import moment from 'moment';
+import { IDateRange, ITableColumn, ITableColumnAccessor } from '@/interfaces';
+
+export const FinancialTablePreviousYear = (Base) =>
+  class extends Base {
+    getTotalPreviousYear = () => {
+      return this.query.PYToDate;
+    };
+    // ------------------------------------
+    // # Columns.
+    // ------------------------------------
+    /**
+     * Retrive previous year total column.
+     * @param   {DateRange} previousYear -
+     * @returns {ITableColumn}
+     */
+    protected getPreviousYearTotalColumn = (
+      dateRange?: IDateRange
+    ): ITableColumn => {
+      const PYDate = dateRange ? dateRange.toDate : this.getTotalPreviousYear();
+      const PYFormatted = moment(PYDate).format('YYYY-MM-DD');
+
+      return {
+        key: 'previous_year',
+        label: this.i18n.__('financial_sheet.previous_year_date', {
+          date: PYFormatted,
+        }),
+      };
+    };
+
+    /**
+     * Retrieve previous year change column.
+     * @returns {ITableColumn}
+     */
+    protected getPreviousYearChangeColumn = (): ITableColumn => {
+      return {
+        key: 'previous_year_change',
+        label: this.i18n.__('financial_sheet.previous_year_change'),
+      };
+    };
+
+    /**
+     * Retrieve previous year percentage column.
+     * @returns {ITableColumn}
+     */
+    protected getPreviousYearPercentageColumn = (): ITableColumn => {
+      return {
+        key: 'previous_year_percentage',
+        label: this.i18n.__('financial_sheet.previous_year_percentage'),
+      };
+    };
+
+    // ------------------------------------
+    // # Accessors.
+    // ------------------------------------
+    /**
+     * Retrieves previous year total column accessor.
+     * @returns {ITableColumnAccessor}
+     */
+    protected getPreviousYearTotalAccessor = (): ITableColumnAccessor => {
+      return {
+        key: 'previous_year',
+        accessor: 'previousYear.formattedAmount',
+      };
+    };
+
+    /**
+     * Retrieves previous year change column accessor.
+     * @returns {ITableColumnAccessor}
+     */
+    protected getPreviousYearChangeAccessor = (): ITableColumnAccessor => {
+      return {
+        key: 'previous_year_change',
+        accessor: 'previousYearChange.formattedAmount',
+      };
+    };
+
+    /**
+     * Retrieves previous year percentage column accessor.
+     * @returns {ITableColumnAccessor}
+     */
+    protected getPreviousYearPercentageAccessor = (): ITableColumnAccessor => {
+      return {
+        key: 'previous_year_percentage',
+        accessor: 'previousYearPercentage.formattedAmount',
+      };
+    };
+
+    /**
+     * Retrieves previous year total horizontal column accessor.
+     * @param   {number} index
+     * @returns {ITableColumnAccessor}
+     */
+    protected getPreviousYearTotalHorizAccessor = (
+      index: number
+    ): ITableColumnAccessor => {
+      return {
+        key: 'previous_year',
+        accessor: `horizontalTotals[${index}].previousYear.formattedAmount`,
+      };
+    };
+
+    /**
+     * Retrieves previous previous year change horizontal column accessor.
+     * @param   {number} index
+     * @returns {ITableColumnAccessor}
+     */
+    protected getPreviousYearChangeHorizAccessor = (
+      index: number
+    ): ITableColumnAccessor => {
+      return {
+        key: 'previous_year_change',
+        accessor: `horizontalTotals[${index}].previousYearChange.formattedAmount`,
+      };
+    };
+
+    /**
+     * Retrieves previous year percentage horizontal column accessor.
+     * @param   {number} index
+     * @returns {ITableColumnAccessor}
+     */
+    protected getPreviousYearPercentageHorizAccessor = (
+      index: number
+    ): ITableColumnAccessor => {
+      return {
+        key: 'previous_year_percentage',
+        accessor: `horizontalTotals[${index}].previousYearPercentage.formattedAmount`,
+      };
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/GeneralLedger/GeneralLedger.ts b/packages/server/src/services/FinancialStatements/GeneralLedger/GeneralLedger.ts
new file mode 100644
index 000000000..512ed37d7
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/GeneralLedger/GeneralLedger.ts
@@ -0,0 +1,240 @@
+import { isEmpty, get, last, sumBy } from 'lodash';
+import {
+  IGeneralLedgerSheetQuery,
+  IGeneralLedgerSheetAccount,
+  IGeneralLedgerSheetAccountBalance,
+  IGeneralLedgerSheetAccountTransaction,
+  IAccount,
+  IJournalPoster,
+  IJournalEntry,
+  IContact,
+} from '@/interfaces';
+import FinancialSheet from '../FinancialSheet';
+
+/**
+ * General ledger sheet.
+ */
+export default class GeneralLedgerSheet extends FinancialSheet {
+  tenantId: number;
+  accounts: IAccount[];
+  query: IGeneralLedgerSheetQuery;
+  openingBalancesJournal: IJournalPoster;
+  transactions: IJournalPoster;
+  contactsMap: Map<number, IContact>;
+  baseCurrency: string;
+  i18n: any;
+
+  /**
+   * Constructor method.
+   * @param {number} tenantId -
+   * @param {IAccount[]} accounts -
+   * @param {IJournalPoster} transactions -
+   * @param {IJournalPoster} openingBalancesJournal -
+   * @param {IJournalPoster} closingBalancesJournal -
+   */
+  constructor(
+    tenantId: number,
+    query: IGeneralLedgerSheetQuery,
+    accounts: IAccount[],
+    contactsByIdMap: Map<number, IContact>,
+    transactions: IJournalPoster,
+    openingBalancesJournal: IJournalPoster,
+    baseCurrency: string,
+    i18n
+  ) {
+    super();
+
+    this.tenantId = tenantId;
+    this.query = query;
+    this.numberFormat = this.query.numberFormat;
+    this.accounts = accounts;
+    this.contactsMap = contactsByIdMap;
+    this.transactions = transactions;
+    this.openingBalancesJournal = openingBalancesJournal;
+    this.baseCurrency = baseCurrency;
+    this.i18n = i18n;
+  }
+
+  /**
+   * Retrieve the transaction amount.
+   * @param {number} credit - Credit amount.
+   * @param {number} debit - Debit amount.
+   * @param {string} normal - Credit or debit.
+   */
+  getAmount(credit: number, debit: number, normal: string) {
+    return normal === 'credit' ? credit - debit : debit - credit;
+  }
+
+  /**
+   * Entry mapper.
+   * @param {IJournalEntry} entry -
+   * @return {IGeneralLedgerSheetAccountTransaction}
+   */
+  entryReducer(
+    entries: IGeneralLedgerSheetAccountTransaction[],
+    entry: IJournalEntry,
+    openingBalance: number
+  ): IGeneralLedgerSheetAccountTransaction[] {
+    const lastEntry = last(entries);
+
+    const contact = this.contactsMap.get(entry.contactId);
+    const amount = this.getAmount(
+      entry.credit,
+      entry.debit,
+      entry.accountNormal
+    );
+    const runningBalance =
+      amount + (!isEmpty(entries) ? lastEntry.runningBalance : openingBalance);
+
+    const newEntry = {
+      date: entry.date,
+      entryId: entry.id,
+
+      referenceType: entry.referenceType,
+      referenceId: entry.referenceId,
+      referenceTypeFormatted: this.i18n.__(entry.referenceTypeFormatted),
+
+      contactName: get(contact, 'displayName'),
+      contactType: get(contact, 'contactService'),
+
+      transactionType: entry.transactionType,
+      index: entry.index,
+      note: entry.note,
+
+      credit: entry.credit,
+      debit: entry.debit,
+      amount,
+      runningBalance,
+
+      formattedAmount: this.formatNumber(amount),
+      formattedCredit: this.formatNumber(entry.credit),
+      formattedDebit: this.formatNumber(entry.debit),
+      formattedRunningBalance: this.formatNumber(runningBalance),
+
+      currencyCode: this.baseCurrency,
+    };
+    entries.push(newEntry);
+
+    return entries;
+  }
+
+  /**
+   * Mapping the account transactions to general ledger transactions of the given account.
+   * @param {IAccount} account
+   * @return {IGeneralLedgerSheetAccountTransaction[]}
+   */
+  private accountTransactionsMapper(
+    account: IAccount,
+    openingBalance: number
+  ): IGeneralLedgerSheetAccountTransaction[] {
+    const entries = this.transactions.getAccountEntries(account.id);
+
+    return entries.reduce(
+      (
+        entries: IGeneralLedgerSheetAccountTransaction[],
+        entry: IJournalEntry
+      ) => {
+        return this.entryReducer(entries, entry, openingBalance);
+      },
+      []
+    );
+  }
+
+  /**
+   * Retrieve account opening balance.
+   * @param {IAccount} account
+   * @return {IGeneralLedgerSheetAccountBalance}
+   */
+  private accountOpeningBalance(
+    account: IAccount
+  ): IGeneralLedgerSheetAccountBalance {
+    const amount = this.openingBalancesJournal.getAccountBalance(account.id);
+    const formattedAmount = this.formatTotalNumber(amount);
+    const currencyCode = this.baseCurrency;
+    const date = this.query.fromDate;
+
+    return { amount, formattedAmount, currencyCode, date };
+  }
+
+  /**
+   * Retrieve account closing balance.
+   * @param {IAccount} account
+   * @return {IGeneralLedgerSheetAccountBalance}
+   */
+  private accountClosingBalance(
+    openingBalance: number,
+    transactions: IGeneralLedgerSheetAccountTransaction[]
+  ): IGeneralLedgerSheetAccountBalance {
+    const amount = this.calcClosingBalance(openingBalance, transactions);
+    const formattedAmount = this.formatTotalNumber(amount);
+    const currencyCode = this.baseCurrency;
+    const date = this.query.toDate;
+
+    return { amount, formattedAmount, currencyCode, date };
+  }
+
+  private calcClosingBalance(
+    openingBalance: number,
+    transactions: IGeneralLedgerSheetAccountTransaction[]
+  ) {
+    return openingBalance + sumBy(transactions, (trans) => trans.amount);
+  }
+
+  /**
+   * Retreive general ledger accounts sections.
+   * @param {IAccount} account
+   * @return {IGeneralLedgerSheetAccount}
+   */
+  private accountMapper(account: IAccount): IGeneralLedgerSheetAccount {
+    const openingBalance = this.accountOpeningBalance(account);
+
+    const transactions = this.accountTransactionsMapper(
+      account,
+      openingBalance.amount
+    );
+    const closingBalance = this.accountClosingBalance(
+      openingBalance.amount,
+      transactions
+    );
+
+    return {
+      id: account.id,
+      name: account.name,
+      code: account.code,
+      index: account.index,
+      parentAccountId: account.parentAccountId,
+      openingBalance,
+      transactions,
+      closingBalance,
+    };
+  }
+
+  /**
+   * Retrieve mapped accounts with general ledger transactions and opeing/closing balance.
+   * @param {IAccount[]} accounts -
+   * @return {IGeneralLedgerSheetAccount[]}
+   */
+  private accountsWalker(accounts: IAccount[]): IGeneralLedgerSheetAccount[] {
+    return (
+      accounts
+        .map((account: IAccount) => this.accountMapper(account))
+        // Filter general ledger accounts that have no transactions
+        // when`noneTransactions` is on.
+        .filter(
+          (generalLedgerAccount: IGeneralLedgerSheetAccount) =>
+            !(
+              generalLedgerAccount.transactions.length === 0 &&
+              this.query.noneTransactions
+            )
+        )
+    );
+  }
+
+  /**
+   * Retrieve general ledger report data.
+   * @return {IGeneralLedgerSheetAccount[]}
+   */
+  public reportData(): IGeneralLedgerSheetAccount[] {
+    return this.accountsWalker(this.accounts);
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/GeneralLedger/GeneralLedgerService.ts b/packages/server/src/services/FinancialStatements/GeneralLedger/GeneralLedgerService.ts
new file mode 100644
index 000000000..74633d81e
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/GeneralLedger/GeneralLedgerService.ts
@@ -0,0 +1,172 @@
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import { ServiceError } from '@/exceptions';
+import { difference } from 'lodash';
+import { IGeneralLedgerSheetQuery, IGeneralLedgerMeta } from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import Journal from '@/services/Accounting/JournalPoster';
+import GeneralLedgerSheet from '@/services/FinancialStatements/GeneralLedger/GeneralLedger';
+import InventoryService from '@/services/Inventory/Inventory';
+import { transformToMap, parseBoolean } from 'utils';
+import { Tenant } from '@/system/models';
+
+const ERRORS = {
+  ACCOUNTS_NOT_FOUND: 'ACCOUNTS_NOT_FOUND',
+};
+
+@Service()
+export default class GeneralLedgerService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  inventoryService: InventoryService;
+
+  @Inject('logger')
+  logger: any;
+
+  /**
+   * Defaults general ledger report filter query.
+   * @return {IBalanceSheetQuery}
+   */
+  get defaultQuery() {
+    return {
+      fromDate: moment().startOf('year').format('YYYY-MM-DD'),
+      toDate: moment().endOf('year').format('YYYY-MM-DD'),
+      basis: 'cash',
+      numberFormat: {
+        noCents: false,
+        divideOn1000: false,
+      },
+      noneZero: false,
+      accountsIds: [],
+    };
+  }
+
+  /**
+   * Validates accounts existance on the storage.
+   * @param {number} tenantId
+   * @param {number[]} accountsIds
+   */
+  async validateAccountsExistance(tenantId: number, accountsIds: number[]) {
+    const { Account } = this.tenancy.models(tenantId);
+
+    const storedAccounts = await Account.query().whereIn('id', accountsIds);
+    const storedAccountsIds = storedAccounts.map((a) => a.id);
+
+    if (difference(accountsIds, storedAccountsIds).length > 0) {
+      throw new ServiceError(ERRORS.ACCOUNTS_NOT_FOUND);
+    }
+  }
+
+  /**
+   * Retrieve the balance sheet meta.
+   * @param {number} tenantId - 
+   * @returns {IGeneralLedgerMeta}
+   */
+   reportMetadata(tenantId: number): IGeneralLedgerMeta {
+    const settings = this.tenancy.settings(tenantId);
+
+    const isCostComputeRunning = this.inventoryService
+      .isItemsCostComputeRunning(tenantId);
+
+    const organizationName = settings.get({
+      group: 'organization',
+      key: 'name',
+    });
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+
+    return {
+      isCostComputeRunning: parseBoolean(isCostComputeRunning, false),
+      organizationName,
+      baseCurrency
+    };
+  }
+
+  /**
+   * Retrieve general ledger report statement.
+   * ----------
+   * @param {number} tenantId
+   * @param {IGeneralLedgerSheetQuery} query
+   * @return {IGeneralLedgerStatement}
+   */
+  async generalLedger(
+    tenantId: number,
+    query: IGeneralLedgerSheetQuery
+  ): Promise<{
+    data: any;
+    query: IGeneralLedgerSheetQuery;
+    meta: IGeneralLedgerMeta
+  }> {
+    const {
+      accountRepository,
+      transactionsRepository,
+      contactRepository
+    } = this.tenancy.repositories(tenantId);
+
+    const i18n = this.tenancy.i18n(tenantId);
+
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const filter = {
+      ...this.defaultQuery,
+      ...query,
+    };
+    // Retrieve all accounts with associated type from the storage.
+    const accounts = await accountRepository.all();
+    const accountsGraph = await accountRepository.getDependencyGraph();
+
+    // Retrieve all contacts on the storage.
+    const contacts = await contactRepository.all();
+    const contactsByIdMap = transformToMap(contacts, 'id');
+
+    // Retreive journal transactions from/to the given date.
+    const transactions = await transactionsRepository.journal({
+      fromDate: filter.fromDate,
+      toDate: filter.toDate,
+      branchesIds: filter.branchesIds
+    });
+    // Retreive opening balance credit/debit sumation.
+    const openingBalanceTrans = await transactionsRepository.journal({
+      toDate: moment(filter.fromDate).subtract(1, 'day'),
+      sumationCreditDebit: true,
+      branchesIds: filter.branchesIds
+    });
+    // Transform array transactions to journal collection.
+    const transactionsJournal = Journal.fromTransactions(
+      transactions,
+      tenantId,
+      accountsGraph
+    );
+    // Accounts opening transactions. 
+    const openingTransJournal = Journal.fromTransactions(
+      openingBalanceTrans,
+      tenantId,
+      accountsGraph
+    );
+    // General ledger report instance.
+    const generalLedgerInstance = new GeneralLedgerSheet(
+      tenantId,
+      filter,
+      accounts,
+      contactsByIdMap,
+      transactionsJournal,
+      openingTransJournal,
+      tenant.metadata.baseCurrency,
+      i18n
+    );
+    // Retrieve general ledger report data.
+    const reportData = generalLedgerInstance.reportData();
+
+    return {
+      data: reportData,
+      query: filter,
+      meta: this.reportMetadata(tenantId),
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/InventoryDetails/InventoryDetails.ts b/packages/server/src/services/FinancialStatements/InventoryDetails/InventoryDetails.ts
new file mode 100644
index 000000000..c626441e3
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/InventoryDetails/InventoryDetails.ts
@@ -0,0 +1,433 @@
+import * as R from 'ramda';
+import { defaultTo, sumBy, get } from 'lodash';
+import moment from 'moment';
+import {
+  IInventoryDetailsQuery,
+  IItem,
+  IInventoryTransaction,
+  TInventoryTransactionDirection,
+  IInventoryDetailsNumber,
+  IInventoryDetailsDate,
+  IInventoryDetailsData,
+  IInventoryDetailsItem,
+  IInventoryDetailsClosing,
+  INumberFormatQuery,
+  IInventoryDetailsOpening,
+  IInventoryDetailsItemTransaction,
+  IFormatNumberSettings,
+} from '@/interfaces';
+import FinancialSheet from '../FinancialSheet';
+import { transformToMapBy, transformToMapKeyValue } from 'utils';
+import { filterDeep } from 'utils/deepdash';
+
+const MAP_CONFIG = { childrenPath: 'children', pathFormat: 'array' };
+
+enum INodeTypes {
+  ITEM = 'item',
+  TRANSACTION = 'transaction',
+  OPENING_ENTRY = 'OPENING_ENTRY',
+  CLOSING_ENTRY = 'CLOSING_ENTRY',
+}
+
+export default class InventoryDetails extends FinancialSheet {
+  readonly inventoryTransactionsByItemId: Map<number, IInventoryTransaction[]>;
+  readonly openingBalanceTransactions: Map<number, IInventoryTransaction>;
+  readonly query: IInventoryDetailsQuery;
+  readonly numberFormat: INumberFormatQuery;
+  readonly baseCurrency: string;
+  readonly items: IItem[];
+
+  /**
+   * Constructor method.
+   * @param {IItem[]} items - Items.
+   * @param {IInventoryTransaction[]} inventoryTransactions - Inventory transactions.
+   * @param {IInventoryDetailsQuery} query - Report query.
+   * @param {string} baseCurrency - The base currency.
+   */
+  constructor(
+    items: IItem[],
+    openingBalanceTransactions: IInventoryTransaction[],
+    inventoryTransactions: IInventoryTransaction[],
+    query: IInventoryDetailsQuery,
+    baseCurrency: string,
+    i18n: any
+  ) {
+    super();
+
+    this.inventoryTransactionsByItemId = transformToMapBy(
+      inventoryTransactions,
+      'itemId'
+    );
+    this.openingBalanceTransactions = transformToMapKeyValue(
+      openingBalanceTransactions,
+      'itemId'
+    );
+    this.query = query;
+    this.numberFormat = this.query.numberFormat;
+    this.items = items;
+    this.baseCurrency = baseCurrency;
+    this.i18n = i18n;
+  }
+
+  /**
+   * Retrieve the number meta.
+   * @param {number} number
+   * @returns
+   */
+  private getNumberMeta(
+    number: number,
+    settings?: IFormatNumberSettings
+  ): IInventoryDetailsNumber {
+    return {
+      formattedNumber: this.formatNumber(number, {
+        excerptZero: true,
+        money: false,
+        ...settings,
+      }),
+      number: number,
+    };
+  }
+
+  /**
+   * Retrieve the total number meta.
+   * @param {number} number -
+   * @param {IFormatNumberSettings} settings -
+   * @retrun {IInventoryDetailsNumber}
+   */
+  private getTotalNumberMeta(
+    number: number,
+    settings?: IFormatNumberSettings
+  ): IInventoryDetailsNumber {
+    return this.getNumberMeta(number, { excerptZero: false, ...settings });
+  }
+
+  /**
+   * Retrieve the date meta.
+   * @param {Date|string} date
+   * @returns {IInventoryDetailsDate}
+   */
+  private getDateMeta(date: Date | string): IInventoryDetailsDate {
+    return {
+      formattedDate: moment(date).format('YYYY-MM-DD'),
+      date: moment(date).toDate(),
+    };
+  }
+
+  /**
+   * Adjusts the movement amount.
+   * @param {number} amount
+   * @param {TInventoryTransactionDirection} direction
+   * @returns {number}
+   */
+  private adjustAmountMovement = R.curry(
+    (direction: TInventoryTransactionDirection, amount: number): number => {
+      return direction === 'OUT' ? amount * -1 : amount;
+    }
+  );
+
+  /**
+   * Accumlate and mapping running quantity on transactions.
+   * @param {IInventoryDetailsItemTransaction[]} transactions
+   * @returns {IInventoryDetailsItemTransaction[]}
+   */
+  private mapAccumTransactionsRunningQuantity(
+    transactions: IInventoryDetailsItemTransaction[]
+  ): IInventoryDetailsItemTransaction[] {
+    const initial = this.getNumberMeta(0);
+
+    const mapAccumAppender = (a, b) => {
+      const total = a.runningQuantity.number + b.quantityMovement.number;
+      const totalMeta = this.getNumberMeta(total, { excerptZero: false });
+      const accum = { ...b, runningQuantity: totalMeta };
+
+      return [accum, accum];
+    };
+    return R.mapAccum(
+      mapAccumAppender,
+      { runningQuantity: initial },
+      transactions
+    )[1];
+  }
+
+  /**
+   * Accumlate and mapping running valuation on transactions.
+   * @param {IInventoryDetailsItemTransaction[]} transactions
+   * @returns {IInventoryDetailsItemTransaction}
+   */
+  private mapAccumTransactionsRunningValuation(
+    transactions: IInventoryDetailsItemTransaction[]
+  ): IInventoryDetailsItemTransaction[] {
+    const initial = this.getNumberMeta(0);
+
+    const mapAccumAppender = (a, b) => {
+      const adjusmtent = b.direction === 'OUT' ? -1 : 1;
+      const total = a.runningValuation.number + b.cost.number * adjusmtent;
+      const totalMeta = this.getNumberMeta(total, { excerptZero: false });
+      const accum = { ...b, runningValuation: totalMeta };
+
+      return [accum, accum];
+    };
+    return R.mapAccum(
+      mapAccumAppender,
+      { runningValuation: initial },
+      transactions
+    )[1];
+  }
+
+  /**
+   * Retrieve the inventory transaction total.
+   * @param {IInventoryTransaction} transaction
+   * @returns {number}
+   */
+  private getTransactionTotal = (transaction: IInventoryTransaction) => {
+    return transaction.quantity
+      ? transaction.quantity * transaction.rate
+      : transaction.rate;
+  };
+
+  /**
+   * Mappes the item transaction to inventory item transaction node.
+   * @param {IItem} item
+   * @param {IInvetoryTransaction} transaction
+   * @returns {IInventoryDetailsItemTransaction}
+   */
+  private itemTransactionMapper(
+    item: IItem,
+    transaction: IInventoryTransaction
+  ): IInventoryDetailsItemTransaction {
+    const total = this.getTransactionTotal(transaction);
+    const amountMovement = this.adjustAmountMovement(transaction.direction);
+
+    // Quantity movement.
+    const quantityMovement = amountMovement(transaction.quantity);
+    const cost = get(transaction, 'costLotAggregated.cost', 0);
+
+    // Profit margin.
+    const profitMargin = total - cost;
+
+    // Value from computed cost in `OUT` or from total sell price in `IN` transaction.
+    const value = transaction.direction === 'OUT' ? cost : total;
+
+    // Value movement depends on transaction direction.
+    const valueMovement = amountMovement(value);
+
+    return {
+      nodeType: INodeTypes.TRANSACTION,
+      date: this.getDateMeta(transaction.date),
+      transactionType: this.i18n.__(transaction.transcationTypeFormatted),
+      transactionNumber: transaction?.meta?.transactionNumber,
+      direction: transaction.direction,
+
+      quantityMovement: this.getNumberMeta(quantityMovement),
+      valueMovement: this.getNumberMeta(valueMovement),
+
+      quantity: this.getNumberMeta(transaction.quantity),
+      total: this.getNumberMeta(total),
+
+      rate: this.getNumberMeta(transaction.rate),
+      cost: this.getNumberMeta(cost),
+      value: this.getNumberMeta(value),
+
+      profitMargin: this.getNumberMeta(profitMargin),
+
+      runningQuantity: this.getNumberMeta(0),
+      runningValuation: this.getNumberMeta(0),
+    };
+  }
+
+  /**
+   * Retrieve the inventory transcations by item id.
+   * @param {number} itemId
+   * @returns {IInventoryTransaction[]}
+   */
+  private getInventoryTransactionsByItemId(
+    itemId: number
+  ): IInventoryTransaction[] {
+    return defaultTo(this.inventoryTransactionsByItemId.get(itemId + ''), []);
+  }
+
+  /**
+   * Retrieve the item transaction node by the given item.
+   * @param {IItem} item
+   * @returns {IInventoryDetailsItemTransaction[]}
+   */
+  private getItemTransactions(item: IItem): IInventoryDetailsItemTransaction[] {
+    const transactions = this.getInventoryTransactionsByItemId(item.id);
+
+    return R.compose(
+      this.mapAccumTransactionsRunningQuantity.bind(this),
+      this.mapAccumTransactionsRunningValuation.bind(this),
+      R.map(R.curry(this.itemTransactionMapper.bind(this))(item))
+    )(transactions);
+  }
+
+  /**
+   * Mappes the given item transactions.
+   * @param {IItem} item -
+   * @returns {(
+   *    IInventoryDetailsItemTransaction
+   *  | IInventoryDetailsOpening
+   *  | IInventoryDetailsClosing
+   *  )[]}
+   */
+  private itemTransactionsMapper(
+    item: IItem
+  ): (
+    | IInventoryDetailsItemTransaction
+    | IInventoryDetailsOpening
+    | IInventoryDetailsClosing
+  )[] {
+    const transactions = this.getItemTransactions(item);
+    const openingValuation = this.getItemOpeingValuation(item);
+    const closingValuation = this.getItemClosingValuation(
+      item,
+      transactions,
+      openingValuation
+    );
+    const hasTransactions = transactions.length > 0;
+    const isItemHasOpeningBalance = this.isItemHasOpeningBalance(item.id);
+
+    return R.pipe(
+      R.concat(transactions),
+      R.when(R.always(isItemHasOpeningBalance), R.prepend(openingValuation)),
+      R.when(R.always(hasTransactions), R.append(closingValuation))
+    )([]);
+  }
+
+  /**
+   * Detarmines the given item has opening balance transaction.
+   * @param {number} itemId - Item id.
+   * @return {boolean}
+   */
+  private isItemHasOpeningBalance(itemId: number): boolean {
+    return !!this.openingBalanceTransactions.get(itemId);
+  }
+
+  /**
+   * Retrieve the given item opening valuation.
+   * @param {IItem} item -
+   * @returns {IInventoryDetailsOpening}
+   */
+  private getItemOpeingValuation(item: IItem): IInventoryDetailsOpening {
+    const openingBalance = this.openingBalanceTransactions.get(item.id);
+    const quantity = defaultTo(get(openingBalance, 'quantity'), 0);
+    const value = defaultTo(get(openingBalance, 'value'), 0);
+
+    return {
+      nodeType: INodeTypes.OPENING_ENTRY,
+      date: this.getDateMeta(this.query.fromDate),
+      quantity: this.getTotalNumberMeta(quantity),
+      value: this.getTotalNumberMeta(value),
+    };
+  }
+
+  /**
+   * Retrieve the given item closing valuation.
+   * @param {IItem} item -
+   * @returns {IInventoryDetailsOpening}
+   */
+  private getItemClosingValuation(
+    item: IItem,
+    transactions: IInventoryDetailsItemTransaction[],
+    openingValuation: IInventoryDetailsOpening
+  ): IInventoryDetailsOpening {
+    const value = sumBy(transactions, 'valueMovement.number');
+    const quantity = sumBy(transactions, 'quantityMovement.number');
+    const profitMargin = sumBy(transactions, 'profitMargin.number');
+
+    const closingQuantity = quantity + openingValuation.quantity.number;
+    const closingValue = value + openingValuation.value.number;
+
+    return {
+      nodeType: INodeTypes.CLOSING_ENTRY,
+      date: this.getDateMeta(this.query.toDate),
+      quantity: this.getTotalNumberMeta(closingQuantity),
+      value: this.getTotalNumberMeta(closingValue),
+      profitMargin: this.getTotalNumberMeta(profitMargin),
+    };
+  }
+
+  /**
+   * Retrieve the item node of the report.
+   * @param {IItem} item
+   * @returns {IInventoryDetailsItem}
+   */
+  private itemsNodeMapper(item: IItem): IInventoryDetailsItem {
+    return {
+      id: item.id,
+      name: item.name,
+      code: item.code,
+      nodeType: INodeTypes.ITEM,
+      children: this.itemTransactionsMapper(item),
+    };
+  }
+
+  /**
+   * Detarmines the given node equals the given type.
+   * @param {string} nodeType
+   * @param {IItem} node
+   * @returns {boolean}
+   */
+  private isNodeTypeEquals(
+    nodeType: string,
+    node: IInventoryDetailsItem
+  ): boolean {
+    return nodeType === node.nodeType;
+  }
+
+  /**
+   * Detarmines whether the given item node has transactions.
+   * @param {IInventoryDetailsItem} item
+   * @returns {boolean}
+   */
+  private isItemNodeHasTransactions(item: IInventoryDetailsItem) {
+    return !!this.inventoryTransactionsByItemId.get(item.id);
+  }
+
+  /**
+   * Detarmines the filter
+   * @param {IInventoryDetailsItem} item
+   * @return {boolean}
+   */
+  private isFilterNode(item: IInventoryDetailsItem): boolean {
+    return R.ifElse(
+      R.curry(this.isNodeTypeEquals)(INodeTypes.ITEM),
+      this.isItemNodeHasTransactions.bind(this),
+      R.always(true)
+    )(item);
+  }
+
+  /**
+   * Filters items nodes.
+   * @param {IInventoryDetailsItem[]} items -
+   * @returns {IInventoryDetailsItem[]}
+   */
+  private filterItemsNodes(items: IInventoryDetailsItem[]) {
+    const filtered = filterDeep(
+      items,
+      this.isFilterNode.bind(this),
+      MAP_CONFIG
+    );
+    return defaultTo(filtered, []);
+  }
+
+  /**
+   * Retrieve the items nodes of the report.
+   * @param {IItem} items
+   * @returns {IInventoryDetailsItem[]}
+   */
+  private itemsNodes(items: IItem[]): IInventoryDetailsItem[] {
+    return R.compose(
+      this.filterItemsNodes.bind(this),
+      R.map(this.itemsNodeMapper.bind(this))
+    )(items);
+  }
+
+  /**
+   * Retrieve the inventory item details report data.
+   * @returns {IInventoryDetailsData}
+   */
+  public reportData(): IInventoryDetailsData {
+    return this.itemsNodes(this.items);
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/InventoryDetails/InventoryDetailsRepository.ts b/packages/server/src/services/FinancialStatements/InventoryDetails/InventoryDetailsRepository.ts
new file mode 100644
index 000000000..05a4f26a8
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/InventoryDetails/InventoryDetailsRepository.ts
@@ -0,0 +1,120 @@
+import { Inject } from 'typedi';
+import { raw } from 'objection';
+import { isEmpty } from 'lodash';
+import moment from 'moment';
+import {
+  IItem,
+  IInventoryDetailsQuery,
+  IInventoryTransaction,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+export default class InventoryDetailsRepository {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve inventory items.
+   * @param {number} tenantId -
+   * @returns {Promise<IItem>}
+   */
+  public getInventoryItems(
+    tenantId: number,
+    itemsIds?: number[]
+  ): Promise<IItem[]> {
+    const { Item } = this.tenancy.models(tenantId);
+
+    return Item.query().onBuild((q) => {
+      q.where('type', 'inventory');
+
+      if (!isEmpty(itemsIds)) {
+        q.whereIn('id', itemsIds);
+      }
+    });
+  }
+
+  /**
+   * Retrieve the items opening balance transactions.
+   * @param {number} tenantId -
+   * @param {IInventoryDetailsQuery}
+   * @return {Promise<IInventoryTransaction>}
+   */
+  public async openingBalanceTransactions(
+    tenantId: number,
+    filter: IInventoryDetailsQuery
+  ): Promise<IInventoryTransaction[]> {
+    const { InventoryTransaction } = this.tenancy.models(tenantId);
+
+    const openingBalanceDate = moment(filter.fromDate)
+      .subtract(1, 'days')
+      .toDate();
+
+    // Opening inventory transactions.
+    const openingTransactions = InventoryTransaction.query()
+      .select('*')
+      .select(raw("IF(`DIRECTION` = 'IN', `QUANTITY`, 0) as 'QUANTITY_IN'"))
+      .select(raw("IF(`DIRECTION` = 'OUT', `QUANTITY`, 0) as 'QUANTITY_OUT'"))
+      .select(
+        raw(
+          "IF(`DIRECTION` = 'IN', IF(`QUANTITY` IS NULL, `RATE`, `QUANTITY` * `RATE`), 0) as 'VALUE_IN'"
+        )
+      )
+      .select(
+        raw(
+          "IF(`DIRECTION` = 'OUT', IF(`QUANTITY` IS NULL, `RATE`, `QUANTITY` * `RATE`), 0) as 'VALUE_OUT'"
+        )
+      )
+      .modify('filterDateRange', null, openingBalanceDate)
+      .orderBy('date', 'ASC')
+      .as('inventory_transactions');
+
+    if (!isEmpty(filter.warehousesIds)) {
+      openingTransactions.modify('filterByWarehouses', filter.warehousesIds);
+    }
+    if (!isEmpty(filter.branchesIds)) {
+      openingTransactions.modify('filterByBranches', filter.branchesIds);
+    }
+
+    const openingBalanceTransactions = await InventoryTransaction.query()
+      .from(openingTransactions)
+      .select('itemId')
+      .select(raw('SUM(`QUANTITY_IN` - `QUANTITY_OUT`) AS `QUANTITY`'))
+      .select(raw('SUM(`VALUE_IN` - `VALUE_OUT`) AS `VALUE`'))
+      .groupBy('itemId')
+      .sum('rate as rate')
+      .sum('quantityIn as quantityIn')
+      .sum('quantityOut as quantityOut')
+      .sum('valueIn as valueIn')
+      .sum('valueOut as valueOut')
+      .withGraphFetched('itemCostAggregated');
+
+    return openingBalanceTransactions;
+  }
+
+  /**
+   * Retrieve the items inventory tranasactions.
+   * @param {number} tenantId -
+   * @param {IInventoryDetailsQuery}
+   * @return {Promise<IInventoryTransaction>}
+   */
+  public async itemInventoryTransactions(
+    tenantId: number,
+    filter: IInventoryDetailsQuery
+  ): Promise<IInventoryTransaction[]> {
+    const { InventoryTransaction } = this.tenancy.models(tenantId);
+
+    const inventoryTransactions = InventoryTransaction.query()
+      .modify('filterDateRange', filter.fromDate, filter.toDate)
+      .orderBy('date', 'ASC')
+      .withGraphFetched('meta')
+      .withGraphFetched('costLotAggregated');
+
+    if (!isEmpty(filter.branchesIds)) {
+      inventoryTransactions.modify('filterByBranches', filter.branchesIds);
+    }
+    if (!isEmpty(filter.warehousesIds)) {
+      inventoryTransactions.modify('filterByWarehouses', filter.warehousesIds);
+    }
+    return inventoryTransactions;
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/InventoryDetails/InventoryDetailsService.ts b/packages/server/src/services/FinancialStatements/InventoryDetails/InventoryDetailsService.ts
new file mode 100644
index 000000000..7cc1d0667
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/InventoryDetails/InventoryDetailsService.ts
@@ -0,0 +1,125 @@
+import moment from 'moment';
+import { Service, Inject } from 'typedi';
+import {
+  IInventoryDetailsQuery,
+  IInvetoryItemDetailDOO,
+  IInventoryItemDetailMeta,
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import InventoryDetails from './InventoryDetails';
+import FinancialSheet from '../FinancialSheet';
+import InventoryDetailsRepository from './InventoryDetailsRepository';
+import InventoryService from '@/services/Inventory/Inventory';
+import { parseBoolean } from 'utils';
+import { Tenant } from '@/system/models';
+
+@Service()
+export default class InventoryDetailsService extends FinancialSheet {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  reportRepo: InventoryDetailsRepository;
+
+  @Inject()
+  inventoryService: InventoryService;
+
+  /**
+   * Defaults balance sheet filter query.
+   * @return {IBalanceSheetQuery}
+   */
+  private get defaultQuery(): IInventoryDetailsQuery {
+    return {
+      fromDate: moment().startOf('year').format('YYYY-MM-DD'),
+      toDate: moment().endOf('year').format('YYYY-MM-DD'),
+      itemsIds: [],
+      numberFormat: {
+        precision: 2,
+        divideOn1000: false,
+        showZero: false,
+        formatMoney: 'total',
+        negativeFormat: 'mines',
+      },
+      noneTransactions: false,
+      branchesIds: [],
+      warehousesIds: [],
+    };
+  }
+
+  /**
+   * Retrieve the balance sheet meta.
+   * @param {number} tenantId -
+   * @returns {IInventoryItemDetailMeta}
+   */
+  private reportMetadata(tenantId: number): IInventoryItemDetailMeta {
+    const settings = this.tenancy.settings(tenantId);
+
+    const isCostComputeRunning =
+      this.inventoryService.isItemsCostComputeRunning(tenantId);
+
+    const organizationName = settings.get({
+      group: 'organization',
+      key: 'name',
+    });
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+
+    return {
+      isCostComputeRunning: parseBoolean(isCostComputeRunning, false),
+      organizationName,
+      baseCurrency,
+    };
+  }
+
+  /**
+   * Retrieve the inventory details report data.
+   * @param {number} tenantId -
+   * @param {IInventoryDetailsQuery} query -
+   * @return {Promise<IInvetoryItemDetailDOO>}
+   */
+  public async inventoryDetails(
+    tenantId: number,
+    query: IInventoryDetailsQuery
+  ): Promise<IInvetoryItemDetailDOO> {
+    const i18n = this.tenancy.i18n(tenantId);
+
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const filter = {
+      ...this.defaultQuery,
+      ...query,
+    };
+    // Retrieves the items.
+    const items = await this.reportRepo.getInventoryItems(
+      tenantId,
+      filter.itemsIds
+    );
+    // Opening balance transactions.
+    const openingBalanceTransactions =
+      await this.reportRepo.openingBalanceTransactions(tenantId, filter);
+
+    // Retrieves the inventory transaction.
+    const inventoryTransactions =
+      await this.reportRepo.itemInventoryTransactions(tenantId, filter);
+
+    // Inventory details report mapper.
+    const inventoryDetailsInstance = new InventoryDetails(
+      items,
+      openingBalanceTransactions,
+      inventoryTransactions,
+      filter,
+      tenant.metadata.baseCurrency,
+      i18n
+    );
+
+    return {
+      data: inventoryDetailsInstance.reportData(),
+      query: filter,
+      meta: this.reportMetadata(tenantId),
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/InventoryDetails/InventoryDetailsTable.ts b/packages/server/src/services/FinancialStatements/InventoryDetails/InventoryDetailsTable.ts
new file mode 100644
index 000000000..98d5522f2
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/InventoryDetails/InventoryDetailsTable.ts
@@ -0,0 +1,197 @@
+import * as R from 'ramda';
+import {
+  IInventoryDetailsItem,
+  IInventoryDetailsItemTransaction,
+  IInventoryDetailsClosing,
+  ITableColumn,
+  ITableRow,
+  IInventoryDetailsNode,
+  IInventoryDetailsOpening,
+} from '@/interfaces';
+import { mapValuesDeep } from 'utils/deepdash';
+import { tableRowMapper } from 'utils';
+
+enum IROW_TYPE {
+  ITEM = 'ITEM',
+  TRANSACTION = 'TRANSACTION',
+  CLOSING_ENTRY = 'CLOSING_ENTRY',
+  OPENING_ENTRY = 'OPENING_ENTRY',
+}
+
+const MAP_CONFIG = { childrenPath: 'children', pathFormat: 'array' };
+
+export default class InventoryDetailsTable {
+  i18n: any;
+  report: any;
+
+  /**
+   * Constructor method.
+   * @param {ICashFlowStatement} reportStatement - Report statement.
+   */
+  constructor(reportStatement, i18n) {
+    this.report = reportStatement;
+    this.i18n = i18n;
+  }
+
+  /**
+   * Mappes the item node to table rows.
+   * @param {IInventoryDetailsItem} item
+   * @returns {ITableRow}
+   */
+  private itemNodeMapper = (item: IInventoryDetailsItem) => {
+    const columns = [{ key: 'item_name', accessor: 'name' }];
+
+    return tableRowMapper(item, columns, {
+      rowTypes: [IROW_TYPE.ITEM],
+    });
+  };
+
+  /**
+   * Mappes the item inventory transaction to table row.
+   * @param {IInventoryDetailsItemTransaction} transaction
+   * @returns {ITableRow}
+   */
+  private itemTransactionNodeMapper = (
+    transaction: IInventoryDetailsItemTransaction
+  ) => {
+    const columns = [
+      { key: 'date', accessor: 'date.formattedDate' },
+      { key: 'transaction_type', accessor: 'transactionType' },
+      { key: 'transaction_id', accessor: 'transactionNumber' },
+      {
+        key: 'quantity_movement',
+        accessor: 'quantityMovement.formattedNumber',
+      },
+      { key: 'rate', accessor: 'rate.formattedNumber' },
+      { key: 'total', accessor: 'total.formattedNumber' },
+      { key: 'value', accessor: 'valueMovement.formattedNumber' },
+      { key: 'profit_margin', accessor: 'profitMargin.formattedNumber' },
+      { key: 'running_quantity', accessor: 'runningQuantity.formattedNumber' },
+      {
+        key: 'running_valuation',
+        accessor: 'runningValuation.formattedNumber',
+      },
+    ];
+    return tableRowMapper(transaction, columns, {
+      rowTypes: [IROW_TYPE.TRANSACTION],
+    });
+  };
+
+  /**
+   * Opening balance transaction mapper to table row.
+   * @param {IInventoryDetailsOpening} transaction
+   * @returns {ITableRow}
+   */
+  private openingNodeMapper = (
+    transaction: IInventoryDetailsOpening
+  ): ITableRow => {
+    const columns = [
+      { key: 'date', accessor: 'date.formattedDate' },
+      { key: 'closing', value: this.i18n.__('Opening balance') },
+      { key: 'empty' },
+      { key: 'quantity', accessor: 'quantity.formattedNumber' },
+      { key: 'empty' },
+      { key: 'empty' },
+      { key: 'value', accessor: 'value.formattedNumber' },
+    ];
+    return tableRowMapper(transaction, columns, {
+      rowTypes: [IROW_TYPE.OPENING_ENTRY],
+    });
+  };
+
+  /**
+   * Closing balance transaction mapper to table raw.
+   * @param {IInventoryDetailsClosing} transaction
+   * @returns {ITableRow}
+   */
+  private closingNodeMapper = (
+    transaction: IInventoryDetailsClosing
+  ): ITableRow => {
+    const columns = [
+      { key: 'date', accessor: 'date.formattedDate' },
+      { key: 'closing', value: this.i18n.__('Closing balance') },
+      { key: 'empty' },
+      { key: 'quantity', accessor: 'quantity.formattedNumber' },
+      { key: 'empty' },
+      { key: 'empty' },
+      { key: 'value', accessor: 'value.formattedNumber' },
+      { key: 'profitMargin', accessor: 'profitMargin.formattedNumber' },
+    ];
+
+    return tableRowMapper(transaction, columns, {
+      rowTypes: [IROW_TYPE.CLOSING_ENTRY],
+    });
+  };
+
+  /**
+   * Detarmines the ginve inventory details node type.
+   * @param {string} type
+   * @param {IInventoryDetailsNode} node
+   * @returns {boolean}
+   */
+  private isNodeTypeEquals = (
+    type: string,
+    node: IInventoryDetailsNode
+  ): boolean => {
+    return node.nodeType === type;
+  };
+
+  /**
+   * Mappes the given item or transactions node to table rows.
+   * @param {IInventoryDetailsNode} node -
+   * @return {ITableRow}
+   */
+  private itemMapper = (node: IInventoryDetailsNode): ITableRow => {
+    return R.compose(
+      R.when(
+        R.curry(this.isNodeTypeEquals)('OPENING_ENTRY'),
+        this.openingNodeMapper
+      ),
+      R.when(
+        R.curry(this.isNodeTypeEquals)('CLOSING_ENTRY'),
+        this.closingNodeMapper
+      ),
+      R.when(R.curry(this.isNodeTypeEquals)('item'), this.itemNodeMapper),
+      R.when(
+        R.curry(this.isNodeTypeEquals)('transaction'),
+        this.itemTransactionNodeMapper
+      )
+    )(node);
+  };
+
+  /**
+   * Mappes the items nodes to table rows.
+   * @param {IInventoryDetailsItem[]} items
+   * @returns {ITableRow[]}
+   */
+  private itemsMapper = (items: IInventoryDetailsItem[]): ITableRow[] => {
+    return mapValuesDeep(items, this.itemMapper, MAP_CONFIG);
+  };
+
+  /**
+   * Retrieve the table rows of the inventory item details.
+   * @returns {ITableRow[]}
+   */
+  public tableData = (): ITableRow[] => {
+    return this.itemsMapper(this.report.data);
+  };
+
+  /**
+   * Retrieve the table columns of inventory details report.
+   * @returns {ITableColumn[]}
+   */
+  public tableColumns = (): ITableColumn[] => {
+    return [
+      { key: 'date', label: this.i18n.__('Date') },
+      { key: 'transaction_type', label: this.i18n.__('Transaction type') },
+      { key: 'transaction_id', label: this.i18n.__('Transaction #') },
+      { key: 'quantity', label: this.i18n.__('Quantity') },
+      { key: 'rate', label: this.i18n.__('Rate') },
+      { key: 'total', label: this.i18n.__('Total') },
+      { key: 'value', label: this.i18n.__('Value') },
+      { key: 'profit_margin', label: this.i18n.__('Profit Margin') },
+      { key: 'running_quantity', label: this.i18n.__('Running quantity') },
+      { key: 'running_value', label: this.i18n.__('Running Value') },
+    ];
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/InventoryValuationSheet/InventoryValuationSheet.ts b/packages/server/src/services/FinancialStatements/InventoryValuationSheet/InventoryValuationSheet.ts
new file mode 100644
index 000000000..693ee2692
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/InventoryValuationSheet/InventoryValuationSheet.ts
@@ -0,0 +1,264 @@
+import { sumBy, get, isEmpty } from 'lodash';
+import * as R from 'ramda';
+import FinancialSheet from '../FinancialSheet';
+import {
+  IItem,
+  IInventoryValuationReportQuery,
+  IInventoryValuationItem,
+  InventoryCostLotTracker,
+  IInventoryValuationStatement,
+  IInventoryValuationTotal,
+} from '@/interfaces';
+import { allPassedConditionsPass, transformToMap } from 'utils';
+
+export default class InventoryValuationSheet extends FinancialSheet {
+  readonly query: IInventoryValuationReportQuery;
+  readonly items: IItem[];
+  readonly INInventoryCostLots: Map<number, InventoryCostLotTracker>;
+  readonly OUTInventoryCostLots: Map<number, InventoryCostLotTracker>;
+  readonly baseCurrency: string;
+
+  /**
+   * Constructor method.
+   * @param {IInventoryValuationReportQuery} query
+   * @param items
+   * @param INInventoryCostLots
+   * @param OUTInventoryCostLots
+   * @param baseCurrency
+   */
+  constructor(
+    query: IInventoryValuationReportQuery,
+    items: IItem[],
+    INInventoryCostLots: Map<number, InventoryCostLotTracker[]>,
+    OUTInventoryCostLots: Map<number, InventoryCostLotTracker[]>,
+    baseCurrency: string
+  ) {
+    super();
+
+    this.query = query;
+    this.items = items;
+    this.INInventoryCostLots = transformToMap(INInventoryCostLots, 'itemId');
+    this.OUTInventoryCostLots = transformToMap(OUTInventoryCostLots, 'itemId');
+    this.baseCurrency = baseCurrency;
+    this.numberFormat = this.query.numberFormat;
+  }
+
+  /**
+   * Retrieve the item cost and quantity from the given transaction map.
+   * @param {Map<number, InventoryCostLotTracker[]>} transactionsMap
+   * @param {number} itemId
+   * @returns
+   */
+  private getItemTransaction(
+    transactionsMap: Map<number, InventoryCostLotTracker[]>,
+    itemId: number
+  ): { cost: number; quantity: number } {
+    const meta = transactionsMap.get(itemId);
+
+    const cost = get(meta, 'cost', 0);
+    const quantity = get(meta, 'quantity', 0);
+
+    return { cost, quantity };
+  }
+
+  /**
+   * Retrieve the cost and quantity of the givne item from `IN` transactions.
+   * @param {number} itemId -
+   */
+  private getItemINTransaction(itemId: number): {
+    cost: number;
+    quantity: number;
+  } {
+    return this.getItemTransaction(this.INInventoryCostLots, itemId);
+  }
+
+  /**
+   * Retrieve the cost and quantity of the given item from `OUT` transactions.
+   * @param {number} itemId -
+   */
+  private getItemOUTTransaction(itemId: number): {
+    cost: number;
+    quantity: number;
+  } {
+    return this.getItemTransaction(this.OUTInventoryCostLots, itemId);
+  }
+
+  /**
+   * Retrieve the item closing valuation.
+   * @param {number} itemId - Item id.
+   */
+  private getItemValuation(itemId: number): number {
+    const { cost: INValuation } = this.getItemINTransaction(itemId);
+    const { cost: OUTValuation } = this.getItemOUTTransaction(itemId);
+
+    return Math.max(INValuation - OUTValuation, 0);
+  }
+
+  /**
+   * Retrieve the item closing quantity.
+   * @param {number} itemId - Item id.
+   */
+  private getItemQuantity(itemId: number): number {
+    const { quantity: INQuantity } = this.getItemINTransaction(itemId);
+    const { quantity: OUTQuantity } = this.getItemOUTTransaction(itemId);
+
+    return INQuantity - OUTQuantity;
+  }
+
+  /**
+   * Calculates the item weighted average cost from the given valuation and quantity.
+   * @param {number} valuation
+   * @param {number} quantity
+   * @returns {number}
+   */
+  private calcAverage(valuation: number, quantity: number): number {
+    return quantity ? valuation / quantity : 0;
+  }
+
+  /**
+   * Mapping the item model object to inventory valuation item
+   * @param {IItem} item
+   * @returns {IInventoryValuationItem}
+   */
+  private itemMapper(item: IItem): IInventoryValuationItem {
+    const valuation = this.getItemValuation(item.id);
+    const quantity = this.getItemQuantity(item.id);
+    const average = this.calcAverage(valuation, quantity);
+
+    return {
+      id: item.id,
+      name: item.name,
+      code: item.code,
+      valuation,
+      quantity,
+      average,
+      valuationFormatted: this.formatNumber(valuation),
+      quantityFormatted: this.formatNumber(quantity, { money: false }),
+      averageFormatted: this.formatNumber(average, { money: false }),
+      currencyCode: this.baseCurrency,
+    };
+  }
+
+  /**
+   * Filter none transactions items.
+   * @param {IInventoryValuationItem} valuationItem -
+   * @return {boolean}
+   */
+  private filterNoneTransactions = (
+    valuationItem: IInventoryValuationItem
+  ): boolean => {
+    const transactionIN = this.INInventoryCostLots.get(valuationItem.id);
+    const transactionOUT = this.OUTInventoryCostLots.get(valuationItem.id);
+
+    return transactionOUT || transactionIN;
+  };
+
+  /**
+   * Filter active only items.
+   * @param {IInventoryValuationItem} valuationItem -
+   * @returns {boolean}
+   */
+  private filterActiveOnly = (
+    valuationItem: IInventoryValuationItem
+  ): boolean => {
+    return (
+      valuationItem.average !== 0 ||
+      valuationItem.quantity !== 0 ||
+      valuationItem.valuation !== 0
+    );
+  };
+
+  /**
+   * Filter none-zero total valuation items.
+   * @param {IInventoryValuationItem} valuationItem
+   * @returns {boolean}
+   */
+  private filterNoneZero = (valuationItem: IInventoryValuationItem) => {
+    return valuationItem.valuation !== 0;
+  };
+
+  /**
+   * Filters the inventory valuation items based on query.
+   * @param {IInventoryValuationItem} valuationItem
+   * @returns {boolean}
+   */
+  private itemFilter = (valuationItem: IInventoryValuationItem): boolean => {
+    const { noneTransactions, noneZero, onlyActive } = this.query;
+
+    // Conditions pair filter detarminer.
+    const condsPairFilters = [
+      [noneTransactions, this.filterNoneTransactions],
+      [noneZero, this.filterNoneZero],
+      [onlyActive, this.filterActiveOnly],
+    ];
+    return allPassedConditionsPass(condsPairFilters)(valuationItem);
+  };
+
+  /**
+   * Mappes the items to inventory valuation items nodes.
+   * @param {IItem[]} items
+   * @returns {IInventoryValuationItem[]}
+   */
+  private itemsMapper = (items: IItem[]): IInventoryValuationItem[] => {
+    return this.items.map(this.itemMapper.bind(this));
+  };
+
+  /**
+   * Filters the inventory valuation items nodes.
+   * @param {IInventoryValuationItem[]} nodes -
+   * @returns {IInventoryValuationItem[]}
+   */
+  private itemsFilter = (
+    nodes: IInventoryValuationItem[]
+  ): IInventoryValuationItem[] => {
+    return nodes.filter(this.itemFilter);
+  };
+
+  /**
+   * Detarmines whether the items post filter is active.
+   */
+  private isItemsPostFilter = (): boolean => {
+    return isEmpty(this.query.itemsIds);
+  };
+
+  /**
+   * Retrieve the inventory valuation items.
+   * @returns {IInventoryValuationItem[]}
+   */
+  private itemsSection(): IInventoryValuationItem[] {
+    return R.compose(
+      R.when(this.isItemsPostFilter, this.itemsFilter),
+      this.itemsMapper
+    )(this.items);
+  }
+
+  /**
+   * Retrieve the inventory valuation total.
+   * @param {IInventoryValuationItem[]} items
+   * @returns {IInventoryValuationTotal}
+   */
+  private totalSection(
+    items: IInventoryValuationItem[]
+  ): IInventoryValuationTotal {
+    const valuation = sumBy(items, (item) => item.valuation);
+    const quantity = sumBy(items, (item) => item.quantity);
+
+    return {
+      valuation,
+      quantity,
+      valuationFormatted: this.formatTotalNumber(valuation),
+      quantityFormatted: this.formatTotalNumber(quantity, { money: false }),
+    };
+  }
+
+  /**
+   * Retrieve the inventory valuation report data.
+   * @returns {IInventoryValuationStatement}
+   */
+  public reportData(): IInventoryValuationStatement {
+    const items = this.itemsSection();
+    const total = this.totalSection(items);
+
+    return items.length > 0 ? { items, total } : {};
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/InventoryValuationSheet/InventoryValuationSheetService.ts b/packages/server/src/services/FinancialStatements/InventoryValuationSheet/InventoryValuationSheetService.ts
new file mode 100644
index 000000000..41650ccde
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/InventoryValuationSheet/InventoryValuationSheetService.ts
@@ -0,0 +1,144 @@
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import { isEmpty } from 'lodash';
+import {
+  IInventoryValuationReportQuery,
+  IInventoryValuationSheetMeta,
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import InventoryValuationSheet from './InventoryValuationSheet';
+import InventoryService from '@/services/Inventory/Inventory';
+import { Tenant } from '@/system/models';
+
+@Service()
+export default class InventoryValuationSheetService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  inventoryService: InventoryService;
+
+  /**
+   * Defaults balance sheet filter query.
+   * @return {IBalanceSheetQuery}
+   */
+  get defaultQuery(): IInventoryValuationReportQuery {
+    return {
+      asDate: moment().endOf('year').format('YYYY-MM-DD'),
+      itemsIds: [],
+      numberFormat: {
+        precision: 2,
+        divideOn1000: false,
+        showZero: false,
+        formatMoney: 'always',
+        negativeFormat: 'mines',
+      },
+      noneTransactions: true,
+      noneZero: false,
+      onlyActive: false,
+
+      warehousesIds: [],
+      branchesIds: [],
+    };
+  }
+
+  /**
+   * Retrieve the balance sheet meta.
+   * @param {number} tenantId -
+   * @returns {IBalanceSheetMeta}
+   */
+  reportMetadata(tenantId: number): IInventoryValuationSheetMeta {
+    const settings = this.tenancy.settings(tenantId);
+
+    const isCostComputeRunning =
+      this.inventoryService.isItemsCostComputeRunning(tenantId);
+
+    const organizationName = settings.get({
+      group: 'organization',
+      key: 'name',
+    });
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+
+    return {
+      organizationName,
+      baseCurrency,
+      isCostComputeRunning,
+    };
+  }
+
+  /**
+   * Inventory valuation sheet.
+   * @param {number} tenantId - Tenant id.
+   * @param {IInventoryValuationReportQuery} query - Valuation query.
+   */
+  public async inventoryValuationSheet(
+    tenantId: number,
+    query: IInventoryValuationReportQuery
+  ) {
+    const { Item, InventoryCostLotTracker } = this.tenancy.models(tenantId);
+
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const filter = {
+      ...this.defaultQuery,
+      ...query,
+    };
+    const inventoryItems = await Item.query().onBuild((q) => {
+      q.where('type', 'inventory');
+
+      if (filter.itemsIds.length > 0) {
+        q.whereIn('id', filter.itemsIds);
+      }
+    });
+    const inventoryItemsIds = inventoryItems.map((item) => item.id);
+
+    const commonQuery = (builder) => {
+      builder.whereIn('item_id', inventoryItemsIds);
+      builder.sum('rate as rate');
+      builder.sum('quantity as quantity');
+      builder.sum('cost as cost');
+      builder.select('itemId');
+      builder.groupBy('itemId');
+
+      if (!isEmpty(query.branchesIds)) {
+        builder.modify('filterByBranches', query.branchesIds);
+      }
+      if (!isEmpty(query.warehousesIds)) {
+        builder.modify('filterByWarehouses', query.warehousesIds);
+      }
+    };
+    // Retrieve the inventory cost `IN` transactions.
+    const INTransactions = await InventoryCostLotTracker.query()
+      .onBuild(commonQuery)
+      .where('direction', 'IN');
+
+    // Retrieve the inventory cost `OUT` transactions.
+    const OUTTransactions = await InventoryCostLotTracker.query()
+      .onBuild(commonQuery)
+      .where('direction', 'OUT');
+
+    const inventoryValuationInstance = new InventoryValuationSheet(
+      filter,
+      inventoryItems,
+      INTransactions,
+      OUTTransactions,
+      tenant.metadata.baseCurrency
+    );
+    // Retrieve the inventory valuation report data.
+    const inventoryValuationData = inventoryValuationInstance.reportData();
+
+    return {
+      data: inventoryValuationData,
+      query: filter,
+      meta: this.reportMetadata(tenantId),
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/JournalSheet/JournalSheet.ts b/packages/server/src/services/FinancialStatements/JournalSheet/JournalSheet.ts
new file mode 100644
index 000000000..ee184a5a1
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/JournalSheet/JournalSheet.ts
@@ -0,0 +1,137 @@
+import { sumBy, chain, get, head } from 'lodash';
+import {
+  IJournalEntry,
+  IJournalPoster,
+  IJournalReportEntriesGroup,
+  IJournalReportQuery,
+  IJournalReport,
+  IContact,
+} from '@/interfaces';
+import FinancialSheet from '../FinancialSheet';
+
+export default class JournalSheet extends FinancialSheet {
+  readonly tenantId: number;
+  readonly journal: IJournalPoster;
+  readonly query: IJournalReportQuery;
+  readonly baseCurrency: string;
+  readonly contactsById: Map<number | string, IContact>;
+
+  /**
+   * Constructor method.
+   * @param {number} tenantId
+   * @param {IJournalPoster} journal
+   */
+  constructor(
+    tenantId: number,
+    query: IJournalReportQuery,
+    journal: IJournalPoster,
+    accountsGraph: any,
+    contactsById: Map<number | string, IContact>,
+    baseCurrency: string,
+    i18n
+  ) {
+    super();
+
+    this.tenantId = tenantId;
+    this.journal = journal;
+    this.query = query;
+    this.numberFormat = this.query.numberFormat;
+    this.accountsGraph = accountsGraph;
+    this.contactsById = contactsById;
+    this.baseCurrency = baseCurrency;
+    this.i18n = i18n;
+  }
+
+  /**
+   * Entry mapper.
+   * @param {IJournalEntry} entry 
+   */
+  entryMapper(entry: IJournalEntry) {
+    const account = this.accountsGraph.getNodeData(entry.accountId);
+    const contact = this.contactsById.get(entry.contactId);
+
+    return {
+      entryId: entry.id,
+      index: entry.index,
+      note: entry.note,
+
+      contactName: get(contact, 'displayName'),
+      contactType: get(contact, 'contactService'),
+
+      accountName: account.name,
+      accountCode: account.code,
+      transactionNumber: entry.transactionNumber,
+
+      currencyCode: this.baseCurrency,
+      formattedCredit: this.formatNumber(entry.credit),
+      formattedDebit: this.formatNumber(entry.debit),
+
+      credit: entry.credit,
+      debit: entry.debit,
+
+      createdAt: entry.createdAt,
+    };
+  }
+
+  /**
+   * Mappes the journal entries.
+   * @param {IJournalEntry[]} entries -
+   */
+  entriesMapper(entries: IJournalEntry[]) {
+    return entries.map(this.entryMapper.bind(this));
+  }
+
+  /**
+   * Mapping journal entries groups.
+   * @param {IJournalEntry[]} entriesGroup -
+   * @param {string} key -
+   * @return {IJournalReportEntriesGroup}
+   */
+  entriesGroupsMapper(
+    entriesGroup: IJournalEntry[],
+    groupEntry: IJournalEntry
+  ): IJournalReportEntriesGroup {
+    const totalCredit = sumBy(entriesGroup, 'credit');
+    const totalDebit = sumBy(entriesGroup, 'debit');
+
+    return {
+      date: groupEntry.date,
+      referenceType: groupEntry.referenceType,
+      referenceId: groupEntry.referenceId,
+      referenceTypeFormatted: this.i18n.__(groupEntry.referenceTypeFormatted),
+
+      entries: this.entriesMapper(entriesGroup),
+
+      currencyCode: this.baseCurrency,
+
+      credit: totalCredit,
+      debit: totalDebit,
+
+      formattedCredit: this.formatTotalNumber(totalCredit),
+      formattedDebit: this.formatTotalNumber(totalDebit),
+    };
+  }
+
+  /**
+   * Mapping the journal entries to entries groups.
+   * @param {IJournalEntry[]} entries
+   * @return {IJournalReportEntriesGroup[]}
+   */
+  entriesWalker(entries: IJournalEntry[]): IJournalReportEntriesGroup[] {
+    return chain(entries)
+      .groupBy((entry) => `${entry.referenceId}-${entry.referenceType}`)
+      .map((entriesGroup: IJournalEntry[], key: string) => {
+        const headEntry = head(entriesGroup);
+        return this.entriesGroupsMapper(entriesGroup, headEntry);
+      })
+      .value();
+  }
+
+  /**
+   * Retrieve journal report.
+   * @return {IJournalReport}
+   */
+  reportData(): IJournalReport {
+    return this.entriesWalker(this.journal.entries);
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/JournalSheet/JournalSheetService.ts b/packages/server/src/services/FinancialStatements/JournalSheet/JournalSheetService.ts
new file mode 100644
index 000000000..f932efd8c
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/JournalSheet/JournalSheetService.ts
@@ -0,0 +1,139 @@
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import { IJournalReportQuery, IJournalSheetMeta } from '@/interfaces';
+
+import JournalSheet from './JournalSheet';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import Journal from '@/services/Accounting/JournalPoster';
+import InventoryService from '@/services/Inventory/Inventory';
+import { parseBoolean, transformToMap } from 'utils';
+import { Tenant } from '@/system/models';
+
+@Service()
+export default class JournalSheetService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  inventoryService: InventoryService;
+
+  @Inject('logger')
+  logger: any;
+
+  /**
+   * Default journal sheet filter queyr.
+   */
+  get defaultQuery() {
+    return {
+      fromDate: moment().startOf('year').format('YYYY-MM-DD'),
+      toDate: moment().endOf('year').format('YYYY-MM-DD'),
+      fromRange: null,
+      toRange: null,
+      accountsIds: [],
+      numberFormat: {
+        noCents: false,
+        divideOn1000: false,
+      },
+    };
+  }
+
+  /**
+   * Retrieve the balance sheet meta.
+   * @param {number} tenantId -
+   * @returns {IBalanceSheetMeta}
+   */
+  reportMetadata(tenantId: number): IJournalSheetMeta {
+    const settings = this.tenancy.settings(tenantId);
+
+    const isCostComputeRunning =
+      this.inventoryService.isItemsCostComputeRunning(tenantId);
+
+    const organizationName = settings.get({
+      group: 'organization',
+      key: 'name',
+    });
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+
+    return {
+      isCostComputeRunning: parseBoolean(isCostComputeRunning, false),
+      organizationName,
+      baseCurrency,
+    };
+  }
+
+  /**
+   * Journal sheet.
+   * @param {number} tenantId
+   * @param {IJournalSheetFilterQuery} query
+   */
+  async journalSheet(tenantId: number, query: IJournalReportQuery) {
+    const i18n = this.tenancy.i18n(tenantId);
+    const { accountRepository, transactionsRepository, contactRepository } =
+      this.tenancy.repositories(tenantId);
+
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+
+    const filter = {
+      ...this.defaultQuery,
+      ...query,
+    };
+    this.logger.info('[journal] trying to calculate the report.', {
+      tenantId,
+      filter,
+    });
+
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    // Retrieve all accounts on the storage.
+    const accountsGraph = await accountRepository.getDependencyGraph();
+
+    // Retrieve all contacts on the storage.
+    const contacts = await contactRepository.all();
+    const contactsByIdMap = transformToMap(contacts, 'id');
+
+    // Retrieve all journal transactions based on the given query.
+    const transactions = await AccountTransaction.query().onBuild((query) => {
+      if (filter.fromRange || filter.toRange) {
+        query.modify('filterAmountRange', filter.fromRange, filter.toRange);
+      }
+      query.modify('filterDateRange', filter.fromDate, filter.toDate);
+      query.orderBy(['date', 'createdAt', 'indexGroup', 'index']);
+
+      if (filter.transactionType) {
+        query.where('reference_type', filter.transactionType);
+      }
+      if (filter.transactionType && filter.transactionId) {
+        query.where('reference_id', filter.transactionId);
+      }
+    });
+    // Transform the transactions array to journal collection.
+    const transactionsJournal = Journal.fromTransactions(
+      transactions,
+      tenantId,
+      accountsGraph
+    );
+    // Journal report instance.
+    const journalSheetInstance = new JournalSheet(
+      tenantId,
+      filter,
+      transactionsJournal,
+      accountsGraph,
+      contactsByIdMap,
+      tenant.metadata.baseCurrency,
+      i18n
+    );
+    // Retrieve journal report columns.
+    const journalSheetData = journalSheetInstance.reportData();
+
+    return {
+      data: journalSheetData,
+      query: filter,
+      meta: this.reportMetadata(tenantId),
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSchema.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSchema.ts
new file mode 100644
index 000000000..f18cdf59e
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSchema.ts
@@ -0,0 +1,76 @@
+import * as R from 'ramda';
+import { ACCOUNT_TYPE } from '@/data/AccountTypes';
+import {
+  ProfitLossAggregateNodeId,
+  ProfitLossNodeType,
+  IProfitLossSchemaNode,
+} from '@/interfaces';
+import { FinancialSchema } from '../FinancialSchema';
+
+export const ProfitLossShema = (Base) =>
+  class extends R.compose(FinancialSchema)(Base) {
+    /**
+     * Retrieves the report schema.
+     * @returns {IProfitLossSchemaNode[]}
+     */
+    getSchema = (): IProfitLossSchemaNode[] => {
+      return getProfitLossSheetSchema();
+    };
+  };
+
+/**
+ * Retrieves P&L sheet schema.
+ * @returns {IProfitLossSchemaNode}
+ */
+export const getProfitLossSheetSchema = (): IProfitLossSchemaNode[] => [
+  {
+    id: ProfitLossAggregateNodeId.INCOME,
+    name: 'profit_loss_sheet.income',
+    nodeType: ProfitLossNodeType.ACCOUNTS,
+    accountsTypes: [ACCOUNT_TYPE.INCOME],
+    alwaysShow: true,
+  },
+  {
+    id: ProfitLossAggregateNodeId.COS,
+    name: 'profit_loss_sheet.cost_of_sales',
+    nodeType: ProfitLossNodeType.ACCOUNTS,
+    accountsTypes: [ACCOUNT_TYPE.COST_OF_GOODS_SOLD],
+  },
+  {
+    id: ProfitLossAggregateNodeId.GROSS_PROFIT,
+    name: 'profit_loss_sheet.gross_profit',
+    nodeType: ProfitLossNodeType.EQUATION,
+    equation: `${ProfitLossAggregateNodeId.INCOME} - ${ProfitLossAggregateNodeId.COS}`,
+  },
+  {
+    id: ProfitLossAggregateNodeId.EXPENSES,
+    name: 'profit_loss_sheet.expenses',
+    nodeType: ProfitLossNodeType.ACCOUNTS,
+    accountsTypes: [ACCOUNT_TYPE.EXPENSE],
+    alwaysShow: true,
+  },
+  {
+    id: ProfitLossAggregateNodeId.NET_OPERATING_INCOME,
+    name: 'profit_loss_sheet.net_operating_income',
+    nodeType: ProfitLossNodeType.EQUATION,
+    equation: `${ProfitLossAggregateNodeId.GROSS_PROFIT} - ${ProfitLossAggregateNodeId.EXPENSES}`,
+  },
+  {
+    id: ProfitLossAggregateNodeId.OTHER_INCOME,
+    name: 'profit_loss_sheet.other_income',
+    nodeType: ProfitLossNodeType.ACCOUNTS,
+    accountsTypes: [ACCOUNT_TYPE.OTHER_INCOME],
+  },
+  {
+    id: ProfitLossAggregateNodeId.OTHER_EXPENSES,
+    name: 'profit_loss_sheet.other_expenses',
+    nodeType: ProfitLossNodeType.ACCOUNTS,
+    accountsTypes: [ACCOUNT_TYPE.OTHER_EXPENSE],
+  },
+  {
+    id: ProfitLossAggregateNodeId.NET_INCOME,
+    name: 'profit_loss_sheet.net_income',
+    nodeType: ProfitLossNodeType.EQUATION,
+    equation: `${ProfitLossAggregateNodeId.NET_OPERATING_INCOME} + ${ProfitLossAggregateNodeId.OTHER_INCOME} - ${ProfitLossAggregateNodeId.OTHER_EXPENSES}`,
+  },
+];
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheet.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheet.ts
new file mode 100644
index 000000000..1392c7c38
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheet.ts
@@ -0,0 +1,324 @@
+import * as R from 'ramda';
+import { IProfitLossSheetQuery } from '@/interfaces/ProfitLossSheet';
+import FinancialSheet from '../FinancialSheet';
+import { FinancialSheetStructure } from '../FinancialSheetStructure';
+import {
+  ProfitLossNodeType,
+  IProfitLossSheetEquationNode,
+  IProfitLossEquationSchemaNode,
+  IProfitLossSheetAccountsNode,
+  IProfitLossAccountsSchemaNode,
+  IProfitLossSchemaNode,
+  IProfitLossSheetNode,
+  IAccount,
+  IProfitLossSheetAccountNode,
+} from '@/interfaces';
+import { ProfitLossShema } from './ProfitLossSchema';
+import { ProfitLossSheetPercentage } from './ProfitLossSheetPercentage';
+import { ProfitLossSheetQuery } from './ProfitLossSheetQuery';
+import { ProfitLossSheetRepository } from './ProfitLossSheetRepository';
+import { ProfitLossSheetBase } from './ProfitLossSheetBase';
+import { ProfitLossSheetDatePeriods } from './ProfitLossSheetDatePeriods';
+import { FinancialEvaluateEquation } from '../FinancialEvaluateEquation';
+import { ProfitLossSheetPreviousYear } from './ProfitLossSheetPreviousYear';
+import { ProfitLossSheetPreviousPeriod } from './ProfitLossSheetPreviousPeriod';
+import { FinancialDateRanges } from '../FinancialDateRanges';
+import { ProfitLossSheetFilter } from './ProfitLossSheetFilter';
+
+export default class ProfitLossSheet extends R.compose(
+  ProfitLossSheetPreviousYear,
+  ProfitLossSheetPreviousPeriod,
+  ProfitLossSheetPercentage,
+  ProfitLossSheetDatePeriods,
+  ProfitLossSheetFilter,
+  ProfitLossShema,
+  ProfitLossSheetBase,
+  FinancialDateRanges,
+  FinancialEvaluateEquation,
+  FinancialSheetStructure
+)(FinancialSheet) {
+  /**
+   * Profit/Loss sheet query.
+   * @param {ProfitLossSheetQuery}
+   */
+  readonly query: ProfitLossSheetQuery;
+  /**
+   * @param {string}
+   */
+  readonly comparatorDateType: string;
+
+  /**
+   * Organization's base currency.
+   * @param {string}
+   */
+  readonly baseCurrency: string;
+
+  /**
+   * Profit/Loss repository.
+   * @param {ProfitLossSheetRepository}
+   */
+  readonly repository: ProfitLossSheetRepository;
+
+  /**
+   * Constructor method.
+   * @param {IProfitLossSheetQuery} query -
+   * @param {IAccount[]} accounts -
+   * @param {IJournalPoster} transactionsJournal -
+   */
+  constructor(
+    repository: ProfitLossSheetRepository,
+    query: IProfitLossSheetQuery,
+    baseCurrency: string,
+    i18n: any
+  ) {
+    super();
+
+    this.query = new ProfitLossSheetQuery(query);
+    this.repository = repository;
+    this.numberFormat = this.query.query.numberFormat;
+    this.baseCurrency = baseCurrency;
+    this.i18n = i18n;
+  }
+
+  /**
+   * Retrieve the sheet account node from the given account.
+   * @param   {IAccount} account
+   * @returns {IProfitLossSheetAccountNode}
+   */
+  private accountNodeMapper = (
+    account: IAccount
+  ): IProfitLossSheetAccountNode => {
+    const total = this.repository.totalAccountsLedger
+      .whereAccountId(account.id)
+      .getClosingBalance();
+
+    return {
+      id: account.id,
+      name: account.name,
+      nodeType: ProfitLossNodeType.ACCOUNT,
+      total: this.getAmountMeta(total),
+    };
+  };
+
+  /**
+   * Compose account node.
+   * @param   {IAccount} node
+   * @returns {IProfitLossSheetAccountNode}
+   */
+  private accountNodeCompose = (
+    account: IAccount
+  ): IProfitLossSheetAccountNode => {
+    return R.compose(
+      R.when(
+        this.query.isPreviousPeriodActive,
+        this.previousPeriodAccountNodeCompose
+      ),
+      R.when(
+        this.query.isPreviousYearActive,
+        this.previousYearAccountNodeCompose
+      ),
+      R.when(
+        this.query.isDatePeriodsColumnsType,
+        this.assocAccountNodeDatePeriod
+      ),
+      this.accountNodeMapper
+    )(account);
+  };
+
+  /**
+   * Retrieve report accounts nodes by the given accounts types.
+   * @param   {string[]} types
+   * @returns {IBalanceSheetAccountNode}
+   */
+  private getAccountsNodesByTypes = (
+    types: string[]
+  ): IProfitLossSheetAccountNode[] => {
+    return R.compose(
+      R.map(this.accountNodeCompose),
+      R.flatten,
+      R.map(this.repository.getAccountsByType)
+    )(types);
+  };
+
+  /**
+   * Mapps the accounts schema node to report node.
+   * @param   {IProfitLossSchemaNode} node
+   * @returns {IProfitLossSheetNode}
+   */
+  private accountsSchemaNodeMapper = (
+    node: IProfitLossAccountsSchemaNode
+  ): IProfitLossSheetNode => {
+    // Retrieve accounts node by the given types.
+    const children = this.getAccountsNodesByTypes(node.accountsTypes);
+
+    // Retrieve the total of the given nodes.
+    const total = this.getTotalOfNodes(children);
+
+    return {
+      id: node.id,
+      name: this.i18n.__(node.name),
+      nodeType: ProfitLossNodeType.ACCOUNTS,
+      total: this.getTotalAmountMeta(total),
+      children,
+    };
+  };
+
+  /**
+   * Accounts schema node composer.
+   * @param   {IProfitLossSchemaNode} node
+   * @returns {IProfitLossSheetAccountsNode}
+   */
+  private accountsSchemaNodeCompose = (
+    node: IProfitLossSchemaNode
+  ): IProfitLossSheetAccountsNode => {
+    return R.compose(
+      R.when(
+        this.query.isPreviousPeriodActive,
+        this.previousPeriodAggregateNodeCompose
+      ),
+      R.when(
+        this.query.isPreviousYearActive,
+        this.previousYearAggregateNodeCompose
+      ),
+      R.when(
+        this.query.isDatePeriodsColumnsType,
+        this.assocAggregateDatePeriod
+      ),
+      this.accountsSchemaNodeMapper
+    )(node);
+  };
+
+  /**
+   * Equation schema node parser.
+   * @param {(IProfitLossSchemaNode | IProfitLossSheetNode)[]} accNodes -
+   * @param {IProfitLossEquationSchemaNode} node -
+   * @param {IProfitLossSheetEquationNode}
+   */
+  private equationSchemaNodeParser = R.curry(
+    (
+      accNodes: (IProfitLossSchemaNode | IProfitLossSheetNode)[],
+      node: IProfitLossEquationSchemaNode
+    ): IProfitLossSheetEquationNode => {
+      const tableNodes = this.getNodesTableForEvaluating(
+        'total.amount',
+        accNodes
+      );
+      // Evaluate the given equation.
+      const total = this.evaluateEquation(node.equation, tableNodes);
+
+      return {
+        id: node.id,
+        name: this.i18n.__(node.name),
+        nodeType: ProfitLossNodeType.EQUATION,
+        total: this.getTotalAmountMeta(total),
+      };
+    }
+  );
+
+  /**
+   * Equation schema node composer.
+   * @param   {(IProfitLossSchemaNode | IProfitLossSheetNode)[]} accNodes -
+   * @param   {IProfitLossSchemaNode} node -
+   * @returns {IProfitLossSheetEquationNode}
+   */
+  private equationSchemaNodeCompose = R.curry(
+    (
+      accNodes: (IProfitLossSchemaNode | IProfitLossSheetNode)[],
+      node: IProfitLossEquationSchemaNode
+    ): IProfitLossSheetEquationNode => {
+      return R.compose(
+        R.when(
+          this.query.isPreviousPeriodActive,
+          this.previousPeriodEquationNodeCompose(accNodes, node.equation)
+        ),
+        R.when(
+          this.query.isPreviousYearActive,
+          this.previousYearEquationNodeCompose(accNodes, node.equation)
+        ),
+        R.when(
+          this.query.isDatePeriodsColumnsType,
+          this.assocEquationNodeDatePeriod(accNodes, node.equation)
+        ),
+        this.equationSchemaNodeParser(accNodes)
+      )(node);
+    }
+  );
+
+  /**
+   * Parses accounts schema node to report node.
+   * @param   {IProfitLossSchemaNode} schemaNode
+   * @returns {IProfitLossSheetNode | IProfitLossSchemaNode}
+   */
+  private accountsSchemaNodeMap = (
+    schemaNode: IProfitLossSchemaNode
+  ): IProfitLossSheetNode | IProfitLossSchemaNode => {
+    return R.compose(
+      R.when(
+        this.isNodeType(ProfitLossNodeType.ACCOUNTS),
+        this.accountsSchemaNodeCompose
+      )
+    )(schemaNode);
+  };
+
+  /**
+   * Composes schema equation node to report node.
+   * @param   {IProfitLossSheetNode | IProfitLossSchemaNode} node
+   * @param   {number} key
+   * @param   {IProfitLossSheetNode | IProfitLossSchemaNode} parentValue
+   * @param   {(IProfitLossSheetNode | IProfitLossSchemaNode)[]} accNodes
+   * @param   context
+   * @returns {IProfitLossSheetEquationNode}
+   */
+  private reportSchemaEquationNodeCompose = (
+    node: IProfitLossSheetNode | IProfitLossSchemaNode,
+    key: number,
+    parentValue: IProfitLossSheetNode | IProfitLossSchemaNode,
+    accNodes: (IProfitLossSheetNode | IProfitLossSchemaNode)[],
+    context
+  ): IProfitLossSheetEquationNode => {
+    return R.compose(
+      R.when(
+        this.isNodeType(ProfitLossNodeType.EQUATION),
+        this.equationSchemaNodeCompose(accNodes)
+      )
+    )(node);
+  };
+
+  /**
+   * Parses schema accounts nodes.
+   * @param   {IProfitLossSchemaNode[]}
+   * @returns {(IProfitLossSheetNode | IProfitLossSchemaNode)[]}
+   */
+  private reportSchemaAccountsNodesCompose = (
+    schemaNodes: IProfitLossSchemaNode[]
+  ): (IProfitLossSheetNode | IProfitLossSchemaNode)[] => {
+    return this.mapNodesDeep(schemaNodes, this.accountsSchemaNodeMap);
+  };
+
+  /**
+   * Parses schema equation nodes.
+   * @param   {(IProfitLossSheetNode | IProfitLossSchemaNode)[]} nodes
+   * @returns {(IProfitLossSheetNode | IProfitLossSchemaNode)[]}
+   */
+  private reportSchemaEquationNodesCompose = (
+    nodes: (IProfitLossSheetNode | IProfitLossSchemaNode)[]
+  ): (IProfitLossSheetNode | IProfitLossSchemaNode)[] => {
+    return this.mapAccNodesDeep(nodes, this.reportSchemaEquationNodeCompose);
+  };
+
+  /**
+   * Retrieve profit/loss report data.
+   * @return {IProfitLossSheetStatement}
+   */
+  public reportData = (): IProfitLossSheetNode => {
+    const schema = this.getSchema();
+
+    return R.compose(
+      this.reportFilterPlugin,
+      this.reportRowsPercentageCompose,
+      this.reportColumnsPerentageCompose,
+      this.reportSchemaEquationNodesCompose,
+      this.reportSchemaAccountsNodesCompose
+    )(schema);
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetBase.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetBase.ts
new file mode 100644
index 000000000..ea5888c55
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetBase.ts
@@ -0,0 +1,30 @@
+import * as R from 'ramda';
+import { TOTAL_NODE_TYPES } from './constants';
+
+export const ProfitLossSheetBase = (Base) =>
+  class extends Base {
+    /**
+     *
+     * @param type
+     * @param node
+     * @returns
+     */
+    public isNodeType = R.curry((type: string, node) => {
+      return node.nodeType === type;
+    });
+
+    protected isNodeTypeIn = R.curry((types: string[], node) => {
+      return types.indexOf(node.nodeType) !== -1;
+    });
+
+    /**
+     * 
+     */
+    protected findNodeById = R.curry((id, nodes) => {
+      return this.findNodeDeep(nodes, (node) => node.id === id);
+    });
+
+    isNodeTotal = (node) => {
+      return this.isNodeTypeIn(TOTAL_NODE_TYPES, node);
+    }
+  };
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetDatePeriods.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetDatePeriods.ts
new file mode 100644
index 000000000..8f0f5650a
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetDatePeriods.ts
@@ -0,0 +1,236 @@
+import * as R from 'ramda';
+import { sumBy } from 'lodash';
+import { FinancialDatePeriods } from '../FinancialDatePeriods';
+import {
+  IDateRange,
+  IProfitLossHorizontalDatePeriodNode,
+  IProfitLossSheetAccountNode,
+  IProfitLossSheetAccountsNode,
+  IProfitLossSheetCommonNode,
+  IProfitLossSheetNode,
+} from '@/interfaces';
+
+export const ProfitLossSheetDatePeriods = (Base) =>
+  class extends R.compose(FinancialDatePeriods)(Base) {
+    /**
+     * Retrieves the date periods based on the report query.
+     * @returns {IDateRange[]}
+     */
+    get datePeriods(): IDateRange[] {
+      return this.getDateRanges(
+        this.query.fromDate,
+        this.query.toDate,
+        this.query.displayColumnsBy
+      );
+    }
+
+    /**
+     * Retrieves the date periods of the given node based on the report query.
+     * @param   {IProfitLossSheetCommonNode} node
+     * @param   {Function} callback
+     * @returns {}
+     */
+    protected getReportNodeDatePeriods = (
+      node: IProfitLossSheetCommonNode,
+      callback: (
+        node: IProfitLossSheetCommonNode,
+        fromDate: Date,
+        toDate: Date,
+        index: number
+      ) => any
+    ) => {
+      return this.getNodeDatePeriods(
+        this.query.fromDate,
+        this.query.toDate,
+        this.query.displayColumnsBy,
+        node,
+        callback
+      );
+    };
+
+    // --------------------------
+    // # Account Nodes.
+    // --------------------------
+    /**
+     * Retrieve account node date period total.
+     * @param   {IProfitLossSheetAccount} node
+     * @param   {Date} fromDate
+     * @param   {Date} toDate
+     * @returns {}
+     */
+    private getAccountNodeDatePeriodTotal = (
+      node: IProfitLossSheetAccountNode,
+      fromDate: Date,
+      toDate: Date
+    ) => {
+      const periodTotal = this.repository.periodsAccountsLedger
+        .whereAccountId(node.id)
+        .whereFromDate(fromDate)
+        .whereToDate(toDate)
+        .getClosingBalance();
+
+      return this.getDatePeriodTotalMeta(periodTotal, fromDate, toDate);
+    };
+
+    /**
+     * Retrieve account node date period.
+     * @param   {IProfitLossSheetAccountNode} node
+     * @returns {IProfitLossSheetAccountNode}
+     */
+    public getAccountNodeDatePeriod = (node: IProfitLossSheetAccountNode) => {
+      return this.getReportNodeDatePeriods(
+        node,
+        this.getAccountNodeDatePeriodTotal
+      );
+    };
+
+    /**
+     * Account date periods to the given account node.
+     * @param   {IProfitLossSheetAccountNode} node
+     * @returns {IProfitLossSheetAccountNode}
+     */
+    public assocAccountNodeDatePeriod = (
+      node: IProfitLossSheetAccountNode
+    ): IProfitLossSheetAccountNode => {
+      const datePeriods = this.getAccountNodeDatePeriod(node);
+
+      return R.assoc('horizontalTotals', datePeriods, node);
+    };
+
+    // --------------------------
+    // # Aggregate nodes.
+    // --------------------------
+    /**
+     * Retrieves sumation of the given aggregate node children totals.
+     * @param   {IProfitLossSheetAccountsNode} node
+     * @param   {number} index
+     * @returns {number}
+     */
+    private getAggregateDatePeriodIndexTotal = (
+      node: IProfitLossSheetAccountsNode,
+      index: number
+    ): number => {
+      return sumBy(node.children, `horizontalTotals[${index}].total.amount`);
+    };
+
+    /**
+     *
+     * @param    {IProfitLossSheetAccount} node
+     * @param    {Date} fromDate
+     * @param    {Date} toDate
+     * @param    {number} index
+     * @returns  {IProfitLossSheetAccount}
+     */
+    private getAggregateNodeDatePeriodTotal = R.curry(
+      (
+        node: IProfitLossSheetAccountsNode,
+        fromDate: Date,
+        toDate: Date,
+        index: number
+      ): IProfitLossHorizontalDatePeriodNode => {
+        const periodTotal = this.getAggregateDatePeriodIndexTotal(node, index);
+
+        return this.getDatePeriodTotalMeta(periodTotal, fromDate, toDate);
+      }
+    );
+
+    /**
+     * Retrieves aggregate horizontal date periods.
+     * @param   {IProfitLossSheetAccountsNode} node
+     * @returns {IProfitLossSheetAccountsNode}
+     */
+    private getAggregateNodeDatePeriod = (
+      node: IProfitLossSheetAccountsNode
+    ): IProfitLossHorizontalDatePeriodNode[] => {
+      return this.getReportNodeDatePeriods(
+        node,
+        this.getAggregateNodeDatePeriodTotal
+      );
+    };
+
+    /**
+     * Assoc horizontal date periods to aggregate node.
+     * @param   {IProfitLossSheetAccountsNode} node
+     * @returns {IProfitLossSheetAccountsNode}
+     */
+    protected assocAggregateDatePeriod = (
+      node: IProfitLossSheetAccountsNode
+    ): IProfitLossSheetAccountsNode => {
+      const datePeriods = this.getAggregateNodeDatePeriod(node);
+
+      return R.assoc('horizontalTotals', datePeriods, node);
+    };
+
+    // --------------------------
+    // # Equation nodes.
+    // --------------------------
+    /**
+     * Retrieves equation date period node.
+     * @param   {IProfitLossSheetNode[]} accNodes
+     * @param   {IProfitLossSheetNode} node
+     * @param   {Date} fromDate
+     * @param   {Date} toDate
+     * @param   {number} index
+     * @returns {IProfitLossHorizontalDatePeriodNode}
+     */
+    private getEquationNodeDatePeriod = R.curry(
+      (
+        accNodes: IProfitLossSheetNode[],
+        equation: string,
+        node: IProfitLossSheetNode,
+        fromDate: Date,
+        toDate: Date,
+        index: number
+      ): IProfitLossHorizontalDatePeriodNode => {
+        const tableNodes = this.getNodesTableForEvaluating(
+          `horizontalTotals[${index}].total.amount`,
+          accNodes
+        );
+        // Evaluate the given equation.
+        const total = this.evaluateEquation(equation, tableNodes);
+
+        return this.getDatePeriodTotalMeta(total, fromDate, toDate);
+      }
+    );
+
+    /**
+     * Retrieves the equation node date periods.
+     * @param   {IProfitLossSheetNode[]} node
+     * @param   {string} equation
+     * @param   {IProfitLossSheetNode} node
+     * @returns {IProfitLossHorizontalDatePeriodNode[]}
+     */
+    private getEquationNodeDatePeriods = R.curry(
+      (
+        accNodes: IProfitLossSheetNode[],
+        equation: string,
+        node: IProfitLossSheetNode
+      ): IProfitLossHorizontalDatePeriodNode[] => {
+        return this.getReportNodeDatePeriods(
+          node,
+          this.getEquationNodeDatePeriod(accNodes, equation)
+        );
+      }
+    );
+
+    /**
+     * Assoc equation node date period.
+     * @param   {IProfitLossSheetNode[]}
+     * @param   {IProfitLossSheetNode} node
+     * @returns {IProfitLossSheetNode}
+     */
+    protected assocEquationNodeDatePeriod = R.curry(
+      (
+        accNodes: IProfitLossSheetNode[],
+        equation: string,
+        node: IProfitLossSheetNode
+      ): IProfitLossSheetNode => {
+        const periods = this.getEquationNodeDatePeriods(
+          accNodes,
+          equation,
+          node
+        );
+        return R.assoc('horizontalTotals', periods, node);
+      }
+    );
+  };
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetFilter.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetFilter.ts
new file mode 100644
index 000000000..864cf1fbe
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetFilter.ts
@@ -0,0 +1,170 @@
+import * as R from 'ramda';
+import { get } from 'lodash';
+import { IProfitLossSheetNode, ProfitLossNodeType } from '@/interfaces';
+import { FinancialFilter } from '../FinancialFilter';
+import { ProfitLossSheetBase } from './ProfitLossSheetBase';
+import { ProfitLossSheetQuery } from './ProfitLossSheetQuery';
+
+export const ProfitLossSheetFilter = (Base) =>
+  class extends R.compose(FinancialFilter, ProfitLossSheetBase)(Base) {
+    query: ProfitLossSheetQuery;
+
+    // ----------------
+    // # Account.
+    // ----------------
+    /**
+     * Filter report node detarmine.
+     * @param  {IProfitLossSheetNode} node - Balance sheet node.
+     * @return {boolean}
+     */
+    private accountNoneZeroNodesFilterDetarminer = (
+      node: IProfitLossSheetNode
+    ): boolean => {
+      return R.ifElse(
+        this.isNodeType(ProfitLossNodeType.ACCOUNT),
+        this.isNodeNoneZero,
+        R.always(true)
+      )(node);
+    };
+
+    /**
+     * Detarmines account none-transactions node.
+     * @param   {IBalanceSheetDataNode} node
+     * @returns {boolean}
+     */
+    private accountNoneTransFilterDetarminer = (
+      node: IProfitLossSheetNode
+    ): boolean => {
+      return R.ifElse(
+        this.isNodeType(ProfitLossNodeType.ACCOUNT),
+        this.isNodeNoneZero,
+        R.always(true)
+      )(node);
+    };
+
+    /**
+     * Report nodes filter.
+     * @param  {IProfitLossSheetNode[]} nodes -
+     * @return {IProfitLossSheetNode[]}
+     */
+    private accountsNoneZeroNodesFilter = (
+      nodes: IProfitLossSheetNode[]
+    ): IProfitLossSheetNode[] => {
+      return this.filterNodesDeep(
+        nodes,
+        this.accountNoneZeroNodesFilterDetarminer
+      );
+    };
+
+    /**
+     * Filters the accounts none-transactions nodes.
+     * @param   {IProfitLossSheetNode[]} nodes
+     * @returns {IProfitLossSheetNode[]}
+     */
+    private accountsNoneTransactionsNodesFilter = (
+      nodes: IProfitLossSheetNode[]
+    ) => {
+      return this.filterNodesDeep(nodes, this.accountNoneTransFilterDetarminer);
+    };
+
+    // ----------------
+    // # Aggregate.
+    // ----------------
+    /**
+     * Detearmines aggregate none-children filtering.
+     * @param   {IProfitLossSheetNode} node
+     * @returns {boolean}
+     */
+    private aggregateNoneChildrenFilterDetarminer = (
+      node: IProfitLossSheetNode
+    ): boolean => {
+      const schemaNode = this.getSchemaNodeById(node.id);
+
+      // Detarmines whether the given node is aggregate node.
+      const isAggregateNode = this.isNodeType(
+        ProfitLossNodeType.ACCOUNTS,
+        node
+      );
+      // Detarmines if the schema node is always should show.
+      const isSchemaAlwaysShow = get(schemaNode, 'alwaysShow', false);
+
+      // Should node has children if aggregate node or not always show.
+      return isAggregateNode && !isSchemaAlwaysShow
+        ? this.isNodeHasChildren(node)
+        : true;
+    };
+
+    /**
+     * Filters aggregate none-children nodes.
+     * @param   {IProfitLossSheetNode[]} nodes
+     * @returns {IProfitLossSheetNode[]}
+     */
+    private aggregateNoneChildrenFilter = (
+      nodes: IProfitLossSheetNode[]
+    ): IProfitLossSheetNode[] => {
+      return this.filterNodesDeep2(
+        this.aggregateNoneChildrenFilterDetarminer,
+        nodes
+      );
+    };
+
+    // ----------------
+    // # Composers.
+    // ----------------
+    /**
+     * Filters none-zero nodes.
+     * @param   {IProfitLossSheetNode[]} nodes
+     * @returns {IProfitLossSheetNode[]}
+     */
+    private filterNoneZeroNodesCompose = (
+      nodes: IProfitLossSheetNode[]
+    ): IProfitLossSheetNode[] => {
+      return R.compose(
+        this.aggregateNoneChildrenFilter,
+        this.accountsNoneZeroNodesFilter
+      )(nodes);
+    };
+
+    /**
+     * Filters none-transactions nodes.
+     * @param   {IProfitLossSheetNode[]} nodes
+     * @returns {IProfitLossSheetNode[]}
+     */
+    private filterNoneTransNodesCompose = (
+      nodes: IProfitLossSheetNode[]
+    ): IProfitLossSheetNode[] => {
+      return R.compose(
+        this.aggregateNoneChildrenFilter,
+        this.accountsNoneTransactionsNodesFilter
+      )(nodes);
+    };
+
+    /**
+     * Supress nodes when total accounts range transactions is empty.
+     * @param   {IProfitLossSheetNode[]} nodes
+     * @returns {IProfitLossSheetNode[]}
+     */
+    private supressNodesWhenRangeTransactionsEmpty = (
+      nodes: IProfitLossSheetNode[]
+    ) => {
+      return this.repository.totalAccountsLedger.isEmpty() ? [] : nodes;
+    };
+
+    /**
+     * Compose report nodes filtering.
+     * @param   {IProfitLossSheetNode[]} nodes
+     * @returns {IProfitLossSheetNode[]}
+     */
+    protected reportFilterPlugin = (
+      nodes: IProfitLossSheetNode[]
+    ): IProfitLossSheetNode[] => {
+      return R.compose(
+        this.supressNodesWhenRangeTransactionsEmpty,
+        R.when(() => this.query.noneZero, this.filterNoneZeroNodesCompose),
+        R.when(
+          () => this.query.noneTransactions,
+          this.filterNoneTransNodesCompose
+        )
+      )(nodes);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetPercentage.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetPercentage.ts
new file mode 100644
index 000000000..e84fdc1a8
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetPercentage.ts
@@ -0,0 +1,301 @@
+import * as R from 'ramda';
+import {
+  IProfitLossSheetNode,
+  IProfitLossSheetTotal,
+  ProfitLossAggregateNodeId,
+} from '@/interfaces';
+import { FinancialHorizTotals } from '../FinancialHorizTotals';
+
+export const ProfitLossSheetPercentage = (Base) =>
+  class extends R.compose(FinancialHorizTotals)(Base) {
+    /**
+     * Assoc column of percentage attribute to the given node.
+     * @param  {IProfitLossSheetNode} netIncomeNode -
+     * @param  {IProfitLossSheetNode} node -
+     * @return {IProfitLossSheetNode}
+     */
+    private assocColumnPercentage = R.curry(
+      (
+        propertyPath: string,
+        parentNode: IProfitLossSheetNode,
+        node: IProfitLossSheetNode
+      ) => {
+        const percentage = this.getPercentageBasis(
+          parentNode.total.amount,
+          node.total.amount
+        );
+        return R.assoc(
+          propertyPath,
+          this.getPercentageAmountMeta(percentage),
+          node
+        );
+      }
+    );
+
+    /**
+     * Assoc column of percentage attribute to the given node.
+     * @param  {IProfitLossSheetNode} netIncomeNode -
+     * @param  {IProfitLossSheetNode} node -
+     * @return {IProfitLossSheetNode}
+     */
+    private assocColumnTotalPercentage = R.curry(
+      (
+        propertyPath: string,
+        parentNode: IProfitLossSheetNode,
+        node: IProfitLossSheetNode
+      ) => {
+        const percentage = this.getPercentageBasis(
+          parentNode.total.amount,
+          node.total.amount
+        );
+        return R.assoc(
+          propertyPath,
+          this.getPercentageTotalAmountMeta(percentage),
+          node
+        );
+      }
+    );
+
+    /**
+     * Compose percentage of columns.
+     * @param   {IProfitLossSheetNode[]} nodes
+     * @returns {IProfitLossSheetNode[]}
+     */
+    private columnPercentageCompose = (
+      nodes: IProfitLossSheetNode[]
+    ): IProfitLossSheetNode[] => {
+      const netIncomeNode = this.findNodeById(
+        ProfitLossAggregateNodeId.NET_INCOME,
+        nodes
+      );
+      return this.mapNodesDeep(
+        nodes,
+        this.columnPercentageMapper(netIncomeNode)
+      );
+    };
+
+    /**
+     * Compose percentage of income.
+     * @param   {IProfitLossSheetNode[]} nodes
+     * @returns {IProfitLossSheetNode[]}
+     */
+    private incomePercetageCompose = (
+      nodes: IProfitLossSheetNode[]
+    ): IProfitLossSheetNode[] => {
+      const incomeNode = this.findNodeById(
+        ProfitLossAggregateNodeId.INCOME,
+        nodes
+      );
+      return this.mapNodesDeep(nodes, this.incomePercentageMapper(incomeNode));
+    };
+
+    /**
+     *
+     * @param {IProfitLossSheetNode[]} nodes
+     * @returns {IProfitLossSheetNode[]}
+     */
+    private rowPercentageCompose = (
+      nodes: IProfitLossSheetNode[]
+    ): IProfitLossSheetNode[] => {
+      return this.mapNodesDeep(nodes, this.rowPercentageMap);
+    };
+
+    /**
+     *
+     * @param  {IProfitLossSheetNode} netIncomeNode -
+     * @param  {IProfitLossSheetNode} node -
+     * @return {IProfitLossSheetNode}
+     */
+    private columnPercentageMapper = R.curry(
+      (netIncomeNode: IProfitLossSheetNode, node: IProfitLossSheetNode) => {
+        const path = 'percentageColumn';
+
+        return R.compose(
+          R.when(
+            this.isNodeHasHorizTotals,
+            this.assocColumnPercentageHorizTotals(netIncomeNode)
+          ),
+          R.ifElse(
+            this.isNodeTotal,
+            this.assocColumnTotalPercentage(path, netIncomeNode),
+            this.assocColumnPercentage(path, netIncomeNode)
+          )
+        )(node);
+      }
+    );
+
+    /**
+     *
+     * @param   {IProfitLossSheetNode} node
+     * @returns {IProfitLossSheetNode}
+     */
+    private rowPercentageMap = (
+      node: IProfitLossSheetNode
+    ): IProfitLossSheetNode => {
+      const path = 'percentageRow';
+
+      return R.compose(
+        R.when(this.isNodeHasHorizTotals, this.assocRowPercentageHorizTotals),
+        R.ifElse(
+          this.isNodeTotal,
+          this.assocColumnTotalPercentage(path, node),
+          this.assocColumnPercentage(path, node)
+        )
+      )(node);
+    };
+
+    /**
+     *
+     * @param   {IProfitLossSheetNode} incomeNode -
+     * @param   {IProfitLossSheetNode} node -
+     * @returns {IProfitLossSheetNode}
+     */
+    private incomePercentageMapper = R.curry(
+      (incomeNode: IProfitLossSheetNode, node: IProfitLossSheetNode) => {
+        const path = 'percentageIncome';
+
+        return R.compose(
+          R.when(
+            this.isNodeHasHorizTotals,
+            this.assocIncomePercentageHorizTotals(incomeNode)
+          ),
+          R.ifElse(
+            this.isNodeTotal,
+            this.assocColumnTotalPercentage(path, incomeNode),
+            this.assocColumnPercentage(path, incomeNode)
+          )
+        )(node);
+      }
+    );
+
+    /**
+     *
+     * @param {IProfitLossSheetNode} expenseNode -
+     * @param {IProfitLossSheetNode} node -
+     */
+    private expensePercentageMapper = R.curry(
+      (expenseNode: IProfitLossSheetNode, node: IProfitLossSheetNode) => {
+        const path = 'percentageExpense';
+
+        return R.compose(
+          R.when(
+            this.isNodeHasHorizTotals,
+            this.assocExpensePercentageHorizTotals(expenseNode)
+          ),
+          R.ifElse(
+            this.isNodeTotal,
+            this.assocColumnTotalPercentage(path, expenseNode),
+            this.assocColumnPercentage(path, expenseNode)
+          )
+        )(node);
+      }
+    );
+
+    /**
+     * Compose percentage of expense.
+     * @param   {IProfitLossSheetNode[]} nodes
+     * @returns {IProfitLossSheetNode[]}
+     */
+    private expensesPercentageCompose = (
+      nodes: IProfitLossSheetNode[]
+    ): IProfitLossSheetNode[] => {
+      const expenseNode = this.findNodeById(
+        ProfitLossAggregateNodeId.EXPENSES,
+        nodes
+      );
+      return this.mapNodesDeep(
+        nodes,
+        this.expensePercentageMapper(expenseNode)
+      );
+    };
+
+    /**
+     * Compose percentage attributes.
+     * @param   {IProfitLossSheetNode[]} nodes
+     * @returns {IProfitLossSheetNode[]}
+     */
+    protected reportColumnsPerentageCompose = (
+      nodes: IProfitLossSheetNode[]
+    ): IProfitLossSheetNode[] => {
+      return R.compose(
+        R.when(this.query.isIncomePercentage, this.incomePercetageCompose),
+        R.when(this.query.isColumnPercentage, this.columnPercentageCompose),
+        R.when(this.query.isExpensesPercentage, this.expensesPercentageCompose),
+        R.when(this.query.isRowPercentage, this.rowPercentageCompose)
+      )(nodes);
+    };
+
+    /**
+     *
+     * @param   {} nodes
+     * @returns {}
+     */
+    protected reportRowsPercentageCompose = (nodes) => {
+      return nodes;
+    };
+
+    // ----------------------------------
+    // # Horizontal Nodes
+    // ----------------------------------
+    /**
+     * Assoc incomer percentage to horizontal totals nodes.
+     * @param   {IProfitLossSheetNode} incomeNode -
+     * @param   {IProfitLossSheetNode} node -
+     * @returns {IProfitLossSheetNode}
+     */
+    private assocIncomePercentageHorizTotals = R.curry(
+      (incomeNode: IProfitLossSheetNode, node: IProfitLossSheetNode) => {
+        const horTotalsWithIncomePerc = this.assocPercentageHorizTotals(
+          'percentageIncome',
+          incomeNode,
+          node
+        );
+        return R.assoc('horizontalTotals', horTotalsWithIncomePerc, node);
+      }
+    );
+
+    /**
+     * Assoc expense percentage to horizontal totals nodes.
+     * @param   {IProfitLossSheetNode} expenseNode -
+     * @param   {IProfitLossSheetNode} node -
+     * @returns {IProfitLossSheetNode}
+     */
+    private assocExpensePercentageHorizTotals = R.curry(
+      (expenseNode: IProfitLossSheetNode, node: IProfitLossSheetNode) => {
+        const horTotalsWithExpensePerc = this.assocPercentageHorizTotals(
+          'percentageExpense',
+          expenseNode,
+          node
+        );
+        return R.assoc('horizontalTotals', horTotalsWithExpensePerc, node);
+      }
+    );
+
+    /**
+     * Assoc net income percentage to horizontal totals nodes.
+     * @param   {IProfitLossSheetNode} expenseNode -
+     * @param   {IProfitLossSheetNode} node -
+     * @returns {IProfitLossSheetNode}
+     */
+    private assocColumnPercentageHorizTotals = R.curry(
+      (netIncomeNode: IProfitLossSheetNode, node: IProfitLossSheetNode) => {
+        const horTotalsWithExpensePerc = this.assocPercentageHorizTotals(
+          'percentageColumn',
+          netIncomeNode,
+          node
+        );
+        return R.assoc('horizontalTotals', horTotalsWithExpensePerc, node);
+      }
+    );
+
+    /**
+     *
+     */
+    private assocRowPercentageHorizTotals = R.curry((node) => {
+      const horTotalsWithExpensePerc = this.assocHorizontalPercentageTotals(
+        'percentageRow',
+        node
+      );
+      return R.assoc('horizontalTotals', horTotalsWithExpensePerc, node);
+    });
+  };
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetPreviousPeriod.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetPreviousPeriod.ts
new file mode 100644
index 000000000..d8d0489d1
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetPreviousPeriod.ts
@@ -0,0 +1,395 @@
+import * as R from 'ramda';
+import { sumBy } from 'lodash';
+import {
+  IProfitLossHorizontalDatePeriodNode,
+  IProfitLossSchemaNode,
+  IProfitLossSheetAccountNode,
+  IProfitLossSheetAccountsNode,
+  IProfitLossSheetEquationNode,
+  IProfitLossSheetNode,
+} from '@/interfaces';
+import { FinancialPreviousPeriod } from '../FinancialPreviousPeriod';
+import { ProfitLossSheetQuery } from './ProfitLossSheetQuery';
+
+export const ProfitLossSheetPreviousPeriod = (Base) =>
+  class extends R.compose(FinancialPreviousPeriod)(Base) {
+    query: ProfitLossSheetQuery;
+
+    // ---------------------------
+    // # Account
+    // ---------------------------
+    /**
+     * Assoc previous period change attribute to account node.
+     * @param    {IProfitLossSheetAccountNode} accountNode
+     * @returns  {IProfitLossSheetAccountNode}
+     */
+    protected assocPreviousPeriodTotalAccountNode = (
+      node: IProfitLossSheetAccountNode
+    ): IProfitLossSheetAccountNode => {
+      const total = this.repository.PPTotalAccountsLedger.whereAccountId(
+        node.id
+      ).getClosingBalance();
+
+      return R.assoc('previousPeriod', this.getAmountMeta(total), node);
+    };
+
+    /**
+     * Compose previous period account node.
+     * @param   {IProfitLossSheetAccountNode} accountNode
+     * @returns {IProfitLossSheetAccountNode}
+     */
+    protected previousPeriodAccountNodeCompose = (
+      accountNode: IProfitLossSheetAccountNode
+    ): IProfitLossSheetAccountNode => {
+      return R.compose(
+        R.when(
+          this.isNodeHasHorizTotals,
+          this.assocPreviousPeriodAccountHorizNodeCompose
+        ),
+        R.when(
+          this.query.isPreviousPeriodPercentageActive,
+          this.assocPreviousPeriodPercentageNode
+        ),
+        R.when(
+          this.query.isPreviousPeriodChangeActive,
+          this.assocPreviousPeriodChangeNode
+        ),
+        this.assocPreviousPeriodTotalAccountNode
+      )(accountNode);
+    };
+
+    // ---------------------------
+    // # Aggregate
+    // ---------------------------
+    /**
+     * Assoc previous period total attribute to aggregate node.
+     * @param   {IProfitLossSheetAccountNode} accountNode
+     * @returns {IProfitLossSheetAccountNode}
+     */
+    private assocPreviousPeriodTotalAggregateNode = (
+      node: IProfitLossSheetAccountNode
+    ) => {
+      const total = sumBy(node.children, 'previousPeriod.amount');
+
+      return R.assoc('previousPeriod', this.getTotalAmountMeta(total), node);
+    };
+
+    /**
+     * Compose previous period to aggregate node.
+     * @param   {IProfitLossSheetAccountNode} accountNode
+     * @returns {IProfitLossSheetAccountNode}
+     */
+    protected previousPeriodAggregateNodeCompose = (
+      accountNode: IProfitLossSheetAccountNode
+    ): IProfitLossSheetAccountNode => {
+      return R.compose(
+        R.when(
+          this.isNodeHasHorizTotals,
+          this.assocPreviousPeriodAggregateHorizNode
+        ),
+        R.when(
+          this.query.isPreviousPeriodPercentageActive,
+          this.assocPreviousPeriodTotalPercentageNode
+        ),
+        R.when(
+          this.query.isPreviousPeriodChangeActive,
+          this.assocPreviousPeriodTotalChangeNode
+        ),
+        this.assocPreviousPeriodTotalAggregateNode
+      )(accountNode);
+    };
+
+    // ---------------------------
+    // # Equation
+    // --------------------------
+    /**
+     *
+     * @param   {(IProfitLossSchemaNode | IProfitLossSheetNode)[]} accNodes
+     * @param   {string} equation
+     * @param   {IProfitLossSheetNode} node
+     * @returns {IProfitLossSheetEquationNode}
+     */
+    private assocPreviousPeriodTotalEquationNode = R.curry(
+      (
+        accNodes: (IProfitLossSchemaNode | IProfitLossSheetNode)[],
+        equation: string,
+        node: IProfitLossSheetEquationNode
+      ): IProfitLossSheetEquationNode => {
+        const previousPeriodNodePath = 'previousPeriod.amount';
+        const tableNodes = this.getNodesTableForEvaluating(
+          previousPeriodNodePath,
+          accNodes
+        );
+        // Evaluate the given equation.
+        const total = this.evaluateEquation(equation, tableNodes);
+
+        return R.assoc('previousPeriod', this.getTotalAmountMeta(total), node);
+      }
+    );
+
+    /**
+     *
+     * @param   {(IProfitLossSchemaNode | IProfitLossSheetNode)[]} accNodes -
+     * @param   {string} node
+     * @param   {IProfitLossSheetEquationNode} node
+     * @returns {IProfitLossSheetEquationNode}
+     */
+    protected previousPeriodEquationNodeCompose = R.curry(
+      (
+        accNodes: (IProfitLossSchemaNode | IProfitLossSheetNode)[],
+        equation: string,
+        node: IProfitLossSheetEquationNode
+      ): IProfitLossSheetEquationNode => {
+        return R.compose(
+          R.when(
+            this.isNodeHasHorizTotals,
+            this.assocPreviousPeriodEquationHorizNode(accNodes, equation)
+          ),
+          R.when(
+            this.query.isPreviousPeriodPercentageActive,
+            this.assocPreviousPeriodTotalPercentageNode
+          ),
+          R.when(
+            this.query.isPreviousPeriodChangeActive,
+            this.assocPreviousPeriodTotalChangeNode
+          ),
+          this.assocPreviousPeriodTotalEquationNode(accNodes, equation)
+        )(node);
+      }
+    );
+
+    // ---------------------------
+    // # Horizontal Nodes - Account
+    // --------------------------
+    /**
+     * Assoc previous period to account horizontal node.
+     * @param   {IProfitLossSheetAccountNode} node
+     * @param   {IProfitLossHorizontalDatePeriodNode} totalNode
+     * @returns {IProfitLossHorizontalDatePeriodNode}
+     */
+    private assocPerviousPeriodAccountHorizTotal = R.curry(
+      (
+        node: IProfitLossSheetAccountNode,
+        totalNode: IProfitLossHorizontalDatePeriodNode
+      ): IProfitLossHorizontalDatePeriodNode => {
+        const total = this.repository.PPPeriodsAccountsLedger.whereAccountId(
+          node.id
+        )
+          .whereFromDate(totalNode.previousPeriodFromDate.date)
+          .whereToDate(totalNode.previousPeriodToDate.date)
+          .getClosingBalance();
+
+        return R.assoc('previousPeriod', this.getAmountMeta(total), totalNode);
+      }
+    );
+
+    /**
+     * @param {IProfitLossSheetAccountNode} node
+     * @param {IProfitLossSheetTotal}
+     */
+    private previousPeriodAccountHorizNodeCompose = R.curry(
+      (
+        node: IProfitLossSheetAccountNode,
+        horizontalTotalNode: IProfitLossHorizontalDatePeriodNode,
+        index: number
+      ): IProfitLossHorizontalDatePeriodNode => {
+        return R.compose(
+          R.when(
+            this.query.isPreviousPeriodPercentageActive,
+            this.assocPreviousPeriodPercentageNode
+          ),
+          R.when(
+            this.query.isPreviousPeriodChangeActive,
+            this.assocPreviousPeriodChangeNode
+          ),
+          this.assocPerviousPeriodAccountHorizTotal(node),
+          this.assocPreviousPeriodHorizNodeFromToDates(
+            this.query.displayColumnsBy
+          )
+        )(horizontalTotalNode);
+      }
+    );
+
+    /**
+     *
+     * @param {IProfitLossSheetAccountNode} node
+     * @returns {IProfitLossSheetAccountNode}
+     */
+    private assocPreviousPeriodAccountHorizNodeCompose = (
+      node: IProfitLossSheetAccountNode
+    ): IProfitLossSheetAccountNode => {
+      const horizontalTotals = R.addIndex(R.map)(
+        this.previousPeriodAccountHorizNodeCompose(node),
+        node.horizontalTotals
+      );
+      return R.assoc('horizontalTotals', horizontalTotals, node);
+    };
+
+    // ----------------------------------
+    // # Horizontal Nodes - Aggregate
+    // ----------------------------------
+    /**
+     * Assoc previous period total to aggregate horizontal nodes.
+     * @param  {IProfitLossSheetAccountsNode} node
+     * @param  {number} index
+     * @param  {any} totalNode
+     * @return {}
+     */
+    private assocPreviousPeriodAggregateHorizTotal = R.curry(
+      (
+        node: IProfitLossSheetAccountsNode,
+        index: number,
+        totalNode: IProfitLossHorizontalDatePeriodNode
+      ) => {
+        const total = this.getPPHorizNodesTotalSumation(index, node);
+
+        return R.assoc(
+          'previousPeriod',
+          this.getTotalAmountMeta(total),
+          totalNode
+        );
+      }
+    );
+
+    /**
+     *
+     * @param   {IProfitLossSheetAccountsNode} node
+     * @param   {IProfitLossHorizontalDatePeriodNode} horizontalTotalNode -
+     * @param   {number} index
+     * @returns {IProfitLossHorizontalDatePeriodNode}
+     */
+    private previousPeriodAggregateHorizNodeCompose = R.curry(
+      (
+        node: IProfitLossSheetAccountsNode,
+        horizontalTotalNode: IProfitLossHorizontalDatePeriodNode,
+        index: number
+      ): IProfitLossHorizontalDatePeriodNode => {
+        return R.compose(
+          R.when(
+            this.query.isPreviousPeriodPercentageActive,
+            this.assocPreviousPeriodTotalPercentageNode
+          ),
+          R.when(
+            this.query.isPreviousPeriodChangeActive,
+            this.assocPreviousPeriodTotalChangeNode
+          ),
+          R.when(
+            this.query.isPreviousPeriodActive,
+            this.assocPreviousPeriodAggregateHorizTotal(node, index)
+          ),
+          R.when(
+            this.query.isPreviousPeriodActive,
+            this.assocPreviousPeriodHorizNodeFromToDates(
+              this.query.displayColumnsBy
+            )
+          )
+        )(horizontalTotalNode);
+      }
+    );
+
+    /**
+     * Assoc previous period to aggregate horizontal nodes.
+     * @param {IProfitLossSheetAccountsNode} node
+     * @returns
+     */
+    private assocPreviousPeriodAggregateHorizNode = (
+      node: IProfitLossSheetAccountsNode
+    ): IProfitLossSheetAccountsNode => {
+      const horizontalTotals = R.addIndex(R.map)(
+        this.previousPeriodAggregateHorizNodeCompose(node),
+        node.horizontalTotals
+      );
+      return R.assoc('horizontalTotals', horizontalTotals, node);
+    };
+
+    // ----------------------------------
+    // # Horizontal Nodes - Equation
+    // ----------------------------------
+    /**
+     *
+     * @param {IProfitLossSheetNode[]} accNodes -
+     * @param {string} equation
+     * @param {index} number
+     * @param {} totalNode
+     */
+    private assocPreviousPeriodEquationHorizTotal = R.curry(
+      (
+        accNodes: IProfitLossSheetNode[],
+        equation: string,
+        index: number,
+        totalNode
+      ): IProfitLossSheetNode => {
+        const scopes = this.getNodesTableForEvaluating(
+          `horizontalTotals[${index}].previousPeriod.amount`,
+          accNodes
+        );
+        const total = this.evaluateEquation(equation, scopes);
+
+        return R.assoc(
+          'previousPeriod',
+          this.getTotalAmountMeta(total),
+          totalNode
+        );
+      }
+    );
+
+    /**
+     *
+     * @param {IProfitLossSheetNode[]} accNodes -
+     * @param {string} equation
+     * @param {} horizontalTotalNode
+     * @param {number} index
+     */
+    private previousPeriodEquationHorizNodeCompose = R.curry(
+      (
+        accNodes: IProfitLossSheetNode[],
+        equation: string,
+        horizontalTotalNode,
+        index: number
+      ) => {
+        const assocHorizTotal = this.assocPreviousPeriodEquationHorizTotal(
+          accNodes,
+          equation,
+          index
+        );
+        return R.compose(
+          R.when(
+            this.query.isPreviousPeriodPercentageActive,
+            this.assocPreviousPeriodTotalPercentageNode
+          ),
+          R.when(
+            this.query.isPreviousPeriodChangeActive,
+            this.assocPreviousPeriodTotalChangeNode
+          ),
+          R.when(this.query.isPreviousPeriodActive, assocHorizTotal),
+          R.when(
+            this.query.isPreviousPeriodActive,
+            this.assocPreviousPeriodHorizNodeFromToDates(
+              this.query.displayColumnsBy
+            )
+          )
+        )(horizontalTotalNode);
+      }
+    );
+
+    /**
+     * Assoc previous period equation to horizontal nodes.
+     * @parma  {IProfitLossSheetNode[]} accNodes -
+     * @param  {string} equation
+     * @param  {IProfitLossSheetEquationNode} node
+     * @return {IProfitLossSheetEquationNode}
+     */
+    private assocPreviousPeriodEquationHorizNode = R.curry(
+      (
+        accNodes: IProfitLossSheetNode[],
+        equation: string,
+        node: IProfitLossSheetEquationNode
+      ): IProfitLossSheetEquationNode => {
+        const horizontalTotals = R.addIndex(R.map)(
+          this.previousPeriodEquationHorizNodeCompose(accNodes, equation),
+          node.horizontalTotals
+        );
+        return R.assoc('horizontalTotals', horizontalTotals, node);
+      }
+    );
+  };
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetPreviousYear.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetPreviousYear.ts
new file mode 100644
index 000000000..4695f3977
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetPreviousYear.ts
@@ -0,0 +1,367 @@
+import * as R from 'ramda';
+import { sumBy } from 'lodash';
+import { compose } from 'lodash/fp';
+import {
+  IProfitLossSheetEquationNode,
+  IProfitLossSheetAccountNode,
+  IProfitLossSchemaNode,
+  IProfitLossSheetNode,
+  IProfitLossSheetTotal,
+} from '@/interfaces';
+import { ProfitLossSheetRepository } from './ProfitLossSheetRepository';
+import { FinancialPreviousYear } from '../FinancialPreviousYear';
+
+export const ProfitLossSheetPreviousYear = (Base) =>
+  class extends compose(FinancialPreviousYear)(Base) {
+    repository: ProfitLossSheetRepository;
+
+    // ---------------------------
+    // # Account
+    // ---------------------------
+    /**
+     * Assoc previous year total attribute to account node.
+     * @param   {IProfitLossSheetAccountNode} accountNode
+     * @returns {IProfitLossSheetAccountNode}
+     */
+    private assocPreviousYearTotalAccountNode = (
+      accountNode: IProfitLossSheetAccountNode
+    ) => {
+      const total = this.repository.PYTotalAccountsLedger.whereAccountId(
+        accountNode.id
+      ).getClosingBalance();
+
+      return R.assoc('previousYear', this.getAmountMeta(total), accountNode);
+    };
+
+    /**
+     * Compose previous year account node.
+     * @param   {IProfitLossSheetAccountNode} accountNode
+     * @returns {IProfitLossSheetAccountNode}
+     */
+    protected previousYearAccountNodeCompose = (
+      accountNode: IProfitLossSheetAccountNode
+    ): IProfitLossSheetAccountNode => {
+      return R.compose(
+        R.when(
+          this.isNodeHasHorizTotals,
+          this.assocPreviousYearAccountHorizNodeCompose
+        ),
+        R.when(
+          this.query.isPreviousYearPercentageActive,
+          this.assocPreviousYearPercentageNode
+        ),
+        R.when(
+          this.query.isPreviousYearChangeActive,
+          this.assocPreviousYearChangetNode
+        ),
+        this.assocPreviousYearTotalAccountNode
+      )(accountNode);
+    };
+
+    // ---------------------------
+    // # Aggregate
+    // ---------------------------
+    /**
+     * Assoc previous year change attribute to aggregate node.
+     * @param    {IProfitLossSheetAccountNode} accountNode
+     * @returns  {IProfitLossSheetAccountNode}
+     */
+    private assocPreviousYearTotalAggregateNode = (
+      node: IProfitLossSheetAccountNode
+    ): IProfitLossSheetAccountNode => {
+      const total = sumBy(node.children, 'previousYear.amount');
+
+      return R.assoc('previousYear', this.getTotalAmountMeta(total), node);
+    };
+
+    /**
+     * Compose previous year to aggregate node.
+     * @param   {IProfitLossSheetAccountNode} accountNode
+     * @returns {IProfitLossSheetAccountNode}
+     */
+    protected previousYearAggregateNodeCompose = (
+      accountNode: IProfitLossSheetAccountNode
+    ): IProfitLossSheetAccountNode => {
+      return R.compose(
+        R.when(
+          this.isNodeHasHorizTotals,
+          this.assocPreviousYearAggregateHorizNode
+        ),
+        R.when(
+          this.query.isPreviousYearPercentageActive,
+          this.assocPreviousYearTotalPercentageNode
+        ),
+        R.when(
+          this.query.isPreviousYearChangeActive,
+          this.assocPreviousYearTotalChangeNode
+        ),
+        this.assocPreviousYearTotalAggregateNode
+      )(accountNode);
+    };
+
+    // ---------------------------
+    // # Equation
+    // ---------------------------
+    /**
+     * Assoc previous year total to equation node.
+     * @param   {(IProfitLossSchemaNode | IProfitLossSheetNode)[]} accNodes
+     * @param   {string} equation
+     * @param   {IProfitLossSheetNode} node
+     * @returns {IProfitLossSheetEquationNode}
+     */
+    private assocPreviousYearTotalEquationNode = R.curry(
+      (
+        accNodes: (IProfitLossSchemaNode | IProfitLossSheetNode)[],
+        equation: string,
+        node: IProfitLossSheetNode
+      ) => {
+        const previousPeriodNodePath = 'previousYear.amount';
+        const tableNodes = this.getNodesTableForEvaluating(
+          previousPeriodNodePath,
+          accNodes
+        );
+        // Evaluate the given equation.
+        const total = this.evaluateEquation(equation, tableNodes);
+
+        return R.assoc('previousYear', this.getTotalAmountMeta(total), node);
+      }
+    );
+
+    /**
+     * Previous year equation node.
+     * @param   {(IProfitLossSchemaNode | IProfitLossSheetNode)[]} accNodes -
+     * @param   {string} node
+     * @param   {IProfitLossSheetEquationNode} node
+     * @returns {IProfitLossSheetEquationNode}
+     */
+    protected previousYearEquationNodeCompose = R.curry(
+      (
+        accNodes: (IProfitLossSchemaNode | IProfitLossSheetNode)[],
+        equation: string,
+        node: IProfitLossSheetEquationNode
+      ) => {
+        return R.compose(
+          R.when(
+            this.isNodeHasHorizTotals,
+            this.assocPreviousYearEquationHorizNode(accNodes, equation)
+          ),
+          R.when(
+            this.query.isPreviousYearPercentageActive,
+            this.assocPreviousYearTotalPercentageNode
+          ),
+          R.when(
+            this.query.isPreviousYearChangeActive,
+            this.assocPreviousYearTotalChangeNode
+          ),
+          this.assocPreviousYearTotalEquationNode(accNodes, equation)
+        )(node);
+      }
+    );
+
+    // ----------------------------------
+    // # Horizontal Nodes - Account
+    // ----------------------------------
+    /**
+     * Assoc preivous year to account horizontal total node.
+     * @param   {IProfitLossSheetAccountNode} node
+     * @returns
+     */
+    private assocPreviousYearAccountHorizTotal = R.curry(
+      (node: IProfitLossSheetAccountNode, totalNode) => {
+        const total = this.repository.PYPeriodsAccountsLedger.whereAccountId(
+          node.id
+        )
+          .whereFromDate(totalNode.previousYearFromDate.date)
+          .whereToDate(totalNode.previousYearToDate.date)
+          .getClosingBalance();
+
+        return R.assoc('previousYear', this.getAmountMeta(total), totalNode);
+      }
+    );
+
+    /**
+     * Previous year account horizontal node composer.
+     * @param   {IProfitLossSheetAccountNode} horizontalTotalNode
+     * @param   {IProfitLossSheetTotal} horizontalTotalNode -
+     * @returns {IProfitLossSheetTotal}
+     */
+    private previousYearAccountHorizNodeCompose = R.curry(
+      (
+        node: IProfitLossSheetAccountNode,
+        horizontalTotalNode: IProfitLossSheetTotal
+      ): IProfitLossSheetTotal => {
+        return R.compose(
+          R.when(
+            this.query.isPreviousYearPercentageActive,
+            this.assocPreviousYearPercentageNode
+          ),
+          R.when(
+            this.query.isPreviousYearChangeActive,
+            this.assocPreviousYearChangetNode
+          ),
+          R.when(
+            this.query.isPreviousYearActive,
+            this.assocPreviousYearAccountHorizTotal(node)
+          ),
+          R.when(
+            this.query.isPreviousYearActive,
+            this.assocPreviousYearHorizNodeFromToDates
+          )
+        )(horizontalTotalNode);
+      }
+    );
+
+    /**
+     *
+     * @param   {IProfitLossSheetAccountNode} node
+     * @returns {IProfitLossSheetAccountNode}
+     */
+    private assocPreviousYearAccountHorizNodeCompose = (
+      node: IProfitLossSheetAccountNode
+    ): IProfitLossSheetAccountNode => {
+      const horizontalTotals = R.map(
+        this.previousYearAccountHorizNodeCompose(node),
+        node.horizontalTotals
+      );
+      return R.assoc('horizontalTotals', horizontalTotals, node);
+    };
+
+    // ----------------------------------
+    // # Horizontal Nodes - Aggregate
+    // ----------------------------------
+    /**
+     *
+     */
+    private assocPreviousYearAggregateHorizTotal = R.curry(
+      (node, index, totalNode) => {
+        const total = this.getPYHorizNodesTotalSumation(index, node);
+
+        return R.assoc(
+          'previousYear',
+          this.getTotalAmountMeta(total),
+          totalNode
+        );
+      }
+    );
+
+    /**
+     *
+     */
+    private previousYearAggregateHorizNodeCompose = R.curry(
+      (node, horizontalTotalNode, index: number) => {
+        return R.compose(
+          R.when(
+            this.query.isPreviousYearPercentageActive,
+            this.assocPreviousYearTotalPercentageNode
+          ),
+          R.when(
+            this.query.isPreviousYearChangeActive,
+            this.assocPreviousYearTotalChangeNode
+          ),
+          R.when(
+            this.query.isPreviousYearActive,
+            this.assocPreviousYearAggregateHorizTotal(node, index)
+          )
+        )(horizontalTotalNode);
+      }
+    );
+
+    /**
+     *
+     * @param   {IProfitLossSheetAccountNode} node
+     * @returns {IProfitLossSheetAccountNode}
+     */
+    private assocPreviousYearAggregateHorizNode = (
+      node: IProfitLossSheetAccountNode
+    ): IProfitLossSheetAccountNode => {
+      const horizontalTotals = R.addIndex(R.map)(
+        this.previousYearAggregateHorizNodeCompose(node),
+        node.horizontalTotals
+      );
+      return R.assoc('horizontalTotals', horizontalTotals, node);
+    };
+
+    // ----------------------------------
+    // # Horizontal Nodes - Equation
+    // ----------------------------------
+    /**
+     *
+     * @param {IProfitLossSheetNode[]} accNodes -
+     * @param {string} equation
+     * @param {number} index
+     * @param {} totalNode -
+     */
+    private assocPreviousYearEquationHorizTotal = R.curry(
+      (
+        accNodes: IProfitLossSheetNode[],
+        equation: string,
+        index: number,
+        totalNode
+      ) => {
+        const scopes = this.getNodesTableForEvaluating(
+          `horizontalTotals[${index}].previousYear.amount`,
+          accNodes
+        );
+        const total = this.evaluateEquation(equation, scopes);
+
+        return R.assoc(
+          'previousYear',
+          this.getTotalAmountMeta(total),
+          totalNode
+        );
+      }
+    );
+
+    /**
+     *
+     * @param {IProfitLossSheetNode[]} accNodes -
+     * @param {string} equation
+     * @param {} horizontalTotalNode
+     * @param {number} index
+     */
+    private previousYearEquationHorizNodeCompose = R.curry(
+      (
+        accNodes: IProfitLossSheetNode[],
+        equation: string,
+        horizontalTotalNode,
+        index: number
+      ) => {
+        const assocHorizTotal = this.assocPreviousYearEquationHorizTotal(
+          accNodes,
+          equation,
+          index
+        );
+        return R.compose(
+          R.when(
+            this.query.isPreviousYearPercentageActive,
+            this.assocPreviousYearTotalPercentageNode
+          ),
+          R.when(
+            this.query.isPreviousYearChangeActive,
+            this.assocPreviousYearTotalChangeNode
+          ),
+          R.when(this.query.isPreviousYearActive, assocHorizTotal)
+        )(horizontalTotalNode);
+      }
+    );
+
+    /**
+     *
+     * @param {IProfitLossSheetNode[]} accNodes
+     * @param {string} equation
+     * @param {IProfitLossSheetEquationNode} node
+     */
+    private assocPreviousYearEquationHorizNode = R.curry(
+      (
+        accNodes: IProfitLossSheetNode[],
+        equation: string,
+        node: IProfitLossSheetEquationNode
+      ) => {
+        const horizontalTotals = R.addIndex(R.map)(
+          this.previousYearEquationHorizNodeCompose(accNodes, equation),
+          node.horizontalTotals
+        );
+        return R.assoc('horizontalTotals', horizontalTotals, node);
+      }
+    );
+  };
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetQuery.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetQuery.ts
new file mode 100644
index 000000000..e21e514bd
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetQuery.ts
@@ -0,0 +1,209 @@
+import { merge } from 'lodash';
+import * as R from 'ramda';
+import { IProfitLossSheetQuery, IFinancialDatePeriodsUnit } from '@/interfaces';
+import { DISPLAY_COLUMNS_BY } from './constants';
+import { FinancialDateRanges } from '../FinancialDateRanges';
+
+export class ProfitLossSheetQuery extends R.compose(FinancialDateRanges)(
+  class {}
+) {
+  /**
+   * P&L query.
+   * @param {IProfitLossSheetQuery}
+   */
+  public readonly query: IProfitLossSheetQuery;
+
+  /**
+   * Previous year to date.
+   * @param {Date}
+   */
+  public readonly PYToDate: Date;
+  /**
+   * Previous year from date.
+   * @param {Date}
+   */
+  public readonly PYFromDate: Date;
+  /**
+   * Previous period to date.
+   * @param {Date}
+   */
+  public readonly PPToDate: Date;
+  /**
+   * Previous period from date.
+   * @param {Date}
+   */
+  public readonly PPFromDate: Date;
+
+  /**
+   * Constructor method.
+   * @param {IProfitLossSheetQuery} query
+   */
+  constructor(query: IProfitLossSheetQuery) {
+    super();
+    this.query = query;
+
+    // Pervious Year (PY) Dates.
+    this.PYToDate = this.getPreviousYearDate(this.query.toDate);
+    this.PYFromDate = this.getPreviousYearDate(this.query.fromDate);
+
+    // Previous Period (PP) Dates for total column..
+    if (this.isTotalColumnType()) {
+      const { fromDate, toDate } = this.getPPTotalDateRange(
+        this.query.fromDate,
+        this.query.toDate
+      );
+      this.PPToDate = toDate;
+      this.PPFromDate = fromDate;
+
+      // Previous period (PP) dates for date periods columns type.
+    } else if (this.isDatePeriodsColumnsType()) {
+      const { fromDate, toDate } = this.getPPDatePeriodDateRange(
+        this.query.fromDate,
+        this.query.toDate,
+        this.query.displayColumnsBy as IFinancialDatePeriodsUnit
+      );
+      this.PPToDate = toDate;
+      this.PPFromDate = fromDate;
+    }
+    return merge(this, query);
+  }
+
+  /**
+   * Detarmines the given display columns type.
+   * @param   {string} displayColumnsBy
+   * @returns {boolean}
+   */
+  public isDisplayColumnsBy = (displayColumnsBy: string): boolean => {
+    return this.query.displayColumnsBy === displayColumnsBy;
+  };
+
+  /**
+   * Detarmines the given display columns by type.
+   * @param   {string} displayColumnsBy
+   * @returns {boolean}
+   */
+  public isDisplayColumnsType = (displayColumnsType: string): boolean => {
+    return this.query.displayColumnsType === displayColumnsType;
+  };
+
+  /**
+   * Detarmines whether the columns type is date periods.
+   * @returns {boolean}
+   */
+  public isDatePeriodsColumnsType = (): boolean => {
+    return this.isDisplayColumnsType(DISPLAY_COLUMNS_BY.DATE_PERIODS);
+  };
+
+  /**
+   * Detarmines whether the columns type is total.
+   * @returns {boolean}
+   */
+  public isTotalColumnType = (): boolean => {
+    return this.isDisplayColumnsType(DISPLAY_COLUMNS_BY.TOTAL);
+  };
+
+  // --------------------------------------
+  // # Previous Year (PY)
+  // --------------------------------------
+  /**
+   * Detarmines the report query has previous year enabled.
+   * @returns {boolean}
+   */
+  public isPreviousYearActive = (): boolean => {
+    return this.query.previousYear;
+  };
+
+  /**
+   * Detarmines the report query has previous year percentage change active.
+   * @returns {boolean}
+   */
+  public isPreviousYearPercentageActive = (): boolean => {
+    return this.query.previousYearPercentageChange;
+  };
+
+  /**
+   * Detarmines the report query has previous year change active.
+   * @returns {boolean}
+   */
+  public isPreviousYearChangeActive = (): boolean => {
+    return this.query.previousYearAmountChange;
+  };
+
+  /**
+   * Retrieves PY date based on the current query.
+   * @returns {Date}
+   */
+  public getTotalPreviousYear = (): Date => {
+    return this.PYFromDate;
+  };
+
+  // --------------------------------------
+  // # Previous Period (PP)
+  // --------------------------------------
+  /**
+   * Detarmines the report query has previous period enabled.
+   * @returns {boolean}
+   */
+  public isPreviousPeriodActive = (): boolean => {
+    return this.query.previousPeriod;
+  };
+
+  /**
+   * Detarmines the report query has previous period percentage change active.
+   * @returns {boolean}
+   */
+  public isPreviousPeriodPercentageActive = (): boolean => {
+    return this.query.previousPeriodPercentageChange;
+  };
+
+  /**
+   * Detarmines the report query has previous period change active.
+   * @returns {boolean}
+   */
+  public isPreviousPeriodChangeActive = (): boolean => {
+    return this.query.previousPeriodAmountChange;
+  };
+
+  /**
+   * Retrieves previous period date based on the current query.
+   * @returns {Date}
+   */
+  public getTotalPreviousPeriod = (): Date => {
+    return this.PPFromDate;
+  };
+
+  // --------------------------------------
+  // # Percentage vertical/horizontal.
+  // --------------------------------------
+  /**
+   * Detarmines whether percentage of expenses is active.
+   * @returns {boolean}
+   */
+  public isExpensesPercentage = (): boolean => {
+    return this.query.percentageExpense;
+  };
+
+  /**
+   * Detarmines whether percentage of income is active.
+   * @returns {boolean}
+   */
+  public isIncomePercentage = (): boolean => {
+    return this.query.percentageIncome;
+  };
+
+  /**
+   * Detarmines whether percentage of column is active.
+   * @returns {boolean}
+   */
+  public isColumnPercentage = (): boolean => {
+    return this.query.percentageColumn;
+  };
+
+  /**
+   * Detarmines whether percentage of row is active.
+   * @returns {boolean}
+   */
+  public isRowPercentage = (): boolean => {
+    return this.query.percentageRow;
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetRepository.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetRepository.ts
new file mode 100644
index 000000000..def66c041
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetRepository.ts
@@ -0,0 +1,343 @@
+import { defaultTo } from 'lodash';
+import * as R from 'ramda';
+import { Knex } from 'knex';
+import { isEmpty } from 'lodash';
+
+import { transformToMapBy } from 'utils';
+import {
+  IProfitLossSheetQuery,
+  IAccount,
+  IAccountTransactionsGroupBy,
+} from '@/interfaces';
+import Ledger from '@/services/Accounting/Ledger';
+import { ProfitLossSheetQuery } from './ProfitLossSheetQuery';
+import { FinancialDatePeriods } from '../FinancialDatePeriods';
+
+export class ProfitLossSheetRepository extends R.compose(FinancialDatePeriods)(
+  class {}
+) {
+  /**
+   *
+   */
+  public models: any;
+
+  /**
+   *
+   */
+  public accountsByType: any;
+
+  /**
+   * @param {}
+   */
+  public accounts: IAccount[];
+
+  /**
+   * Transactions group type.
+   * @param {IAccountTransactionsGroupBy}
+   */
+  public transactionsGroupType: IAccountTransactionsGroupBy =
+    IAccountTransactionsGroupBy.Month;
+
+  /**
+   * @param {IProfitLossSheetQuery}
+   */
+  public query: ProfitLossSheetQuery;
+
+  /**
+   * Previous year to date.
+   * @param {Date}
+   */
+  public PYToDate: Date;
+
+  /**
+   * Previous year from date.
+   * @param {Date}
+   */
+  public PYFromDate: Date;
+
+  /**
+   * Previous year to date.
+   * @param {Date}
+   */
+  public PPToDate: Date;
+
+  /**
+   * Previous year from date.
+   * @param {Date}
+   */
+  public PPFromDate: Date;
+
+  // ------------------------
+  // # Total
+  // ------------------------
+  /**
+   * Accounts total.
+   * @param {Ledger}
+   */
+  public totalAccountsLedger: Ledger;
+
+  // ------------------------
+  // # Date Periods.
+  // ------------------------
+  /**
+   * Accounts date periods.
+   * @param {Ledger}
+   */
+  public periodsAccountsLedger: Ledger;
+
+  // ------------------------
+  // # Previous Year (PY)
+  // ------------------------
+  /**
+   * @param {Ledger}
+   */
+  public PYTotalAccountsLedger: Ledger;
+
+  /**
+   *
+   * @param {Ledger}
+   */
+  public PYPeriodsAccountsLedger: Ledger;
+
+  // ------------------------
+  // # Previous Period (PP).
+  // ------------------------
+  /**
+   * PP Accounts Periods.
+   * @param {Ledger}
+   */
+  public PPPeriodsAccountsLedger: Ledger;
+
+  /**
+   * PP Accounts Total.
+   * @param {Ledger}
+   */
+  public PPTotalAccountsLedger: Ledger;
+
+  /**
+   * Constructor method.
+   * @param {number} tenantId
+   * @param {IBalanceSheetQuery} query
+   */
+  constructor(models: any, query: IProfitLossSheetQuery) {
+    super();
+
+    this.models = models;
+    this.query = new ProfitLossSheetQuery(query);
+
+    this.transactionsGroupType = this.getGroupByFromDisplayColumnsBy(
+      this.query.displayColumnsBy
+    );
+  }
+
+  /**
+   * Async report repository.
+   */
+  public asyncInitialize = async () => {
+    await this.initAccounts();
+    await this.initAccountsTotalLedger();
+
+    // Date Periods.
+    if (this.query.isDatePeriodsColumnsType()) {
+      await this.initTotalDatePeriods();
+    }
+    // Previous Period (PP)
+    if (this.query.isPreviousPeriodActive()) {
+      await this.initTotalPreviousPeriod();
+    }
+    if (
+      this.query.isPreviousPeriodActive() &&
+      this.query.isDatePeriodsColumnsType()
+    ) {
+      await this.initPeriodsPreviousPeriod();
+    }
+    // Previous Year (PY).
+    if (this.query.isPreviousYearActive()) {
+      await this.initTotalPreviousYear();
+    }
+    if (
+      this.query.isPreviousYearActive() &&
+      this.query.isDatePeriodsColumnsType()
+    ) {
+      await this.initPeriodsPreviousYear();
+    }
+  };
+
+  // ----------------------------
+  // # Accounts
+  // ----------------------------
+  /**
+   * Initialize accounts of the report.
+   */
+  private initAccounts = async () => {
+    const accounts = await this.getAccounts();
+
+    // Inject to the repository.
+    this.accounts = accounts;
+    this.accountsByType = transformToMapBy(accounts, 'accountType');
+  };
+
+  // ----------------------------
+  // # Closing Total.
+  // ----------------------------
+  /**
+   * Initialize accounts closing total based on the given query.
+   */
+  private initAccountsTotalLedger = async (): Promise<void> => {
+    const totalByAccount = await this.accountsTotal(
+      this.query.fromDate,
+      this.query.toDate
+    );
+    // Inject to the repository.
+    this.totalAccountsLedger = Ledger.fromTransactions(totalByAccount);
+  };
+
+  // ----------------------------
+  // # Date periods.
+  // ----------------------------
+  /**
+   * Initialize date periods total of accounts based on the given query.
+   */
+  private initTotalDatePeriods = async (): Promise<void> => {
+    // Retrieves grouped transactions by given date group.
+    const periodsByAccount = await this.accountsDatePeriods(
+      this.query.fromDate,
+      this.query.toDate,
+      this.transactionsGroupType
+    );
+
+    // Inject to the repository.
+    this.periodsAccountsLedger = Ledger.fromTransactions(periodsByAccount);
+  };
+
+  // ----------------------------
+  // # Previous Period (PP).
+  // ----------------------------
+  /**
+   * Initialize total of previous period (PP).
+   */
+  private initTotalPreviousPeriod = async (): Promise<void> => {
+    const PPTotalsByAccounts = await this.accountsTotal(
+      this.query.PPFromDate,
+      this.query.PPToDate
+    );
+    // Inject to the repository.
+    this.PPTotalAccountsLedger = Ledger.fromTransactions(PPTotalsByAccounts);
+  };
+
+  /**
+   * Initialize date periods of previous period (PP).
+   */
+  private initPeriodsPreviousPeriod = async (): Promise<void> => {
+    // Retrieves grouped transactions by given date group.
+    const periodsByAccount = await this.accountsDatePeriods(
+      this.query.PPFromDate,
+      this.query.PPToDate,
+      this.transactionsGroupType
+    );
+    // Inject to the repository.
+    this.PPPeriodsAccountsLedger = Ledger.fromTransactions(periodsByAccount);
+  };
+
+  // ----------------------------
+  // # Previous Year (PY).
+  // ----------------------------
+  /**
+   * Initialize total of previous year (PY).
+   */
+  private initTotalPreviousYear = async (): Promise<void> => {
+    const PYTotalsByAccounts = await this.accountsTotal(
+      this.query.PYFromDate,
+      this.query.PYToDate
+    );
+    // Inject to the repository.
+    this.PYTotalAccountsLedger = Ledger.fromTransactions(PYTotalsByAccounts);
+  };
+
+  /**
+   * Initialize periods of previous year (PY).
+   */
+  private initPeriodsPreviousYear = async () => {
+    // Retrieves grouped transactions by given date group.
+    const periodsByAccount = await this.accountsDatePeriods(
+      this.query.PYFromDate,
+      this.query.PYToDate,
+      this.transactionsGroupType
+    );
+    // Inject to the repository.
+    this.PYPeriodsAccountsLedger = Ledger.fromTransactions(periodsByAccount);
+  };
+
+  // ----------------------------
+  // # Utils
+  // ----------------------------
+  /**
+   * Retrieve the opening balance transactions of the report.
+   */
+  public accountsTotal = async (fromDate: Date, toDate: Date) => {
+    const { AccountTransaction } = this.models;
+
+    return AccountTransaction.query().onBuild((query) => {
+      query.sum('credit as credit');
+      query.sum('debit as debit');
+      query.groupBy('accountId');
+      query.select(['accountId']);
+
+      query.modify('filterDateRange', fromDate, toDate);
+      query.withGraphFetched('account');
+
+      this.commonFilterBranchesQuery(query);
+    });
+  };
+
+  /**
+   * Closing accounts date periods.
+   * @param openingDate
+   * @param datePeriodsType
+   * @returns
+   */
+  public accountsDatePeriods = async (
+    fromDate: Date,
+    toDate: Date,
+    datePeriodsType
+  ) => {
+    const { AccountTransaction } = this.models;
+
+    return AccountTransaction.query().onBuild((query) => {
+      query.sum('credit as credit');
+      query.sum('debit as debit');
+      query.groupBy('accountId');
+      query.select(['accountId']);
+
+      query.modify('groupByDateFormat', datePeriodsType);
+      query.modify('filterDateRange', fromDate, toDate);
+      query.withGraphFetched('account');
+
+      this.commonFilterBranchesQuery(query);
+    });
+  };
+
+  /**
+   * Common branches filter query.
+   * @param {Knex.QueryBuilder} query
+   */
+  private commonFilterBranchesQuery = (query: Knex.QueryBuilder) => {
+    if (!isEmpty(this.query.branchesIds)) {
+      query.modify('filterByBranches', this.query.branchesIds);
+    }
+  };
+
+  /**
+   * Retrieve accounts of the report.
+   * @return {Promise<IAccount[]>}
+   */
+  private getAccounts = () => {
+    const { Account } = this.models;
+
+    return Account.query();
+  };
+
+  public getAccountsByType = (type: string) => {
+    return defaultTo(this.accountsByType.get(type), []);
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetService.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetService.ts
new file mode 100644
index 000000000..14d17fc5a
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetService.ts
@@ -0,0 +1,104 @@
+import { Service, Inject } from 'typedi';
+import {
+  IProfitLossSheetQuery,
+  IProfitLossSheetMeta,
+  IProfitLossSheetNode,
+} from '@/interfaces';
+import ProfitLossSheet from './ProfitLossSheet';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import InventoryService from '@/services/Inventory/Inventory';
+import { parseBoolean } from 'utils';
+import { Tenant } from '@/system/models';
+import { mergeQueryWithDefaults } from './utils';
+import { ProfitLossSheetRepository } from './ProfitLossSheetRepository';
+
+// Profit/Loss sheet service.
+@Service()
+export default class ProfitLossSheetService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  inventoryService: InventoryService;
+
+  /**
+   * Retrieve the trial balance sheet meta.
+   * @param {number} tenantId - Tenant id.
+   * @returns {ITrialBalanceSheetMeta}
+   */
+  reportMetadata(tenantId: number): IProfitLossSheetMeta {
+    const settings = this.tenancy.settings(tenantId);
+
+    const isCostComputeRunning =
+      this.inventoryService.isItemsCostComputeRunning(tenantId);
+    const organizationName = settings.get({
+      group: 'organization',
+      key: 'name',
+    });
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+
+    return {
+      isCostComputeRunning: parseBoolean(isCostComputeRunning, false),
+      organizationName,
+      baseCurrency,
+    };
+  }
+
+  /**
+   * Retrieve profit/loss sheet statement.
+   * @param {number} tenantId
+   * @param {IProfitLossSheetQuery} query
+   * @return { }
+   */
+  profitLossSheet = async (
+    tenantId: number,
+    query: IProfitLossSheetQuery
+  ): Promise<{
+    data: IProfitLossSheetNode[];
+    query: IProfitLossSheetQuery;
+    meta: IProfitLossSheetMeta;
+  }> => {
+    const models = this.tenancy.models(tenantId);
+    const i18n = this.tenancy.i18n(tenantId);
+
+    // Merges the given query with default filter query.
+    const filter = mergeQueryWithDefaults(query);
+
+    // Get the given accounts or throw not found service error.
+    // if (filter.accountsIds.length > 0) {
+    //   await this.accountsService.getAccountsOrThrowError(
+    //     tenantId,
+    //     filter.accountsIds
+    //   );
+    // }
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const profitLossRepo = new ProfitLossSheetRepository(models, filter);
+
+    await profitLossRepo.asyncInitialize();
+
+    // Profit/Loss report instance.
+    const profitLossInstance = new ProfitLossSheet(
+      profitLossRepo,
+      filter,
+      tenant.metadata.baseCurrency,
+      i18n
+    );
+    // Profit/loss report data and collumns.
+    const profitLossData = profitLossInstance.reportData();
+
+    return {
+      data: profitLossData,
+      query: filter,
+      meta: this.reportMetadata(tenantId),
+    };
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetTable.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetTable.ts
new file mode 100644
index 000000000..84694b2dc
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetTable.ts
@@ -0,0 +1,233 @@
+import * as R from 'ramda';
+import {
+  IProfitLossSheetQuery,
+  ITableColumn,
+  IProfitLossSheetAccountsNode,
+  ITableColumnAccessor,
+  ITableRow,
+  ProfitLossNodeType,
+  ProfitLossSheetRowType,
+  IProfitLossSheetNode,
+  IProfitLossSheetEquationNode,
+  IProfitLossSheetAccountNode,
+} from '@/interfaces';
+import { tableRowMapper } from 'utils';
+import { FinancialTable } from '../FinancialTable';
+import { ProfitLossSheetBase } from './ProfitLossSheetBase';
+import { ProfitLossSheetTablePercentage } from './ProfitLossSheetTablePercentage';
+import { ProfitLossSheetQuery } from './ProfitLossSheetQuery';
+import { ProfitLossTablePreviousPeriod } from './ProfitLossTablePreviousPeriod';
+import { ProfitLossTablePreviousYear } from './ProfitLossTablePreviousYear';
+import { FinancialSheetStructure } from '../FinancialSheetStructure';
+import { ProfitLossSheetTableDatePeriods } from './ProfitLossSheetTableDatePeriods';
+
+export class ProfitLossSheetTable extends R.compose(
+  ProfitLossTablePreviousPeriod,
+  ProfitLossTablePreviousYear,
+  ProfitLossSheetTablePercentage,
+  ProfitLossSheetTableDatePeriods,
+  ProfitLossSheetBase,
+  FinancialSheetStructure,
+  FinancialTable
+)(class {}) {
+  readonly query: ProfitLossSheetQuery;
+
+  /**
+   * Constructor method.
+   * @param {} date
+   * @param {IProfitLossSheetQuery} query
+   */
+  constructor(data: any, query: IProfitLossSheetQuery, i18n: any) {
+    super();
+
+    this.query = new ProfitLossSheetQuery(query);
+    this.reportData = data;
+    this.i18n = i18n;
+  }
+
+  // ----------------------------------
+  // # Rows
+  // ----------------------------------
+  /**
+   * Retrieve the total column accessor.
+   * @return {ITableColumnAccessor[]}
+   */
+  private totalColumnAccessor = (): ITableColumnAccessor[] => {
+    return R.pipe(
+      R.when(
+        this.query.isPreviousPeriodActive,
+        R.concat(this.previousPeriodColumnAccessor())
+      ),
+      R.when(
+        this.query.isPreviousYearActive,
+        R.concat(this.previousYearColumnAccessor())
+      ),
+      R.concat(this.percentageColumnsAccessor()),
+      R.concat([{ key: 'total', accessor: 'total.formattedAmount' }])
+    )([]);
+  };
+
+  /**
+   * Common columns accessors.
+   * @returns {ITableColumnAccessor}
+   */
+  private commonColumnsAccessors = (): ITableColumnAccessor[] => {
+    return R.compose(
+      R.concat([{ key: 'name', accessor: 'name' }]),
+      R.ifElse(
+        this.query.isDatePeriodsColumnsType,
+        R.concat(this.datePeriodsColumnsAccessors()),
+        R.concat(this.totalColumnAccessor())
+      )
+    )([]);
+  };
+
+  /**
+   *
+   * @param   {IProfitLossSheetAccountNode} node
+   * @returns {ITableRow}
+   */
+  private accountNodeToTableRow = (
+    node: IProfitLossSheetAccountNode
+  ): ITableRow => {
+    const columns = this.commonColumnsAccessors();
+    const meta = {
+      rowTypes: [ProfitLossSheetRowType.ACCOUNT],
+      id: node.id,
+    };
+    return tableRowMapper(node, columns, meta);
+  };
+
+  /**
+   *
+   * @param   {IProfitLossSheetAccountsNode} node
+   * @returns {ITableRow}
+   */
+  private accountsNodeToTableRow = (
+    node: IProfitLossSheetAccountsNode
+  ): ITableRow => {
+    const columns = this.commonColumnsAccessors();
+    const meta = {
+      rowTypes: [ProfitLossSheetRowType.ACCOUNTS],
+      id: node.id,
+    };
+    return tableRowMapper(node, columns, meta);
+  };
+
+  /**
+   *
+   * @param   {IProfitLossSheetEquationNode} node
+   * @returns {ITableRow}
+   */
+  private equationNodeToTableRow = (
+    node: IProfitLossSheetEquationNode
+  ): ITableRow => {
+    const columns = this.commonColumnsAccessors();
+
+    const meta = {
+      rowTypes: [ProfitLossSheetRowType.TOTAL],
+      id: node.id,
+    };
+    return tableRowMapper(node, columns, meta);
+  };
+
+  /**
+   *
+   * @param   {IProfitLossSheetNode} node
+   * @returns {ITableRow}
+   */
+  private nodeToTableRowCompose = (node: IProfitLossSheetNode): ITableRow => {
+    return R.cond([
+      [
+        this.isNodeType(ProfitLossNodeType.ACCOUNTS),
+        this.accountsNodeToTableRow,
+      ],
+      [
+        this.isNodeType(ProfitLossNodeType.EQUATION),
+        this.equationNodeToTableRow,
+      ],
+      [this.isNodeType(ProfitLossNodeType.ACCOUNT), this.accountNodeToTableRow],
+    ])(node);
+  };
+
+  /**
+   *
+   * @param   {IProfitLossSheetNode[]} nodes
+   * @returns {ITableRow}
+   */
+  private nodesToTableRowsCompose = (
+    nodes: IProfitLossSheetNode[]
+  ): ITableRow[] => {
+    return this.mapNodesDeep(nodes, this.nodeToTableRowCompose);
+  };
+
+  /**
+   * Retrieves the table rows.
+   * @returns {ITableRow[]}
+   */
+  public tableRows = (): ITableRow[] => {
+    return R.compose(
+      this.addTotalRows,
+      this.nodesToTableRowsCompose
+    )(this.reportData);
+  };
+
+  // ----------------------------------
+  // # Columns.
+  // ----------------------------------
+  /**
+   * Retrieve total column children columns.
+   * @returns {ITableColumn[]}
+   */
+  private tableColumnChildren = (): ITableColumn[] => {
+    return R.compose(
+      R.unless(
+        R.isEmpty,
+        R.concat([
+          { key: 'total', label: this.i18n.__('profit_loss_sheet.total') },
+        ])
+      ),
+      R.concat(this.percentageColumns()),
+      R.when(
+        this.query.isPreviousYearActive,
+        R.concat(this.getPreviousYearColumns())
+      ),
+      R.when(
+        this.query.isPreviousPeriodActive,
+        R.concat(this.getPreviousPeriodColumns())
+      )
+    )([]);
+  };
+
+  /**
+   * Retrieves the total column.
+   * @returns {ITableColumn[]}
+   */
+  private totalColumn = (): ITableColumn[] => {
+    return [
+      {
+        key: 'total',
+        label: this.i18n.__('profit_loss_sheet.total'),
+        children: this.tableColumnChildren(),
+      },
+    ];
+  };
+
+  /**
+   * Retrieves the table columns.
+   * @returns {ITableColumn[]}
+   */
+  public tableColumns = (): ITableColumn[] => {
+    return R.compose(
+      this.tableColumnsCellIndexing,
+      R.concat([
+        { key: 'name', label: this.i18n.__('profit_loss_sheet.account_name') },
+      ]),
+      R.ifElse(
+        this.query.isDatePeriodsColumnsType,
+        R.concat(this.datePeriodsColumns()),
+        R.concat(this.totalColumn())
+      )
+    )([]);
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetTableDatePeriods.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetTableDatePeriods.ts
new file mode 100644
index 000000000..ea7781f2e
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetTableDatePeriods.ts
@@ -0,0 +1,150 @@
+import * as R from 'ramda';
+import moment from 'moment';
+import { ITableColumn, IDateRange, ITableColumnAccessor } from '@/interfaces';
+import { FinancialDatePeriods } from '../FinancialDatePeriods';
+import { ProfitLossSheetTablePercentage } from './ProfitLossSheetTablePercentage';
+import { ProfitLossTablePreviousPeriod } from './ProfitLossTablePreviousPeriod';
+
+export const ProfitLossSheetTableDatePeriods = (Base) =>
+  class extends R.compose(
+    ProfitLossSheetTablePercentage,
+    ProfitLossTablePreviousPeriod,
+    FinancialDatePeriods
+  )(Base) {
+    /**
+     * Retrieves the date periods based on the report query.
+     * @returns {IDateRange[]}
+     */
+    get datePeriods() {
+      return this.getDateRanges(
+        this.query.fromDate,
+        this.query.toDate,
+        this.query.displayColumnsBy
+      );
+    }
+
+    // --------------------------------
+    // # Accessors
+    // --------------------------------
+    /**
+     * Date period columns accessor.
+     * @param {IDateRange} dateRange -
+     * @param {number} index -
+     */
+    private datePeriodColumnsAccessor = R.curry(
+      (dateRange: IDateRange, index: number) => {
+        return R.pipe(
+          R.when(
+            this.query.isPreviousPeriodActive,
+            R.concat(this.previousPeriodHorizontalColumnAccessors(index))
+          ),
+          R.when(
+            this.query.isPreviousYearActive,
+            R.concat(this.previousYearHorizontalColumnAccessors(index))
+          ),
+          R.concat(this.percetangeHorizontalColumnsAccessor(index)),
+          R.concat([
+            {
+              key: `date-range-${index}`,
+              accessor: `horizontalTotals[${index}].total.formattedAmount`,
+            },
+          ])
+        )([]);
+      }
+    );
+
+    /**
+     * Retrieve the date periods columns accessors.
+     * @returns {ITableColumnAccessor[]}
+     */
+    protected datePeriodsColumnsAccessors = (): ITableColumnAccessor[] => {
+      return R.compose(
+        R.flatten,
+        R.addIndex(R.map)(this.datePeriodColumnsAccessor)
+      )(this.datePeriods);
+    };
+
+    // --------------------------------
+    // # Columns
+    // --------------------------------
+    /**
+     * Retrieve the formatted column label from the given date range.
+     * @param {ICashFlowDateRange} dateRange -
+     * @return {string}
+     */
+    private formatColumnLabel = (dateRange) => {
+      const monthFormat = (range) => moment(range.toDate).format('YYYY-MM');
+      const yearFormat = (range) => moment(range.toDate).format('YYYY');
+      const dayFormat = (range) => moment(range.toDate).format('YYYY-MM-DD');
+
+      const conditions = [
+        ['month', monthFormat],
+        ['year', yearFormat],
+        ['day', dayFormat],
+        ['quarter', monthFormat],
+        ['week', dayFormat],
+      ];
+      const conditionsPairs = R.map(
+        ([type, formatFn]) => [
+          R.always(this.query.isDisplayColumnsBy(type)),
+          formatFn,
+        ],
+        conditions
+      );
+      return R.compose(R.cond(conditionsPairs))(dateRange);
+    };
+
+    /**
+     *
+     * @param   {number} index
+     * @param   {IDateRange} dateRange
+     * @returns {}
+     */
+    private datePeriodChildrenColumns = (
+      index: number,
+      dateRange: IDateRange
+    ) => {
+      return R.compose(
+        R.unless(
+          R.isEmpty,
+          R.concat([
+            { key: `total`, label: this.i18n.__('profit_loss_sheet.total') },
+          ])
+        ),
+        R.concat(this.percentageColumns()),
+        R.when(
+          this.query.isPreviousYearActive,
+          R.concat(this.getPreviousYearDatePeriodColumnPlugin(dateRange))
+        ),
+        R.when(
+          this.query.isPreviousPeriodActive,
+          R.concat(this.getPreviousPeriodDatePeriodsPlugin(dateRange))
+        )
+      )([]);
+    };
+
+    /**
+     *
+     * @param   {IDateRange} dateRange
+     * @param   {number} index
+     * @returns {ITableColumn}
+     */
+    private datePeriodColumn = (
+      dateRange: IDateRange,
+      index: number
+    ): ITableColumn => {
+      return {
+        key: `date-range-${index}`,
+        label: this.formatColumnLabel(dateRange),
+        children: this.datePeriodChildrenColumns(index, dateRange),
+      };
+    };
+
+    /**
+     * Date periods columns.
+     * @returns {ITableColumn[]}
+     */
+    protected datePeriodsColumns = (): ITableColumn[] => {
+      return this.datePeriods.map(this.datePeriodColumn);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetTablePercentage.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetTablePercentage.ts
new file mode 100644
index 000000000..f2807ba36
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossSheetTablePercentage.ts
@@ -0,0 +1,131 @@
+import * as R from 'ramda';
+import { ITableColumn, ITableColumnAccessor } from '@/interfaces';
+import { ProfitLossSheetQuery } from './ProfitLossSheetQuery';
+
+export const ProfitLossSheetTablePercentage = (Base) =>
+  class extends Base {
+    /**
+     * @param {ProfitLossSheetQuery}
+     */
+    readonly query: ProfitLossSheetQuery;
+
+    // ----------------------------------
+    // # Columns.
+    // ----------------------------------
+    /**
+     * Retrieve percentage of column/row columns.
+     * @returns {ITableColumn[]}
+     */
+    protected percentageColumns = (): ITableColumn[] => {
+      return R.pipe(
+        R.when(
+          this.query.isIncomePercentage,
+          R.append({
+            key: 'percentage_income',
+            label: this.i18n.__('profit_loss_sheet.percentage_of_income'),
+          })
+        ),
+        R.when(
+          this.query.isExpensesPercentage,
+          R.append({
+            key: 'percentage_expenses',
+            label: this.i18n.__('profit_loss_sheet.percentage_of_expenses'),
+          })
+        ),
+        R.when(
+          this.query.isColumnPercentage,
+          R.append({
+            key: 'percentage_column',
+            label: this.i18n.__('profit_loss_sheet.percentage_of_column'),
+          })
+        ),
+        R.when(
+          this.query.isRowPercentage,
+          R.append({
+            key: 'percentage_row',
+            label: this.i18n.__('profit_loss_sheet.percentage_of_row'),
+          })
+        )
+      )([]);
+    };
+
+    // ----------------------------------
+    // # Accessors.
+    // ----------------------------------
+    /**
+     * Retrieves percentage of column/row accessors.
+     * @returns {ITableColumn[]}
+     */
+    protected percentageColumnsAccessor = (): ITableColumnAccessor[] => {
+      return R.pipe(
+        R.when(
+          this.query.isIncomePercentage,
+          R.append({
+            key: 'percentage_income',
+            accessor: 'percentageIncome.formattedAmount',
+          })
+        ),
+        R.when(
+          this.query.isExpensesPercentage,
+          R.append({
+            key: 'percentage_expense',
+            accessor: 'percentageExpense.formattedAmount',
+          })
+        ),
+        R.when(
+          this.query.isColumnPercentage,
+          R.append({
+            key: 'percentage_column',
+            accessor: 'percentageColumn.formattedAmount',
+          })
+        ),
+        R.when(
+          this.query.isRowPercentage,
+          R.append({
+            key: 'percentage_row',
+            accessor: 'percentageRow.formattedAmount',
+          })
+        )
+      )([]);
+    };
+
+    /**
+     * Retrieves percentage horizontal columns accessors.
+     * @param   {number} index
+     * @returns {ITableColumn[]}
+     */
+    protected percetangeHorizontalColumnsAccessor = (
+      index: number
+    ): ITableColumnAccessor[] => {
+      return R.pipe(
+        R.when(
+          this.query.isIncomePercentage,
+          R.append({
+            key: `percentage_income-${index}`,
+            accessor: `horizontalTotals[${index}].percentageIncome.formattedAmount`,
+          })
+        ),
+        R.when(
+          this.query.isExpensesPercentage,
+          R.append({
+            key: `percentage_expense-${index}`,
+            accessor: `horizontalTotals[${index}].percentageExpense.formattedAmount`,
+          })
+        ),
+        R.when(
+          this.query.isColumnPercentage,
+          R.append({
+            key: `percentage_of_column-${index}`,
+            accessor: `horizontalTotals[${index}].percentageColumn.formattedAmount`,
+          })
+        ),
+        R.when(
+          this.query.isRowPercentage,
+          R.append({
+            key: `percentage_of_row-${index}`,
+            accessor: `horizontalTotals[${index}].percentageRow.formattedAmount`,
+          })
+        )
+      )([]);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossTablePreviousPeriod.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossTablePreviousPeriod.ts
new file mode 100644
index 000000000..98048b938
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossTablePreviousPeriod.ts
@@ -0,0 +1,93 @@
+import * as R from 'ramda';
+import { IDateRange, ITableColumn, ITableColumnAccessor } from '@/interfaces';
+import { ProfitLossSheetQuery } from './ProfitLossSheetQuery';
+import { FinancialTablePreviousPeriod } from '../FinancialTablePreviousPeriod';
+
+export const ProfitLossTablePreviousPeriod = (Base) =>
+  class extends R.compose(FinancialTablePreviousPeriod)(Base) {
+    query: ProfitLossSheetQuery;
+
+    // ----------------------------
+    // # Columns
+    // ----------------------------
+    /**
+     * Retrieves pervious period comparison columns.
+     * @returns {ITableColumn[]}
+     */
+    protected getPreviousPeriodColumns = (
+      dateRange?: IDateRange
+    ): ITableColumn[] => {
+      return R.pipe(
+        // Previous period columns.
+        R.append(this.getPreviousPeriodTotalColumn(dateRange)),
+        R.when(
+          this.query.isPreviousPeriodChangeActive,
+          R.append(this.getPreviousPeriodChangeColumn())
+        ),
+        R.when(
+          this.query.isPreviousPeriodPercentageActive,
+          R.append(this.getPreviousPeriodPercentageColumn())
+        )
+      )([]);
+    };
+
+    /**
+     * Compose the previous period for date periods columns.
+     * @params  {IDateRange}
+     * @returns {ITableColumn[]}
+     */
+    protected getPreviousPeriodDatePeriodsPlugin = (
+      dateRange: IDateRange
+    ): ITableColumn[] => {
+      const PPDateRange = this.getPPDatePeriodDateRange(
+        dateRange.fromDate,
+        dateRange.toDate,
+        this.query.displayColumnsBy
+      );
+      return this.getPreviousPeriodColumns(PPDateRange);
+    };
+
+    // ----------------------------
+    // # Accessors
+    // ----------------------------
+    /**
+     * Retrieves previous period columns accessors.
+     * @returns {ITableColumn[]}
+     */
+    protected previousPeriodColumnAccessor = (): ITableColumnAccessor[] => {
+      return R.pipe(
+        // Previous period columns.
+        R.append(this.getPreviousPeriodTotalAccessor()),
+        R.when(
+          this.query.isPreviousPeriodChangeActive,
+          R.append(this.getPreviousPeriodChangeAccessor())
+        ),
+        R.when(
+          this.query.isPreviousPeriodPercentageActive,
+          R.append(this.getPreviousPeriodPercentageAccessor())
+        )
+      )([]);
+    };
+
+    /**
+     * Previous period period column accessor.
+     * @param   {number} index
+     * @returns {ITableColumn[]}
+     */
+    protected previousPeriodHorizontalColumnAccessors = (
+      index: number
+    ): ITableColumnAccessor[] => {
+      return R.pipe(
+        // Previous period columns.
+        R.append(this.getPreviousPeriodTotalHorizAccessor(index)),
+        R.when(
+          this.query.isPreviousPeriodChangeActive,
+          R.append(this.getPreviousPeriodChangeHorizAccessor(index))
+        ),
+        R.when(
+          this.query.isPreviousPeriodPercentageActive,
+          R.append(this.getPreviousPeriodPercentageHorizAccessor(index))
+        )
+      )([]);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossTablePreviousYear.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossTablePreviousYear.ts
new file mode 100644
index 000000000..27d3db311
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/ProfitLossTablePreviousYear.ts
@@ -0,0 +1,107 @@
+import * as R from 'ramda';
+import { IDateRange, ITableColumn, ITableColumnAccessor } from '@/interfaces';
+import { ProfitLossSheetQuery } from './ProfitLossSheetQuery';
+import { FinancialTablePreviousYear } from '../FinancialTablePreviousYear';
+import { FinancialDateRanges } from '../FinancialDateRanges';
+
+export const ProfitLossTablePreviousYear = (Base) =>
+  class extends R.compose(
+    FinancialTablePreviousYear,
+    FinancialDateRanges
+  )(Base) {
+    query: ProfitLossSheetQuery;
+
+    // ------------------------------------
+    // # Columns.
+    // ------------------------------------
+    /**
+     * Retrieves pervious year comparison columns.
+     * @returns {ITableColumn[]}
+     */
+    protected getPreviousYearColumns = (
+      dateRange?: IDateRange
+    ): ITableColumn[] => {
+      return R.pipe(
+        // Previous year columns.
+        R.append(this.getPreviousYearTotalColumn(dateRange)),
+        R.when(
+          this.query.isPreviousYearChangeActive,
+          R.append(this.getPreviousYearChangeColumn())
+        ),
+        R.when(
+          this.query.isPreviousYearPercentageActive,
+          R.append(this.getPreviousYearPercentageColumn())
+        )
+      )([]);
+    };
+
+    /**
+     *
+     * @param   {IDateRange} dateRange
+     * @returns {ITableColumn[]}
+     */
+    private previousYearDatePeriodColumnCompose = (
+      dateRange: IDateRange
+    ): ITableColumn[] => {
+      const PYDateRange = this.getPreviousYearDateRange(
+        dateRange.fromDate,
+        dateRange.toDate
+      );
+      return this.getPreviousYearColumns(PYDateRange);
+    };
+
+    /**
+     * Retrieves previous year date periods columns.
+     * @param   {IDateRange} dateRange
+     * @returns {ITableColumn[]}
+     */
+    protected getPreviousYearDatePeriodColumnPlugin = (
+      dateRange: IDateRange
+    ): ITableColumn[] => {
+      return this.previousYearDatePeriodColumnCompose(dateRange);
+    };
+
+    // ---------------------------------------------------
+    // # Accessors.
+    // ---------------------------------------------------
+    /**
+     * Retrieves previous year columns accessors.
+     * @returns {ITableColumnAccessor[]}
+     */
+    protected previousYearColumnAccessor = (): ITableColumnAccessor[] => {
+      return R.pipe(
+        // Previous year columns.
+        R.append(this.getPreviousYearTotalAccessor()),
+        R.when(
+          this.query.isPreviousYearChangeActive,
+          R.append(this.getPreviousYearChangeAccessor())
+        ),
+        R.when(
+          this.query.isPreviousYearPercentageActive,
+          R.append(this.getPreviousYearPercentageAccessor())
+        )
+      )([]);
+    };
+
+    /**
+     * Previous year period column accessor.
+     * @param   {number} index
+     * @returns {ITableColumn[]}
+     */
+    protected previousYearHorizontalColumnAccessors = (
+      index: number
+    ): ITableColumnAccessor[] => {
+      return R.pipe(
+        // Previous year columns.
+        R.append(this.getPreviousYearTotalHorizAccessor(index)),
+        R.when(
+          this.query.isPreviousYearChangeActive,
+          R.append(this.getPreviousYearChangeHorizAccessor(index))
+        ),
+        R.when(
+          this.query.isPreviousYearPercentageActive,
+          R.append(this.getPreviousYearPercentageHorizAccessor(index))
+        )
+      )([]);
+    };
+  };
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/constants.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/constants.ts
new file mode 100644
index 000000000..56f4a14ba
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/constants.ts
@@ -0,0 +1,21 @@
+import { ProfitLossNodeType } from '@/interfaces';
+
+export const MAP_CONFIG = { childrenPath: 'children', pathFormat: 'array' };
+
+export const DISPLAY_COLUMNS_BY = {
+  DATE_PERIODS: 'date_periods',
+  TOTAL: 'total',
+};
+
+export enum IROW_TYPE {
+  AGGREGATE = 'AGGREGATE',
+  ACCOUNTS = 'ACCOUNTS',
+  ACCOUNT = 'ACCOUNT',
+  TOTAL = 'TOTAL',
+}
+
+export const TOTAL_NODE_TYPES = [
+  ProfitLossNodeType.ACCOUNTS,
+  ProfitLossNodeType.AGGREGATE,
+  ProfitLossNodeType.EQUATION
+];
\ No newline at end of file
diff --git a/packages/server/src/services/FinancialStatements/ProfitLossSheet/utils.ts b/packages/server/src/services/FinancialStatements/ProfitLossSheet/utils.ts
new file mode 100644
index 000000000..b9a707f88
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProfitLossSheet/utils.ts
@@ -0,0 +1,54 @@
+import moment from 'moment';
+import { merge } from 'lodash';
+import { IProfitLossSheetQuery } from '@/interfaces';
+
+/**
+ * Default sheet filter query.
+ * @return {IBalanceSheetQuery}
+ */
+export const getDefaultPLQuery = (): IProfitLossSheetQuery => ({
+  fromDate: moment().startOf('year').format('YYYY-MM-DD'),
+  toDate: moment().endOf('year').format('YYYY-MM-DD'),
+
+  numberFormat: {
+    divideOn1000: false,
+    negativeFormat: 'mines',
+    showZero: false,
+    formatMoney: 'total',
+    precision: 2,
+  },
+  basis: 'accural',
+
+  noneZero: false,
+  noneTransactions: false,
+
+  displayColumnsType: 'total',
+  displayColumnsBy: 'month',
+
+  accountsIds: [],
+
+  percentageColumn: false,
+  percentageRow: false,
+
+  percentageIncome: false,
+  percentageExpense: false,
+
+  previousPeriod: false,
+  previousPeriodAmountChange: false,
+  previousPeriodPercentageChange: false,
+
+  previousYear: false,
+  previousYearAmountChange: false,
+  previousYearPercentageChange: false,
+});
+
+/**
+ *
+ * @param query
+ * @returns
+ */
+export const mergeQueryWithDefaults = (
+  query: IProfitLossSheetQuery
+): IProfitLossSheetQuery => {
+  return merge(getDefaultPLQuery(), query);
+};
diff --git a/packages/server/src/services/FinancialStatements/ProjectProfitabilitySummary/ProjectProfitabilitySummary.ts b/packages/server/src/services/FinancialStatements/ProjectProfitabilitySummary/ProjectProfitabilitySummary.ts
new file mode 100644
index 000000000..22960c52e
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProjectProfitabilitySummary/ProjectProfitabilitySummary.ts
@@ -0,0 +1,216 @@
+import { sumBy } from 'lodash';
+import { map } from 'lodash/fp';
+import {
+  IProjectProfitabilitySummaryProjectNode,
+  IProjectProfitabilitySummaryTotal,
+} from '@/interfaces';
+import Project from 'models/Project';
+import { ProjectProfitabilitySummaryRespository } from './ProjectProfitabilitySummaryRepository';
+import FinancialSheet from '../FinancialSheet';
+
+export class ProfitProfitabilitySummary extends FinancialSheet {
+  private readonly repository: ProjectProfitabilitySummaryRespository;
+  private readonly baseCurrency: string;
+
+  /**
+   * Constructor method.
+   * @param {ProjectProfitabilitySummaryRespository} repository
+   * @param {string} baseCurrency
+   */
+  constructor(
+    repository: ProjectProfitabilitySummaryRespository,
+    baseCurrency: string
+  ) {
+    super();
+
+    this.repository = repository;
+    this.baseCurrency = baseCurrency;
+  }
+
+  /**
+   * Retrieves the project income node.
+   * @param {number} projectId
+   * @returns {IProjectProfitabilitySummaryTotal}
+   */
+  private getProjectIncomeNode = (
+    projectId: number
+  ): IProjectProfitabilitySummaryTotal => {
+    const amount = this.repository.incomeLedger
+      .whereProject(projectId)
+      .getClosingBalance();
+
+    const formattedAmount = this.formatNumber(amount);
+
+    return {
+      amount,
+      formattedAmount,
+      currencyCode: this.baseCurrency,
+    };
+  };
+
+  /**
+   * Retrieves the project expense node.
+   * @param   {number} projectId
+   * @returns {IProjectProfitabilitySummaryTotal}
+   */
+  private getProjectExpenseNode = (
+    projectId: number
+  ): IProjectProfitabilitySummaryTotal => {
+    const amount = this.repository.expenseLedger
+      .whereProject(projectId)
+      .getClosingBalance();
+
+    const formattedAmount = this.formatNumber(amount);
+
+    return {
+      amount,
+      formattedAmount,
+      currencyCode: this.baseCurrency,
+    };
+  };
+
+  /**
+   * Retrieves the project profit total node.
+   * @param {number} projectId - Project id.
+   * @returns {number}
+   */
+  private getProjectProfitTotal = (projectId: number): number => {
+    const incomeTotal = this.repository.incomeLedger
+      .whereProject(projectId)
+      .getClosingBalance();
+
+    const expenseTotal = this.repository.expenseLedger
+      .whereProject(projectId)
+      .getClosingBalance();
+
+    return incomeTotal - expenseTotal;
+  };
+
+  /**
+   * Retrieves the project profit node.
+   * @param {number} projectId - Project id.
+   * @returns {IProjectProfitabilitySummaryTotal}
+   */
+  private getProjectProfitNode = (
+    projectId: number
+  ): IProjectProfitabilitySummaryTotal => {
+    const amount = this.getProjectProfitTotal(projectId);
+    const formattedAmount = this.formatNumber(amount);
+
+    return {
+      amount,
+      formattedAmount,
+      currencyCode: this.baseCurrency,
+    };
+  };
+
+  /**
+   * Retrieves the project node.
+   * @param {Project} project
+   * @returns {IProjectProfitabilitySummaryProjectNode}
+   */
+  private getProjectNode = (
+    project: Project
+  ): IProjectProfitabilitySummaryProjectNode => {
+    return {
+      projectId: project.id,
+      projectName: project.name,
+      projectStatus: 1,
+
+      customerName: project.contact.displayName,
+      customerId: project.contact.id,
+
+      profit: this.getProjectProfitNode(project.id),
+      income: this.getProjectIncomeNode(project.id),
+      expenses: this.getProjectExpenseNode(project.id),
+    };
+  };
+
+  /**
+   * Retrieves the projects nodes.
+   * @returns {IProjectProfitabilitySummaryProjectNode[]}
+   */
+  private getProjectsNode = (): IProjectProfitabilitySummaryProjectNode[] => {
+    return map(this.getProjectNode)(this.repository.projects);
+  };
+
+  /**
+   * Retrieves the all projects total income node.
+   * @param {IProjectProfitabilitySummaryProjectNode[]} projects
+   * @returns {IProjectProfitabilitySummaryTotal}
+   */
+  private getProjectsTotalIncomeNode = (
+    projects: IProjectProfitabilitySummaryProjectNode[]
+  ): IProjectProfitabilitySummaryTotal => {
+    const amount = sumBy(projects, 'income.amount');
+    const formattedAmount = this.formatTotalNumber(amount);
+
+    return {
+      amount,
+      formattedAmount,
+      currencyCode: this.baseCurrency,
+    };
+  };
+
+  /**
+   * Retrieves the all projects expenses total node.
+   * @param {IProjectProfitabilitySummaryProjectNode[]} projects
+   * @returns {IProjectProfitabilitySummaryTotal}
+   */
+  private getProjectsTotalExpensesNode = (
+    projects: IProjectProfitabilitySummaryProjectNode[]
+  ): IProjectProfitabilitySummaryTotal => {
+    const amount = sumBy(projects, 'expenses.amount');
+    const formattedAmount = this.formatTotalNumber(amount);
+
+    return {
+      amount,
+      formattedAmount,
+      currencyCode: this.baseCurrency,
+    };
+  };
+
+  /**
+   * Retreives the all projects profit total node.
+   * @param {IProjectProfitabilitySummaryProjectNode[]} projects
+   * @returns {IProjectProfitabilitySummaryTotal}
+   */
+  private getProjectsTotalProfitNode = (
+    projects: IProjectProfitabilitySummaryProjectNode[]
+  ) => {
+    const amount = sumBy(projects, 'profit.amount');
+    const formattedAmount = this.formatTotalNumber(amount);
+
+    return {
+      amount,
+      formattedAmount,
+      currencyCode: this.baseCurrency,
+    };
+  };
+
+  /**
+   * Retrieves the all projects total node.
+   * @param {IProjectProfitabilitySummaryProjectNode[]} projects
+   * @returns {IProjectProfitabilitySummaryTotal}
+   */
+  private getProjectsTotalNode = (
+    projects: IProjectProfitabilitySummaryProjectNode[]
+  ) => {
+    const income = this.getProjectsTotalIncomeNode(projects);
+    const expenses = this.getProjectsTotalExpensesNode(projects);
+    const profit = this.getProjectsTotalProfitNode(projects);
+
+    return { income, expenses, profit };
+  };
+
+  /**
+   * Retrieves the report data.
+   * @returns {IProjectProfitabilitySummaryTotal}
+   */
+  public getReportData = () => {
+    const projects = this.getProjectsNode();
+    const total = this.getProjectsTotalNode(projects);
+
+    return { projects, total };
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/ProjectProfitabilitySummary/ProjectProfitabilitySummaryRepository.ts b/packages/server/src/services/FinancialStatements/ProjectProfitabilitySummary/ProjectProfitabilitySummaryRepository.ts
new file mode 100644
index 000000000..9ba59cc74
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProjectProfitabilitySummary/ProjectProfitabilitySummaryRepository.ts
@@ -0,0 +1,147 @@
+import { ACCOUNT_NORMAL, ACCOUNT_ROOT_TYPE } from '@/data/AccountTypes';
+import { IAccount, ProjectProfitabilitySummaryQuery } from '@/interfaces';
+import { isEmpty, map } from 'lodash';
+import Project from 'models/Project';
+import Ledger from '@/services/Accounting/Ledger';
+
+export class ProjectProfitabilitySummaryRespository {
+  /**
+   * Tenant models.
+   */
+  private readonly models;
+
+  /**
+   * The report query.
+   * @param {ProjectProfitabilitySummaryQuery}
+   */
+  private readonly query: ProjectProfitabilitySummaryQuery;
+
+  /**
+   *
+   * @param {Project[]}
+   */
+  public projects: Project[];
+
+  /**
+   * Income ledger grouped by projects.
+   * @param {Ledger}
+   */
+  public incomeLedger: Ledger;
+
+  /**
+   * Expenses ledger grouped by projects.
+   * @param {Ledger}
+   */
+  public expenseLedger: Ledger;
+
+  /**
+   *
+   * @param {Models} models -
+   * @param {ProjectProfitabilitySummaryQuery} query -
+   */
+  constructor(models: any, query: ProjectProfitabilitySummaryQuery) {
+    this.query = query;
+    this.models = models;
+  }
+
+  /**
+   * Async initialize all DB queries.
+   */
+  public asyncInitialize = async () => {
+    await this.initProjects();
+
+    const incomeEntries = await this.getIncomeAccountsGroupedEntries();
+    const expenseEntries = await this.getExpenseAccountsGroupedEntries();
+
+    this.incomeLedger = Ledger.fromTransactions(incomeEntries);
+    this.expenseLedger = Ledger.fromTransactions(expenseEntries);
+  };
+
+  /**
+   * Initialize projects.
+   */
+  public initProjects = async () => {
+    const { Project } = this.models;
+
+    const projects = await Project.query().onBuild((query) => {
+      if (this.query.projectsIds) {
+        query.whereIn('id', this.query.projectsIds);
+      }
+      query.withGraphFetched('contact');
+    });
+    this.projects = projects;
+  };
+
+  /**
+   * Retrieves the sumation of grouped entries by account and project id.
+   * @param {number[]} accountsIds
+   * @param {string} accountNormal -
+   * @returns {}
+   */
+  public getAccountsGroupedEntries = async (accountsIds: number[]) => {
+    const { AccountTransaction } = this.models;
+
+    return AccountTransaction.query().onBuild((query) => {
+      query.sum('credit as credit');
+      query.sum('debit as debit');
+      query.select(['accountId', 'projectId']);
+
+      query.groupBy('accountId');
+      query.groupBy('projectId');
+
+      query.whereNotNull('projectId');
+      query.withGraphFetched('account');
+
+      query.whereIn('accountId', accountsIds);
+
+      if (!isEmpty(this.query.projectsIds)) {
+        query.modify('filterByProjects', this.query.projectsIds);
+      }
+    });
+  };
+
+  /**
+   * Retrieves all income accounts.
+   * @returns {IAccount}
+   */
+  public getIncomeAccounts = () => {
+    const { Account } = this.models;
+
+    return Account.query().modify('filterByRootType', ACCOUNT_ROOT_TYPE.INCOME);
+  };
+
+  /**
+   * Retrieves all expenses accounts.
+   * @returns
+   */
+  public getExpensesAccounts = () => {
+    const { Account } = this.models;
+
+    return Account.query().modify(
+      'filterByRootType',
+      ACCOUNT_ROOT_TYPE.EXPENSE
+    );
+  };
+
+  /**
+   * Retrieves the sumation of grouped entries by income accounts and projects.
+   * @returns {}
+   */
+  public getIncomeAccountsGroupedEntries = async () => {
+    const incomeAccounts = await this.getIncomeAccounts();
+    const incomeAcountssIds = map(incomeAccounts, 'id');
+
+    return this.getAccountsGroupedEntries(incomeAcountssIds);
+  };
+
+  /**
+   * Retrieves the sumation of grouped entries by expenses accounts and projects.
+   * @returns {}
+   */
+  public getExpenseAccountsGroupedEntries = async () => {
+    const expenseAccounts = await this.getExpensesAccounts();
+    const expenseAccountsIds = map(expenseAccounts, 'id');
+
+    return this.getAccountsGroupedEntries(expenseAccountsIds);
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/ProjectProfitabilitySummary/ProjectProfitabilitySummaryService.ts b/packages/server/src/services/FinancialStatements/ProjectProfitabilitySummary/ProjectProfitabilitySummaryService.ts
new file mode 100644
index 000000000..59f8866bd
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProjectProfitabilitySummary/ProjectProfitabilitySummaryService.ts
@@ -0,0 +1,75 @@
+import { Inject, Service } from 'typedi';
+import {
+  IProjectProfitabilitySummaryMeta,
+  IProjectProfitabilitySummaryPOJO,
+  ProjectProfitabilitySummaryQuery,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Tenant } from '@/system/models';
+import { ProfitProfitabilitySummary } from './ProjectProfitabilitySummary';
+import { ProjectProfitabilitySummaryRespository } from './ProjectProfitabilitySummaryRepository';
+
+@Service()
+export class ProjectProfitabilitySummaryService {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Retrieves the project profitiability summary report.
+   * @param {number} tenantId
+   * @param {ProjectProfitabilitySummaryQuery} query
+   * @returns {Promise<IProjectProfitabilitySummaryPOJO>}
+   */
+  public projectProfitabilitySummary = async (
+    tenantId: number,
+    query: ProjectProfitabilitySummaryQuery
+  ): Promise<IProjectProfitabilitySummaryPOJO> => {
+    const models = this.tenancy.models(tenantId);
+
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    // Initialize the report repository.
+    const projectProfitabilityRepo = new ProjectProfitabilitySummaryRespository(
+      models,
+      query
+    );
+    await projectProfitabilityRepo.asyncInitialize();
+
+    const projectProfitabilityInstance = new ProfitProfitabilitySummary(
+      projectProfitabilityRepo,
+      tenant.metadata.baseCurrency
+    );
+    const projectProfitData = projectProfitabilityInstance.getReportData();
+
+    return {
+      data: projectProfitData,
+      query,
+      meta: this.reportMetadata(tenantId),
+    };
+  };
+
+  /**
+   * Retrieve the balance sheet meta.
+   * @param {number} tenantId -
+   * @returns {IBalanceSheetMeta}
+   */
+  private reportMetadata(tenantId: number): IProjectProfitabilitySummaryMeta {
+    const settings = this.tenancy.settings(tenantId);
+
+    const organizationName = settings.get({
+      group: 'organization',
+      key: 'name',
+    });
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+
+    return {
+      organizationName,
+      baseCurrency,
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/ProjectProfitabilitySummary/ProjectProfitabilitySummaryTable.ts b/packages/server/src/services/FinancialStatements/ProjectProfitabilitySummary/ProjectProfitabilitySummaryTable.ts
new file mode 100644
index 000000000..0cd1b96df
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/ProjectProfitabilitySummary/ProjectProfitabilitySummaryTable.ts
@@ -0,0 +1,116 @@
+import { map } from 'lodash/fp';
+import * as R from 'ramda';
+import {
+  IProjectProfitabilitySummaryData,
+  IProjectProfitabilitySummaryProjectNode,
+  IProjectProfitabilitySummaryRowType,
+  IProjectProfitabilitySummaryTotalNode,
+  ITableColumn,
+  ITableRow,
+} from '@/interfaces';
+import { tableRowMapper } from 'utils';
+
+export class ProjectProfitabilitySummaryTable {
+  /**
+   * Holds the report data.
+   * @var {IProjectProfitabilitySummaryPOJO}
+   */
+  private readonly reportData: IProjectProfitabilitySummaryData;
+
+  /**
+   * Constructor method.
+   * @param {IProjectProfitabilitySummaryData} reportData
+   * @param {} i18n
+   */
+  constructor(
+    reportData: IProjectProfitabilitySummaryData,
+    i18n: any
+  ) {
+    this.reportData = reportData;
+    this.i18n = i18n;
+  }
+
+  // ----------------------------------
+  // # ROWS.
+  // ----------------------------------
+  /**
+   * Retrieves the project node table row.
+   * @param {IProjectProfitabilitySummaryProjectNode} node
+   * @returns {ITableRow}
+   */
+  private projectNodeData = (
+    node: IProjectProfitabilitySummaryProjectNode
+  ): ITableRow => {
+    const meta = {
+      rowTypes: [IProjectProfitabilitySummaryRowType.PROJECT],
+    };
+    const columns = [
+      { key: 'name', accessor: 'projectName' },
+      { key: 'customer_name', accessor: 'customerName' },
+      { key: 'income', accessor: 'income.formattedAmount' },
+      { key: 'expenses', accessor: 'expenses.formattedAmount' },
+      { key: 'profit', accessor: 'profit.formattedAmount' },
+    ];
+    return tableRowMapper(node, columns, meta);
+  };
+
+  /**
+   * Retrieves the projects nodes table rows.
+   * @param {IProjectProfitabilitySummaryProjectNode[]} nodes
+   * @returns {ITableRow[]}
+   */
+  public projectsNodesData = (
+    nodes: IProjectProfitabilitySummaryProjectNode[]
+  ): ITableRow[] => {
+    return map(this.projectNodeData)(nodes);
+  };
+
+  /**
+   * Retrieves the projects total table row.
+   * @param {IProjectProfitabilitySummaryTotal} totalNode
+   * @returns {ITableRow}
+   */
+  public projectsTotalRow = (
+    node: IProjectProfitabilitySummaryTotalNode
+  ): ITableRow => {
+    const meta = {
+      rowTypes: [IProjectProfitabilitySummaryRowType.TOTAL],
+    };
+    const columns = [
+      { key: 'name', value: '' },
+      { key: 'customer_name', value: '' },
+      { key: 'income', accessor: 'income.formattedAmount' },
+      { key: 'expenses', accessor: 'expenses.formattedAmount' },
+      { key: 'profit', accessor: 'profit.formattedAmount' },
+    ];
+    return tableRowMapper(node, columns, meta);
+  };
+
+  /**
+   * Retrieves the table rows.
+   * @returns {ITableRow[]}
+   */
+  public tableData = (): ITableRow[] => {
+    return R.pipe(
+      R.concat(this.projectsNodesData(this.reportData.projects)),
+      R.append(this.projectsTotalRow(this.reportData.total))
+    )([]);
+  };
+
+  // ----------------------------------
+  // # Columns.
+  // ----------------------------------
+  /**
+   * Retrievs the table columns
+   * @returns {ITableColumn[]}
+   */
+  public tableColumns = (): ITableColumn[] => {
+    return [
+      { key: 'name', label: 'Project Name' },
+      { key: 'customer_name', label: 'Customer Name' },
+      { key: 'income', label: 'Income' },
+      { key: 'expenses', label: 'Expenses' },
+      { key: 'profit', label: 'Profit' },
+    ];
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/PurchasesByItems/PurchasesByItems.ts b/packages/server/src/services/FinancialStatements/PurchasesByItems/PurchasesByItems.ts
new file mode 100644
index 000000000..0dba04f03
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/PurchasesByItems/PurchasesByItems.ts
@@ -0,0 +1,187 @@
+import { get, isEmpty, sumBy } from 'lodash';
+import * as R from 'ramda';
+import FinancialSheet from '../FinancialSheet';
+import { allPassedConditionsPass, transformToMap } from 'utils';
+import {
+  IAccountTransaction,
+  IInventoryValuationTotal,
+  IInventoryValuationItem,
+  IInventoryValuationReportQuery,
+  IInventoryValuationStatement,
+  IItem,
+} from '@/interfaces';
+
+export default class InventoryValuationReport extends FinancialSheet {
+  readonly baseCurrency: string;
+  readonly items: IItem[];
+  readonly itemsTransactions: Map<number, IAccountTransaction>;
+  readonly query: IInventoryValuationReportQuery;
+
+  /**
+   * Constructor method.
+   * @param {IInventoryValuationReportQuery} query
+   * @param {IItem[]} items
+   * @param {IAccountTransaction[]} itemsTransactions
+   * @param {string} baseCurrency
+   */
+  constructor(
+    query: IInventoryValuationReportQuery,
+    items: IItem[],
+    itemsTransactions: IAccountTransaction[],
+    baseCurrency: string
+  ) {
+    super();
+
+    this.baseCurrency = baseCurrency;
+    this.items = items;
+    this.itemsTransactions = transformToMap(itemsTransactions, 'itemId');
+    this.query = query;
+    this.numberFormat = this.query.numberFormat;
+  }
+
+  /**
+   * Retrieve the item purchase item, cost and average cost price.
+   * @param {number} itemId
+   */
+  getItemTransaction(itemId: number): {
+    quantity: number;
+    cost: number;
+    average: number;
+  } {
+    const transaction = this.itemsTransactions.get(itemId);
+
+    const quantity = get(transaction, 'quantity', 0);
+    const cost = get(transaction, 'cost', 0);
+
+    const average = cost / quantity;
+
+    return { quantity, cost, average };
+  }
+
+  /**
+   * Detarmines whether the purchase node is active.
+   * @param {} node
+   * @returns {boolean}
+   */
+  private filterPurchaseOnlyActive = (node) => {
+    return node.quantityPurchased !== 0 && node.purchaseCost !== 0;
+  };
+
+  /**
+   * Determines whether the purchase node is not none transactions.
+   * @param node
+   * @returns {boolean}
+   */
+  private filterPurchaseNoneTransaction = (node) => {
+    const anyTransaction = this.itemsTransactions.get(node.id);
+
+    return !isEmpty(anyTransaction);
+  };
+
+  /**
+   * Filters sales by items nodes based on the report query.
+   * @param {ISalesByItemsItem} saleItem -
+   * @return {boolean}
+   */
+  private purchaseByItemFilter = (node): boolean => {
+    const { noneTransactions, onlyActive } = this.query;
+
+    const conditions = [
+      [noneTransactions, this.filterPurchaseNoneTransaction],
+      [onlyActive, this.filterPurchaseOnlyActive],
+    ];
+    return allPassedConditionsPass(conditions)(node);
+  };
+
+  /**
+   * Mapping the given item section.
+   * @param {IInventoryValuationItem} item
+   * @returns
+   */
+  private itemSectionMapper = (item: IItem): IInventoryValuationItem => {
+    const meta = this.getItemTransaction(item.id);
+
+    return {
+      id: item.id,
+      name: item.name,
+      code: item.code,
+      quantityPurchased: meta.quantity,
+      purchaseCost: meta.cost,
+      averageCostPrice: meta.average,
+      quantityPurchasedFormatted: this.formatNumber(meta.quantity, {
+        money: false,
+      }),
+      purchaseCostFormatted: this.formatNumber(meta.cost),
+      averageCostPriceFormatted: this.formatNumber(meta.average),
+      currencyCode: this.baseCurrency,
+    };
+  };
+
+  /**
+   * Detarmines whether the items post filter is active.
+   * @returns {boolean}
+   */
+  private isItemsPostFilter = (): boolean => {
+    return isEmpty(this.query.itemsIds);
+  };
+
+  /**
+   * Filters purchase by items nodes.
+   * @param {} nodes -
+   * @returns
+   */
+  private itemsFilter = (nodes) => {
+    return nodes.filter(this.purchaseByItemFilter);
+  };
+
+  /**
+   * Mappes purchase by items nodes.
+   * @param items
+   * @returns
+   */
+  private itemsMapper = (items) => {
+    return items.map(this.itemSectionMapper);
+  };
+
+  /**
+   * Retrieve the items sections.
+   * @returns {IInventoryValuationItem[]}
+   */
+  private itemsSection = (): IInventoryValuationItem[] => {
+    return R.compose(
+      R.when(this.isItemsPostFilter, this.itemsFilter),
+      this.itemsMapper
+    )(this.items);
+  };
+
+  /**
+   * Retrieve the total section of the sheet.
+   * @param {IInventoryValuationItem[]} items
+   * @returns {IInventoryValuationTotal}
+   */
+  totalSection(items: IInventoryValuationItem[]): IInventoryValuationTotal {
+    const quantityPurchased = sumBy(items, (item) => item.quantityPurchased);
+    const purchaseCost = sumBy(items, (item) => item.purchaseCost);
+
+    return {
+      quantityPurchased,
+      purchaseCost,
+      quantityPurchasedFormatted: this.formatTotalNumber(quantityPurchased, {
+        money: false,
+      }),
+      purchaseCostFormatted: this.formatTotalNumber(purchaseCost),
+      currencyCode: this.baseCurrency,
+    };
+  }
+
+  /**
+   * Retrieve the sheet data.
+   * @returns
+   */
+  reportData(): IInventoryValuationStatement {
+    const items = this.itemsSection();
+    const total = this.totalSection(items);
+
+    return items.length > 0 ? { items, total } : {};
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/PurchasesByItems/PurchasesByItemsService.ts b/packages/server/src/services/FinancialStatements/PurchasesByItems/PurchasesByItemsService.ts
new file mode 100644
index 000000000..4c226e48a
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/PurchasesByItems/PurchasesByItemsService.ts
@@ -0,0 +1,127 @@
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import {
+  IInventoryValuationReportQuery,
+  IInventoryValuationStatement,
+  IInventoryValuationSheetMeta,
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import PurchasesByItems from './PurchasesByItems';
+import { Tenant } from '@/system/models';
+
+@Service()
+export default class InventoryValuationReportService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  /**
+   * Defaults balance sheet filter query.
+   * @return {IBalanceSheetQuery}
+   */
+  get defaultQuery(): IInventoryValuationReportQuery {
+    return {
+      fromDate: moment().startOf('year').format('YYYY-MM-DD'),
+      toDate: moment().endOf('year').format('YYYY-MM-DD'),
+      itemsIds: [],
+      numberFormat: {
+        precision: 2,
+        divideOn1000: false,
+        showZero: false,
+        formatMoney: 'always',
+        negativeFormat: 'mines',
+      },
+      noneTransactions: true,
+      onlyActive: false,
+    };
+  }
+
+  /**
+   * Retrieve the balance sheet meta.
+   * @param {number} tenantId -
+   * @returns {IBalanceSheetMeta}
+   */
+  reportMetadata(tenantId: number): IInventoryValuationSheetMeta {
+    const settings = this.tenancy.settings(tenantId);
+
+    const organizationName = settings.get({
+      group: 'organization',
+      key: 'name',
+    });
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+
+    return {
+      organizationName,
+      baseCurrency,
+    };
+  }
+
+  /**
+   * Retrieve balance sheet statement.
+   * -------------
+   * @param {number} tenantId
+   * @param {IBalanceSheetQuery} query
+   *
+   * @return {IBalanceSheetStatement}
+   */
+  public async purchasesByItems(
+    tenantId: number,
+    query: IInventoryValuationReportQuery
+  ): Promise<{
+    data: IInventoryValuationStatement,
+    query: IInventoryValuationReportQuery,
+    meta: IInventoryValuationSheetMeta,
+  }> {
+    const { Item, InventoryTransaction } = this.tenancy.models(tenantId);
+
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const filter = {
+      ...this.defaultQuery,
+      ...query,
+    };
+    const inventoryItems = await Item.query().onBuild(q => {
+      q.where('type', 'inventory');
+
+      if (filter.itemsIds.length > 0) {
+        q.whereIn('id', filter.itemsIds);
+      }
+    });
+    const inventoryItemsIds = inventoryItems.map((item) => item.id);
+
+    // Calculates the total inventory total quantity and rate `IN` transactions.
+    const inventoryTransactions = await InventoryTransaction.query().onBuild(
+      (builder: any) => {
+        builder.modify('itemsTotals');
+        builder.modify('INDirection');
+
+        // Filter the inventory items only.
+        builder.whereIn('itemId', inventoryItemsIds);
+
+        // Filter the date range of the sheet.
+        builder.modify('filterDateRange', filter.fromDate, filter.toDate)
+      }
+    );
+
+    const purchasesByItemsInstance = new PurchasesByItems(
+      filter,
+      inventoryItems,
+      inventoryTransactions,
+      tenant.metadata.baseCurrency
+    );
+    const purchasesByItemsData = purchasesByItemsInstance.reportData();
+
+    return {
+      data: purchasesByItemsData,
+      query: filter,
+      meta: this.reportMetadata(tenantId),
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/SalesByItems/SalesByItems.ts b/packages/server/src/services/FinancialStatements/SalesByItems/SalesByItems.ts
new file mode 100644
index 000000000..1cb7f0074
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/SalesByItems/SalesByItems.ts
@@ -0,0 +1,174 @@
+import { get, sumBy } from 'lodash';
+import * as R from 'ramda';
+import FinancialSheet from '../FinancialSheet';
+import { allPassedConditionsPass, transformToMap } from 'utils';
+import {
+  ISalesByItemsReportQuery,
+  IAccountTransaction,
+  ISalesByItemsItem,
+  ISalesByItemsTotal,
+  ISalesByItemsSheetStatement,
+  IItem,
+} from '@/interfaces';
+
+export default class SalesByItemsReport extends FinancialSheet {
+  readonly baseCurrency: string;
+  readonly items: IItem[];
+  readonly itemsTransactions: Map<number, IAccountTransaction>;
+  readonly query: ISalesByItemsReportQuery;
+
+  /**
+   * Constructor method.
+   * @param {ISalesByItemsReportQuery} query
+   * @param {IItem[]} items
+   * @param {IAccountTransaction[]} itemsTransactions
+   * @param {string} baseCurrency
+   */
+  constructor(
+    query: ISalesByItemsReportQuery,
+    items: IItem[],
+    itemsTransactions: IAccountTransaction[],
+    baseCurrency: string
+  ) {
+    super();
+
+    this.baseCurrency = baseCurrency;
+    this.items = items;
+    this.itemsTransactions = transformToMap(itemsTransactions, 'itemId');
+    this.query = query;
+    this.numberFormat = this.query.numberFormat;
+  }
+
+  /**
+   * Retrieve the item purchase item, cost and average cost price.
+   * @param {number} itemId - Item id.
+   */
+  getItemTransaction(itemId: number): {
+    quantity: number;
+    cost: number;
+    average: number;
+  } {
+    const transaction = this.itemsTransactions.get(itemId);
+
+    const quantity = get(transaction, 'quantity', 0);
+    const cost = get(transaction, 'cost', 0);
+
+    const average = cost / quantity;
+
+    return { quantity, cost, average };
+  }
+
+  /**
+   * Mapping the given item section.
+   * @param {ISalesByItemsItem} item
+   * @returns
+   */
+  private itemSectionMapper = (item: IItem): ISalesByItemsItem => {
+    const meta = this.getItemTransaction(item.id);
+
+    return {
+      id: item.id,
+      name: item.name,
+      code: item.code,
+      quantitySold: meta.quantity,
+      soldCost: meta.cost,
+      averageSellPrice: meta.average,
+      quantitySoldFormatted: this.formatNumber(meta.quantity, {
+        money: false,
+      }),
+      soldCostFormatted: this.formatNumber(meta.cost),
+      averageSellPriceFormatted: this.formatNumber(meta.average),
+      currencyCode: this.baseCurrency,
+    };
+  };
+
+  /**
+   * Detarmines whether the given sale node is has transactions.
+   * @param {ISalesByItemsItem} node -
+   * @returns {boolean}
+   */
+  private filterSaleNoneTransactions = (node: ISalesByItemsItem) => {
+    return this.itemsTransactions.get(node.id);
+  };
+
+  /**
+   * Detarmines whether the given sale by item node is active.
+   * @param {ISalesByItemsItem} node
+   * @returns {boolean}
+   */
+  private filterSaleOnlyActive = (node: ISalesByItemsItem): boolean => {
+    return node.quantitySold !== 0 || node.soldCost !== 0;
+  };
+
+  /**
+   * Filters sales by items nodes based on the report query.
+   * @param {ISalesByItemsItem} saleItem -
+   * @return {boolean}
+   */
+  private itemSaleFilter = (saleItem: ISalesByItemsItem): boolean => {
+    const { noneTransactions, onlyActive } = this.query;
+
+    const conditions = [
+      [noneTransactions, this.filterSaleNoneTransactions],
+      [onlyActive, this.filterSaleOnlyActive],
+    ];
+    return allPassedConditionsPass(conditions)(saleItem);
+  };
+
+  /**
+   * Mappes the given items to sales by items nodes.
+   * @param {IItem[]} items -
+   * @returns {ISalesByItemsItem[]}
+   */
+  private itemsMapper = (items: IItem[]): ISalesByItemsItem[] => {
+    return items.map(this.itemSectionMapper);
+  };
+
+  /**
+   * Filters sales by items sections.
+   * @param items
+   * @returns
+   */
+  private itemsFilters = (nodes: ISalesByItemsItem[]): ISalesByItemsItem[] => {
+    return nodes.filter(this.itemSaleFilter);
+  };
+
+  /**
+   * Retrieve the items sections.
+   * @returns {ISalesByItemsItem[]}
+   */
+  private itemsSection(): ISalesByItemsItem[] {
+    return R.compose(this.itemsFilters, this.itemsMapper)(this.items);
+  }
+
+  /**
+   * Retrieve the total section of the sheet.
+   * @param {IInventoryValuationItem[]} items
+   * @returns {IInventoryValuationTotal}
+   */
+  totalSection(items: ISalesByItemsItem[]): ISalesByItemsTotal {
+    const quantitySold = sumBy(items, (item) => item.quantitySold);
+    const soldCost = sumBy(items, (item) => item.soldCost);
+
+    return {
+      quantitySold,
+      soldCost,
+      quantitySoldFormatted: this.formatTotalNumber(quantitySold, {
+        money: false,
+      }),
+      soldCostFormatted: this.formatTotalNumber(soldCost),
+      currencyCode: this.baseCurrency,
+    };
+  }
+
+  /**
+   * Retrieve the sheet data.
+   * @returns {ISalesByItemsSheetStatement}
+   */
+  reportData(): ISalesByItemsSheetStatement {
+    const items = this.itemsSection();
+    const total = this.totalSection(items);
+
+    return items.length > 0 ? { items, total } : {};
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/SalesByItems/SalesByItemsService.ts b/packages/server/src/services/FinancialStatements/SalesByItems/SalesByItemsService.ts
new file mode 100644
index 000000000..8d0032f7a
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/SalesByItems/SalesByItemsService.ts
@@ -0,0 +1,132 @@
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import {
+  ISalesByItemsReportQuery,
+  ISalesByItemsSheetStatement,
+  ISalesByItemsSheetMeta
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import SalesByItems from './SalesByItems';
+import { Tenant } from '@/system/models';
+
+@Service()
+export default class SalesByItemsReportService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  /**
+   * Defaults balance sheet filter query.
+   * @return {IBalanceSheetQuery}
+   */
+  get defaultQuery(): ISalesByItemsReportQuery {
+    return {
+      fromDate: moment().startOf('year').format('YYYY-MM-DD'),
+      toDate: moment().endOf('year').format('YYYY-MM-DD'),
+      itemsIds: [],
+      numberFormat: {
+        precision: 2,
+        divideOn1000: false,
+        showZero: false,
+        formatMoney: 'always',
+        negativeFormat: 'mines',
+      },
+      noneTransactions: true,
+      onlyActive: false,
+    };
+  }
+
+  /**
+   * Retrieve the balance sheet meta.
+   * @param {number} tenantId -
+   * @returns {IBalanceSheetMeta}
+   */
+  reportMetadata(tenantId: number): ISalesByItemsSheetMeta {
+    const settings = this.tenancy.settings(tenantId);
+
+    const organizationName = settings.get({
+      group: 'organization',
+      key: 'name',
+    });
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+
+    return {
+      organizationName,
+      baseCurrency,
+    };
+  }
+
+  /**
+   * Retrieve balance sheet statement.
+   * -------------
+   * @param {number} tenantId
+   * @param {IBalanceSheetQuery} query
+   *
+   * @return {IBalanceSheetStatement}
+   */
+  public async salesByItems(
+    tenantId: number,
+    query: ISalesByItemsReportQuery
+  ): Promise<{
+    data: ISalesByItemsSheetStatement,
+    query: ISalesByItemsReportQuery,
+    meta: ISalesByItemsSheetMeta,
+  }> {
+    const { Item, InventoryTransaction } = this.tenancy.models(tenantId);
+
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const filter = {
+      ...this.defaultQuery,
+      ...query,
+    };
+    this.logger.info('[sales_by_items] trying to calculate the report.', {
+      filter,
+      tenantId,
+    });
+    // Inventory items for sales report.
+    const inventoryItems = await Item.query().onBuild((q) => {
+      q.where('type', 'inventory');
+
+      if (filter.itemsIds.length > 0) {
+        q.whereIn('id', filter.itemsIds);
+      }
+    });
+    const inventoryItemsIds = inventoryItems.map((item) => item.id);
+
+    // Calculates the total inventory total quantity and rate `IN` transactions.
+    const inventoryTransactions = await InventoryTransaction.query().onBuild(
+      (builder: any) => {
+        builder.modify('itemsTotals');
+        builder.modify('OUTDirection');
+
+        // Filter the inventory items only.
+        builder.whereIn('itemId', inventoryItemsIds);
+
+        // Filter the date range of the sheet.
+        builder.modify('filterDateRange', filter.fromDate, filter.toDate)
+      }
+    );
+
+    const purchasesByItemsInstance = new SalesByItems(
+      filter,
+      inventoryItems,
+      inventoryTransactions,
+      tenant.metadata.baseCurrency,
+    );
+    const purchasesByItemsData = purchasesByItemsInstance.reportData();
+
+    return {
+      data: purchasesByItemsData,
+      query: filter,
+      meta: this.reportMetadata(tenantId),
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/TransactionsByContact/TransactionsByContact.ts b/packages/server/src/services/FinancialStatements/TransactionsByContact/TransactionsByContact.ts
new file mode 100644
index 000000000..05521ed3b
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/TransactionsByContact/TransactionsByContact.ts
@@ -0,0 +1,195 @@
+import { sumBy, defaultTo } from 'lodash';
+import {
+  ITransactionsByContactsTransaction,
+  ITransactionsByContactsAmount,
+  ITransactionsByContactsFilter,
+  ITransactionsByContactsContact,
+  IContact,
+  ILedger,
+  ILedgerEntry,
+} from '@/interfaces';
+import FinancialSheet from '../FinancialSheet';
+import { allPassedConditionsPass } from 'utils';
+
+export default class TransactionsByContact extends FinancialSheet {
+  readonly contacts: IContact[];
+  readonly ledger: ILedger;
+  readonly filter: ITransactionsByContactsFilter;
+  readonly accountsGraph: any;
+
+  /**
+   * Customer transaction mapper.
+   * @param {any} transaction -
+   * @return {Omit<ITransactionsByContactsTransaction, 'runningBalance'>}
+   */
+  protected contactTransactionMapper(
+    entry: ILedgerEntry
+  ): Omit<ITransactionsByContactsTransaction, 'runningBalance'> {
+    const account = this.accountsGraph.getNodeData(entry.accountId);
+    const currencyCode = this.baseCurrency;
+
+    return {
+      credit: this.getContactAmount(entry.credit, currencyCode),
+      debit: this.getContactAmount(entry.debit, currencyCode),
+      accountName: account.name,
+      currencyCode: this.baseCurrency,
+      transactionNumber: entry.transactionNumber,
+      transactionType: this.i18n.__(entry.referenceTypeFormatted),
+      date: entry.date,
+      createdAt: entry.createdAt,
+    };
+  }
+
+  /**
+   * Customer transactions mapper with running balance.
+   * @param {number} openingBalance
+   * @param {ITransactionsByContactsTransaction[]} transactions
+   * @returns {ITransactionsByContactsTransaction[]}
+   */
+  protected contactTransactionRunningBalance(
+    openingBalance: number,
+    accountNormal: 'credit' | 'debit',
+    transactions: Omit<ITransactionsByContactsTransaction, 'runningBalance'>[]
+  ): any {
+    let _openingBalance = openingBalance;
+
+    return transactions.map(
+      (transaction: ITransactionsByContactsTransaction) => {
+        _openingBalance +=
+          accountNormal === 'debit'
+            ? transaction.debit.amount
+            : -1 * transaction.debit.amount;
+
+        _openingBalance +=
+          accountNormal === 'credit'
+            ? transaction.credit.amount
+            : -1 * transaction.credit.amount;
+
+        const runningBalance = this.getTotalAmountMeta(
+          _openingBalance,
+          transaction.currencyCode
+        );
+        return { ...transaction, runningBalance };
+      }
+    );
+  }
+
+  /**
+   * Retrieve the customer closing balance from the given transactions and opening balance.
+   * @param {number} customerTransactions
+   * @param {number} openingBalance
+   * @returns {number}
+   */
+  protected getContactClosingBalance(
+    customerTransactions: ITransactionsByContactsTransaction[],
+    contactNormal: 'credit' | 'debit',
+    openingBalance: number
+  ): number {
+    const closingBalance = openingBalance;
+
+    const totalCredit = sumBy(customerTransactions, 'credit.amount');
+    const totalDebit = sumBy(customerTransactions, 'debit.amount');
+
+    const total =
+      contactNormal === 'debit'
+        ? totalDebit - totalCredit
+        : totalCredit - totalDebit;
+
+    return closingBalance + total;
+  }
+
+  /**
+   * Retrieve the given customer opening balance from the given customer id.
+   * @param {number} customerId
+   * @returns {number}
+   */
+  protected getContactOpeningBalance(customerId: number): number {
+    const openingBalanceLedger = this.ledger
+      .whereContactId(customerId)
+      .whereToDate(this.filter.fromDate);
+
+    // Retrieve the closing balance of the ledger.
+    const openingBalance = openingBalanceLedger.getClosingBalance();
+
+    return defaultTo(openingBalance, 0);
+  }
+
+  /**
+   * Retrieve the customer amount format meta.
+   * @param {number} amount
+   * @param {string} currencyCode
+   * @returns {ITransactionsByContactsAmount}
+   */
+  protected getContactAmount(
+    amount: number,
+    currencyCode: string
+  ): ITransactionsByContactsAmount {
+    return {
+      amount,
+      formattedAmount: this.formatNumber(amount, { currencyCode }),
+      currencyCode,
+    };
+  }
+
+  /**
+   * Retrieve the contact total amount format meta.
+   * @param {number} amount - Amount.
+   * @param {string} currencyCode - Currency code./
+   * @returns {ITransactionsByContactsAmount}
+   */
+  protected getTotalAmountMeta(amount: number, currencyCode: string) {
+    return {
+      amount,
+      formattedAmount: this.formatTotalNumber(amount, { currencyCode }),
+      currencyCode,
+    };
+  }
+
+  /**
+   * Filter customer section that has no transactions.
+   * @param {ITransactionsByCustomersCustomer} transactionsByCustomer
+   * @returns {boolean}
+   */
+  private filterContactByNoneTransaction = (
+    transactionsByContact: ITransactionsByContactsContact
+  ): boolean => {
+    return transactionsByContact.transactions.length > 0;
+  };
+
+  /**
+   * Filters customer section has zero closing balnace.
+   * @param {ITransactionsByCustomersCustomer} transactionsByCustomer
+   * @returns {boolean}
+   */
+  private filterContactNoneZero = (
+    transactionsByContact: ITransactionsByContactsContact
+  ): boolean => {
+    return transactionsByContact.closingBalance.amount !== 0;
+  };
+
+  /**
+   * Filters the given customer node;
+   * @param {ICustomerBalanceSummaryCustomer} customer
+   */
+  private contactNodeFilter = (node: ITransactionsByContactsContact) => {
+    const { noneTransactions, noneZero } = this.filter;
+
+    // Conditions pair filter detarminer.
+    const condsPairFilters = [
+      [noneTransactions, this.filterContactByNoneTransaction],
+      [noneZero, this.filterContactNoneZero],
+    ];
+    return allPassedConditionsPass(condsPairFilters)(node);
+  };
+
+  /**
+   * Filters the given customers nodes.
+   * @param {ICustomerBalanceSummaryCustomer[]} nodes
+   * @returns {ICustomerBalanceSummaryCustomer[]}
+   */
+  protected contactsFilter = (
+    nodes: ITransactionsByContactsContact[]
+  ): ITransactionsByContactsContact[] => {
+    return nodes.filter(this.contactNodeFilter);
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/TransactionsByContact/TransactionsByContactTableRows.ts b/packages/server/src/services/FinancialStatements/TransactionsByContact/TransactionsByContactTableRows.ts
new file mode 100644
index 000000000..ff75e3a9b
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/TransactionsByContact/TransactionsByContactTableRows.ts
@@ -0,0 +1,81 @@
+import moment from 'moment';
+import * as R from 'ramda';
+import { tableMapper, tableRowMapper } from 'utils';
+import { ITransactionsByContactsContact, ITableRow } from '@/interfaces';
+
+enum ROW_TYPE {
+  OPENING_BALANCE = 'OPENING_BALANCE',
+  CLOSING_BALANCE = 'CLOSING_BALANCE',
+  TRANSACTION = 'TRANSACTION',
+  CUSTOMER = 'CUSTOMER',
+}
+
+export default class TransactionsByContactsTableRows {
+  private dateAccessor = (value): string => {
+    return moment(value.date).format('YYYY MMM DD');
+  };
+
+  /**
+   * Retrieve the table rows of contact transactions.
+   * @param {ITransactionsByCustomersCustomer} contact
+   * @returns {ITableRow[]}
+   */
+  protected contactTransactions = (
+    contact: ITransactionsByContactsContact
+  ): ITableRow[] => {
+    const columns = [
+      { key: 'date', accessor: this.dateAccessor },
+      { key: 'account', accessor: 'accountName' },
+      { key: 'transactionType', accessor: 'transactionType' },
+      { key: 'transactionNumber', accessor: 'transactionNumber' },
+      { key: 'credit', accessor: 'credit.formattedAmount' },
+      { key: 'debit', accessor: 'debit.formattedAmount' },
+      { key: 'runningBalance', accessor: 'runningBalance.formattedAmount' },
+    ];
+    return tableMapper(contact.transactions, columns, {
+      rowTypes: [ROW_TYPE.TRANSACTION],
+    });
+  };
+
+  /**
+   * Retrieve the table row of contact opening balance.
+   * @param {ITransactionsByCustomersCustomer} contact
+   * @returns {ITableRow}
+   */
+  protected contactOpeningBalance = (
+    contact: ITransactionsByContactsContact
+  ): ITableRow => {
+    const columns = [
+      { key: 'openingBalanceLabel', value: this.i18n.__('Opening balance') },
+      ...R.repeat({ key: 'empty', value: '' }, 5),
+      {
+        key: 'openingBalanceValue',
+        accessor: 'openingBalance.formattedAmount',
+      },
+    ];
+    return tableRowMapper(contact, columns, {
+      rowTypes: [ROW_TYPE.OPENING_BALANCE],
+    });
+  };
+
+  /**
+   * Retrieve the table row of contact closing balance.
+   * @param {ITransactionsByCustomersCustomer} contact -
+   * @returns {ITableRow}
+   */
+  protected contactClosingBalance = (
+    contact: ITransactionsByContactsContact
+  ): ITableRow => {
+    const columns = [
+      { key: 'closingBalanceLabel', value: this.i18n.__('Closing balance') },
+      ...R.repeat({ key: 'empty', value: '' }, 5),
+      {
+        key: 'closingBalanceValue',
+        accessor: 'closingBalance.formattedAmount',
+      },
+    ];
+    return tableRowMapper(contact, columns, {
+      rowTypes: [ROW_TYPE.CLOSING_BALANCE],
+    });
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/TransactionsByCustomer/TransactionsByCustomers.ts b/packages/server/src/services/FinancialStatements/TransactionsByCustomer/TransactionsByCustomers.ts
new file mode 100644
index 000000000..3ab624830
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/TransactionsByCustomer/TransactionsByCustomers.ts
@@ -0,0 +1,149 @@
+import * as R from 'ramda';
+import {
+  ITransactionsByCustomersTransaction,
+  ITransactionsByCustomersFilter,
+  ITransactionsByCustomersCustomer,
+  ITransactionsByCustomersData,
+  INumberFormatQuery,
+  ICustomer,
+} from '@/interfaces';
+import TransactionsByContact from '../TransactionsByContact/TransactionsByContact';
+import Ledger from '@/services/Accounting/Ledger';
+import { isEmpty } from 'lodash';
+
+const CUSTOMER_NORMAL = 'debit';
+
+export default class TransactionsByCustomers extends TransactionsByContact {
+  readonly customers: ICustomer[];
+  readonly ledger: Ledger;
+  readonly filter: ITransactionsByCustomersFilter;
+  readonly baseCurrency: string;
+  readonly numberFormat: INumberFormatQuery;
+  readonly accountsGraph: any;
+
+  /**
+   * Constructor method.
+   * @param {ICustomer} customers
+   * @param {Map<number, IAccountTransaction[]>} transactionsLedger
+   * @param {string} baseCurrency
+   */
+  constructor(
+    customers: ICustomer[],
+    accountsGraph: any,
+    ledger: Ledger,
+    filter: ITransactionsByCustomersFilter,
+    baseCurrency: string,
+    i18n
+  ) {
+    super();
+
+    this.customers = customers;
+    this.accountsGraph = accountsGraph;
+    this.ledger = ledger;
+    this.baseCurrency = baseCurrency;
+    this.filter = filter;
+    this.numberFormat = this.filter.numberFormat;
+    this.i18n = i18n;
+  }
+
+  /**
+   * Retrieve the customer transactions from the given customer id and opening balance.
+   * @param {number} customerId - Customer id.
+   * @param {number} openingBalance - Opening balance amount.
+   * @returns {ITransactionsByCustomersTransaction[]}
+   */
+  private customerTransactions(
+    customerId: number,
+    openingBalance: number
+  ): ITransactionsByCustomersTransaction[] {
+    const ledger = this.ledger
+      .whereContactId(customerId)
+      .whereFromDate(this.filter.fromDate)
+      .whereToDate(this.filter.toDate);
+
+    const ledgerEntries = ledger.getEntries();
+
+    return R.compose(
+      R.curry(this.contactTransactionRunningBalance)(openingBalance, 'debit'),
+      R.map(this.contactTransactionMapper.bind(this))
+    ).bind(this)(ledgerEntries);
+  }
+
+  /**
+   * Customer section mapper.
+   * @param {ICustomer} customer
+   * @returns {ITransactionsByCustomersCustomer}
+   */
+  private customerMapper(
+    customer: ICustomer
+  ): ITransactionsByCustomersCustomer {
+    const openingBalance = this.getContactOpeningBalance(customer.id);
+    const transactions = this.customerTransactions(customer.id, openingBalance);
+    const closingBalance = this.getCustomerClosingBalance(
+      transactions,
+      openingBalance
+    );
+    const currencyCode = this.baseCurrency;
+
+    return {
+      customerName: customer.displayName,
+      openingBalance: this.getTotalAmountMeta(openingBalance, currencyCode),
+      closingBalance: this.getTotalAmountMeta(closingBalance, currencyCode),
+      transactions,
+    };
+  }
+
+  /**
+   * Retrieve the vendor closing balance from the given customer transactions.
+   * @param {ITransactionsByContactsTransaction[]} customerTransactions
+   * @param {number} openingBalance
+   * @returns
+   */
+  private getCustomerClosingBalance(
+    customerTransactions: ITransactionsByCustomersTransaction[],
+    openingBalance: number
+  ): number {
+    return this.getContactClosingBalance(
+      customerTransactions,
+      CUSTOMER_NORMAL,
+      openingBalance
+    );
+  }
+
+  /**
+   * Detarmines whether the customers post filter is active.
+   * @returns {boolean}
+   */
+  private isCustomersPostFilter = () => {
+    return isEmpty(this.filter.customersIds);
+  };
+
+  /**
+   * Retrieve the customers sections of the report.
+   * @param {ICustomer[]} customers
+   * @returns {ITransactionsByCustomersCustomer[]}
+   */
+  private customersMapper(
+    customers: ICustomer[]
+  ): ITransactionsByCustomersCustomer[] {
+    return R.compose(
+      R.when(this.isCustomersPostFilter, this.contactsFilter),
+      R.map(this.customerMapper.bind(this))
+    ).bind(this)(customers);
+  }
+
+  /**
+   * Retrieve the report data.
+   * @returns {ITransactionsByCustomersData}
+   */
+  public reportData(): ITransactionsByCustomersData {
+    return this.customersMapper(this.customers);
+  }
+
+  /**
+   * Retrieve the report columns.
+   */
+  public reportColumns() {
+    return [];
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/TransactionsByCustomer/TransactionsByCustomersRepository.ts b/packages/server/src/services/FinancialStatements/TransactionsByCustomer/TransactionsByCustomersRepository.ts
new file mode 100644
index 000000000..fd66d8f1e
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/TransactionsByCustomer/TransactionsByCustomersRepository.ts
@@ -0,0 +1,98 @@
+import { isEmpty, map } from 'lodash';
+import { IAccount, IAccountTransaction } from '@/interfaces';
+import { ACCOUNT_TYPE } from '@/data/AccountTypes';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject } from 'typedi';
+
+export default class TransactionsByCustomersRepository {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve the report customers.
+   * @param {number} tenantId 
+   * @returns {Promise<ICustomer[]>}
+   */
+  public async getCustomers(tenantId: number, customersIds?: number[]) {
+    const { Customer } = this.tenancy.models(tenantId);
+
+    return Customer.query().onBuild((q) => {
+      q.orderBy('displayName');
+
+      if (!isEmpty(customersIds)) {
+        q.whereIn('id', customersIds);
+      }
+    });
+  }
+
+  /**
+   * Retrieve the accounts receivable.
+   * @param {number} tenantId
+   * @returns {Promise<IAccount[]>}
+   */
+  public async getReceivableAccounts(tenantId: number): Promise<IAccount[]> {
+    const { Account } = this.tenancy.models(tenantId);
+
+    const accounts = await Account.query().where(
+      'accountType',
+      ACCOUNT_TYPE.ACCOUNTS_RECEIVABLE
+    );
+    return accounts;
+  }
+
+  /**
+   * Retrieve the customers opening balance transactions.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} openingDate - Opening date.
+   * @param {number} customersIds - Customers ids.
+   * @returns {Promise<IAccountTransaction[]>}
+   */
+  public async getCustomersOpeningBalanceTransactions(
+    tenantId: number,
+    openingDate: Date,
+    customersIds?: number[]
+  ): Promise<IAccountTransaction[]> {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+
+    const receivableAccounts = await this.getReceivableAccounts(tenantId);
+    const receivableAccountsIds = map(receivableAccounts, 'id');
+
+    const openingTransactions = await AccountTransaction.query().modify(
+      'contactsOpeningBalance',
+      openingDate,
+      receivableAccountsIds,
+      customersIds
+    );
+    return openingTransactions;
+  }
+
+  /**
+   * Retrieve the customers periods transactions.
+   * @param {number} tenantId - Tenant id.
+   * @param {Date|string} openingDate - Opening date.
+   * @param {number[]} customersIds - Customers ids.
+   * @return {Promise<IAccountTransaction[]>}
+   */
+  public async getCustomersPeriodTransactions(
+    tenantId: number,
+    fromDate: Date,
+    toDate: Date
+  ): Promise<IAccountTransaction[]> {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+
+    const receivableAccounts = await this.getReceivableAccounts(tenantId);
+    const receivableAccountsIds = map(receivableAccounts, 'id');
+
+    const transactions = await AccountTransaction.query().onBuild((query) => {
+      // Filter by date.
+      query.modify('filterDateRange', fromDate, toDate);
+
+      // Filter by customers.
+      query.whereNot('contactId', null);
+
+      // Filter by accounts.
+      query.whereIn('accountId', receivableAccountsIds);
+    });
+    return transactions;
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/TransactionsByCustomer/TransactionsByCustomersService.ts b/packages/server/src/services/FinancialStatements/TransactionsByCustomer/TransactionsByCustomersService.ts
new file mode 100644
index 000000000..24723caaa
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/TransactionsByCustomer/TransactionsByCustomersService.ts
@@ -0,0 +1,172 @@
+import { Inject } from 'typedi';
+import * as R from 'ramda';
+import moment from 'moment';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import {
+  ITransactionsByCustomersService,
+  ITransactionsByCustomersFilter,
+  ITransactionsByCustomersStatement,
+  ILedgerEntry,
+} from '@/interfaces';
+import TransactionsByCustomers from './TransactionsByCustomers';
+import Ledger from '@/services/Accounting/Ledger';
+import TransactionsByCustomersRepository from './TransactionsByCustomersRepository';
+import { Tenant } from '@/system/models';
+
+export default class TransactionsByCustomersService
+  implements ITransactionsByCustomersService
+{
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  reportRepository: TransactionsByCustomersRepository;
+
+  /**
+   * Defaults balance sheet filter query.
+   * @return {ICustomerBalanceSummaryQuery}
+   */
+  get defaultQuery(): ITransactionsByCustomersFilter {
+    return {
+      fromDate: moment().startOf('year').format('YYYY-MM-DD'),
+      toDate: moment().endOf('year').format('YYYY-MM-DD'),
+      numberFormat: {
+        precision: 2,
+        divideOn1000: false,
+        showZero: false,
+        formatMoney: 'total',
+        negativeFormat: 'mines',
+      },
+      comparison: {
+        percentageOfColumn: true,
+      },
+      noneZero: false,
+      noneTransactions: true,
+      customersIds: [],
+    };
+  }
+
+  /**
+   * Retrieve the customers opening balance ledger entries.
+   * @param {number} tenantId
+   * @param {Date} openingDate
+   * @param {number[]} customersIds
+   * @returns {Promise<ILedgerEntry[]>}
+   */
+  private async getCustomersOpeningBalanceEntries(
+    tenantId: number,
+    openingDate: Date,
+    customersIds?: number[]
+  ): Promise<ILedgerEntry[]> {
+    const openingTransactions =
+      await this.reportRepository.getCustomersOpeningBalanceTransactions(
+        tenantId,
+        openingDate,
+        customersIds
+      );
+
+    return R.compose(
+      R.map(R.assoc('date', openingDate)),
+      R.map(R.assoc('accountNormal', 'debit'))
+    )(openingTransactions);
+  }
+
+  /**
+   * Retrieve the customers periods ledger entries.
+   * @param {number} tenantId
+   * @param {Date} fromDate
+   * @param {Date} toDate
+   * @returns {Promise<ILedgerEntry[]>}
+   */
+  private async getCustomersPeriodsEntries(
+    tenantId: number,
+    fromDate: Date | string,
+    toDate: Date | string
+  ): Promise<ILedgerEntry[]> {
+    const transactions =
+      await this.reportRepository.getCustomersPeriodTransactions(
+        tenantId,
+        fromDate,
+        toDate
+      );
+    return R.compose(
+      R.map(R.assoc('accountNormal', 'debit')),
+      R.map((trans) => ({
+        ...trans,
+        referenceTypeFormatted: trans.referenceTypeFormatted,
+      }))
+    )(transactions);
+  }
+
+  /**
+   * Retrieve transactions by by the customers.
+   * @param {number} tenantId
+   * @param {ITransactionsByCustomersFilter} query
+   * @return {Promise<ITransactionsByCustomersStatement>}
+   */
+  public async transactionsByCustomers(
+    tenantId: number,
+    query: ITransactionsByCustomersFilter
+  ): Promise<ITransactionsByCustomersStatement> {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+    const i18n = this.tenancy.i18n(tenantId);
+
+    // Retrieve tenant information.
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const filter = {
+      ...this.defaultQuery,
+      ...query,
+    };
+    const accountsGraph = await accountRepository.getDependencyGraph();
+
+    // Retrieve the report customers.
+    const customers = await this.reportRepository.getCustomers(
+      tenantId,
+      filter.customersIds
+    );
+
+    const openingBalanceDate = moment(filter.fromDate)
+      .subtract(1, 'days')
+      .toDate();
+
+    // Retrieve all ledger transactions of the opening balance of.
+    const openingBalanceEntries = await this.getCustomersOpeningBalanceEntries(
+      tenantId,
+      openingBalanceDate
+    );
+    // Retrieve all ledger transactions between opeing and closing period.
+    const customersTransactions = await this.getCustomersPeriodsEntries(
+      tenantId,
+      query.fromDate,
+      query.toDate
+    );
+    // Concats the opening balance and period customer ledger transactions.
+    const journalTransactions = [
+      ...openingBalanceEntries,
+      ...customersTransactions,
+    ];
+    const journal = new Ledger(journalTransactions);
+
+    // Transactions by customers data mapper.
+    const reportInstance = new TransactionsByCustomers(
+      customers,
+      accountsGraph,
+      journal,
+      filter,
+      tenant.metadata.baseCurrency,
+      i18n
+    );
+
+    return {
+      data: reportInstance.reportData(),
+      columns: reportInstance.reportColumns(),
+      query: filter,
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/TransactionsByCustomer/TransactionsByCustomersTableRows.ts b/packages/server/src/services/FinancialStatements/TransactionsByCustomer/TransactionsByCustomersTableRows.ts
new file mode 100644
index 000000000..5c4e1ceb3
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/TransactionsByCustomer/TransactionsByCustomersTableRows.ts
@@ -0,0 +1,78 @@
+import * as R from 'ramda';
+import { tableRowMapper, tableMapper } from 'utils';
+import { ITransactionsByCustomersCustomer, ITableRow } from '@/interfaces';
+import TransactionsByContactsTableRows from '../TransactionsByContact/TransactionsByContactTableRows';
+
+enum ROW_TYPE {
+  OPENING_BALANCE = 'OPENING_BALANCE',
+  CLOSING_BALANCE = 'CLOSING_BALANCE',
+  TRANSACTION = 'TRANSACTION',
+  CUSTOMER = 'CUSTOMER',
+}
+
+export default class TransactionsByCustomersTableRows extends TransactionsByContactsTableRows {
+  private customersTransactions: ITransactionsByCustomersCustomer[];
+
+  /**
+   * Constructor method.
+   * @param {ITransactionsByCustomersCustomer[]} customersTransactions - Customers transactions.
+   */
+  constructor(
+    customersTransactions: ITransactionsByCustomersCustomer[],
+    i18n
+  ) {
+    super();
+    this.customersTransactions = customersTransactions;
+    this.i18n = i18n;
+  }
+
+  /**
+   * Retrieve the table row of customer details.
+   * @param {ITransactionsByCustomersCustomer} customer -
+   * @returns {ITableRow[]}
+   */
+  private customerDetails = (customer: ITransactionsByCustomersCustomer) => {
+    const columns = [
+      { key: 'customerName', accessor: 'customerName' },
+      ...R.repeat({ key: 'empty', value: '' }, 5),
+      {
+        key: 'closingBalanceValue',
+        accessor: 'closingBalance.formattedAmount',
+      },
+    ];
+
+    return {
+      ...tableRowMapper(customer, columns, { rowTypes: [ROW_TYPE.CUSTOMER] }),
+      children: R.pipe(
+        R.when(
+          R.always(customer.transactions.length > 0),
+          R.pipe(
+            R.concat(this.contactTransactions(customer)),
+            R.prepend(this.contactOpeningBalance(customer))
+          )
+        ),
+        R.append(this.contactClosingBalance(customer))
+      )([]),
+    };
+  };
+
+  /**
+   * Retrieve the table rows of the customer section.
+   * @param {ITransactionsByCustomersCustomer} customer
+   * @returns {ITableRow[]}
+   */
+  private customerRowsMapper = (customer: ITransactionsByCustomersCustomer) => {
+    return R.pipe(this.customerDetails)(customer);
+  };
+
+  /**
+   * Retrieve the table rows of transactions by customers report.
+   * @param {ITransactionsByCustomersCustomer[]} customers
+   * @returns {ITableRow[]}
+   */
+  public tableRows = (): ITableRow[] => {
+    return R.map(this.customerRowsMapper.bind(this))(
+      this.customersTransactions
+    );
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/TransactionsByReference/TransactionsByReferenceReport.ts b/packages/server/src/services/FinancialStatements/TransactionsByReference/TransactionsByReferenceReport.ts
new file mode 100644
index 000000000..d3eb43897
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/TransactionsByReference/TransactionsByReferenceReport.ts
@@ -0,0 +1,81 @@
+import {
+    IAccount,
+  IAccountTransaction,
+  INumberFormatQuery,
+  ITransactionsByReferenceQuery,
+  ITransactionsByReferenceTransaction,
+} from '@/interfaces';
+import FinancialSheet from '../FinancialSheet';
+
+export default class TransactionsByReference extends FinancialSheet {
+  readonly transactions: IAccountTransaction[];
+  readonly query: ITransactionsByReferenceQuery;
+  readonly baseCurrency: string;
+  readonly numberFormat: INumberFormatQuery;
+
+  /**
+   * Constructor method.
+   * @param {IAccountTransaction[]} transactions
+   * @param {ITransactionsByReferenceQuery} query
+   * @param {string} baseCurrency
+   */
+  constructor(
+    transactions: (IAccountTransaction & { account: IAccount }) [],
+    query: ITransactionsByReferenceQuery,
+    baseCurrency: string
+  ) {
+    super();
+
+    this.transactions = transactions;
+    this.query = query;
+    this.baseCurrency = baseCurrency;
+    this.numberFormat = this.query.numberFormat;
+  }
+
+  /**
+   * Mappes the given account transaction to report transaction.
+   * @param {IAccountTransaction} transaction
+   * @returns {ITransactionsByReferenceTransaction}
+   */
+  private transactionMapper = (
+    transaction: IAccountTransaction
+  ): ITransactionsByReferenceTransaction => {
+    return {
+      date: this.getDateMeta(transaction.date),
+
+      credit: this.getAmountMeta(transaction.credit, { money: false }),
+      debit: this.getAmountMeta(transaction.debit, { money: false }),
+
+      referenceTypeFormatted: transaction.referenceTypeFormatted,
+      referenceType: transaction.referenceType,
+      referenceId: transaction.referenceId,
+
+      contactId: transaction.contactId,
+      contactType: transaction.contactType,
+      contactTypeFormatted: transaction.contactType,
+
+      accountName: transaction.account.name,
+      accountCode: transaction.account.code,
+      accountId: transaction.accountId,
+    };
+  };
+
+  /**
+   * Mappes the given accounts transactions to report transactions.
+   * @param {IAccountTransaction} transaction
+   * @returns {ITransactionsByReferenceTransaction}
+   */
+  private transactionsMapper = (
+    transactions: IAccountTransaction[]
+  ): ITransactionsByReferenceTransaction[] => {
+    return transactions.map(this.transactionMapper);
+  };
+
+  /**
+   * Retrieve the report data.
+   * @returns {ITransactionsByReferenceTransaction}
+   */
+  public reportData(): ITransactionsByReferenceTransaction[] {
+    return this.transactionsMapper(this.transactions);
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/TransactionsByReference/TransactionsByReferenceRepository.ts b/packages/server/src/services/FinancialStatements/TransactionsByReference/TransactionsByReferenceRepository.ts
new file mode 100644
index 000000000..fa20028bc
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/TransactionsByReference/TransactionsByReferenceRepository.ts
@@ -0,0 +1,29 @@
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Service, Inject } from 'typedi';
+import { IAccount, IAccountTransaction, ITransactionsByReferenceQuery } from '@/interfaces';
+
+@Service()
+export default class TransactionsByReferenceRepository {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve the accounts transactions of the givne reference id and type.
+   * @param {number} tenantId - 
+   * @param {number} referenceId - Reference id.
+   * @param {string} referenceType - Reference type.
+   * @return {Promise<IAccountTransaction[]>}
+   */
+  public getTransactions(
+    tenantId: number,
+    referenceId: number,
+    referenceType: string,
+  ): Promise<(IAccountTransaction & { account: IAccount }) []> {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+
+    return AccountTransaction.query()
+      .where('reference_id', referenceId)
+      .where('reference_type', referenceType)
+      .withGraphFetched('account');
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/TransactionsByReference/index.ts b/packages/server/src/services/FinancialStatements/TransactionsByReference/index.ts
new file mode 100644
index 000000000..0cc0ad6c1
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/TransactionsByReference/index.ts
@@ -0,0 +1,77 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import {
+  ITransactionsByReferenceQuery,
+  ITransactionsByReferenceTransaction,
+} from '@/interfaces';
+import TransactionsByReferenceRepository from './TransactionsByReferenceRepository';
+import TransactionsByReferenceReport from './TransactionsByReferenceReport';
+
+@Service()
+export default class TransactionsByReferenceService {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  reportRepository: TransactionsByReferenceRepository;
+
+  /**
+   * Default query of transactions by reference report.
+   */
+  get defaultQuery(): ITransactionsByReferenceQuery {
+    return {
+      numberFormat: {
+        precision: 2,
+        divideOn1000: false,
+        showZero: false,
+        formatMoney: 'total',
+        negativeFormat: 'mines',
+      },
+    };
+  }
+
+  /**
+   * Retrieve accounts transactions by given reference id and type.
+   * @param {number} tenantId
+   * @param {ITransactionsByReferenceQuery} filter
+   */
+  public async getTransactionsByReference(
+    tenantId: number,
+    query: ITransactionsByReferenceQuery
+  ): Promise<{
+    transactions: ITransactionsByReferenceTransaction[];
+  }> {
+    const filter = {
+      ...this.defaultQuery,
+      ...query,
+    };
+
+    // Retrieve the accounts transactions of the given reference.
+    const transactions = await this.reportRepository.getTransactions(
+      tenantId,
+      filter.referenceId,
+      filter.referenceType
+    );
+
+    // Settings tenant service.
+    const settings = this.tenancy.settings(tenantId);
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+
+    // Transactions by reference report.
+    const report = new TransactionsByReferenceReport(
+      transactions,
+      filter,
+      baseCurrency
+    );
+
+    return {
+      transactions: report.reportData(),
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/TransactionsByVendor/TransactionsByVendor.ts b/packages/server/src/services/FinancialStatements/TransactionsByVendor/TransactionsByVendor.ts
new file mode 100644
index 000000000..5bc9276c0
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/TransactionsByVendor/TransactionsByVendor.ts
@@ -0,0 +1,147 @@
+import * as R from 'ramda';
+import { isEmpty, sumBy } from 'lodash';
+import {
+  ITransactionsByContactsTransaction,
+  ITransactionsByVendorsFilter,
+  ITransactionsByVendorsTransaction,
+  ITransactionsByVendorsVendor,
+  ITransactionsByVendorsData,
+  ILedger,
+  INumberFormatQuery,
+  IVendor,
+} from '@/interfaces';
+import TransactionsByContact from '../TransactionsByContact/TransactionsByContact';
+
+const VENDOR_NORMAL = 'credit';
+
+export default class TransactionsByVendors extends TransactionsByContact {
+  readonly contacts: IVendor[];
+  readonly transactionsByContact: any;
+  readonly filter: ITransactionsByVendorsFilter;
+  readonly baseCurrency: string;
+  readonly numberFormat: INumberFormatQuery;
+  readonly accountsGraph: any;
+  readonly ledger: ILedger;
+
+  /**
+   * Constructor method.
+   * @param {IVendor} vendors
+   * @param {Map<number, IAccountTransaction[]>} transactionsByContact
+   * @param {string} baseCurrency
+   */
+  constructor(
+    vendors: IVendor[],
+    accountsGraph: any,
+    ledger: ILedger,
+    filter: ITransactionsByVendorsFilter,
+    baseCurrency: string,
+    i18n
+  ) {
+    super();
+
+    this.contacts = vendors;
+    this.accountsGraph = accountsGraph;
+    this.ledger = ledger;
+    this.baseCurrency = baseCurrency;
+    this.filter = filter;
+    this.numberFormat = this.filter.numberFormat;
+    this.i18n = i18n;
+  }
+
+  /**
+   * Retrieve the vendor transactions from the given vendor id and opening balance.
+   * @param {number} vendorId - Vendor id.
+   * @param {number} openingBalance - Opening balance amount.
+   * @returns {ITransactionsByVendorsTransaction[]}
+   */
+  private vendorTransactions(
+    vendorId: number,
+    openingBalance: number
+  ): ITransactionsByVendorsTransaction[] {
+    const openingBalanceLedger = this.ledger
+      .whereContactId(vendorId)
+      .whereFromDate(this.filter.fromDate)
+      .whereToDate(this.filter.toDate);
+
+    const openingEntries = openingBalanceLedger.getEntries();
+
+    return R.compose(
+      R.curry(this.contactTransactionRunningBalance)(openingBalance, 'credit'),
+      R.map(this.contactTransactionMapper.bind(this))
+    ).bind(this)(openingEntries);
+  }
+
+  /**
+   * Vendor section mapper.
+   * @param {IVendor} vendor
+   * @returns {ITransactionsByVendorsVendor}
+   */
+  private vendorMapper(vendor: IVendor): ITransactionsByVendorsVendor {
+    const openingBalance = this.getContactOpeningBalance(vendor.id);
+    const transactions = this.vendorTransactions(vendor.id, openingBalance);
+    const closingBalance = this.getVendorClosingBalance(
+      transactions,
+      openingBalance
+    );
+    const currencyCode = this.baseCurrency;
+
+    return {
+      vendorName: vendor.displayName,
+      openingBalance: this.getTotalAmountMeta(openingBalance, currencyCode),
+      closingBalance: this.getTotalAmountMeta(closingBalance, currencyCode),
+      transactions,
+    };
+  }
+
+  /**
+   * Retrieve the vendor closing balance from the given customer transactions.
+   * @param {ITransactionsByContactsTransaction[]} customerTransactions
+   * @param {number} openingBalance
+   * @returns
+   */
+  private getVendorClosingBalance(
+    customerTransactions: ITransactionsByContactsTransaction[],
+    openingBalance: number
+  ) {
+    return this.getContactClosingBalance(
+      customerTransactions,
+      VENDOR_NORMAL,
+      openingBalance
+    );
+  }
+
+  /**
+   * Detarmines whether the vendors post filter is active.
+   * @returns {boolean}
+   */
+  private isVendorsPostFilter = (): boolean => {
+    return isEmpty(this.filter.vendorsIds);
+  };
+
+  /**
+   * Retrieve the vendors sections of the report.
+   * @param {IVendor[]} vendors
+   * @returns {ITransactionsByVendorsVendor[]}
+   */
+  private vendorsMapper(vendors: IVendor[]): ITransactionsByVendorsVendor[] {
+    return R.compose(
+      R.when(this.isVendorsPostFilter, this.contactsFilter),
+      R.map(this.vendorMapper.bind(this))
+    ).bind(this)(vendors);
+  }
+
+  /**
+   * Retrieve the report data.
+   * @returns {ITransactionsByVendorsData}
+   */
+  public reportData(): ITransactionsByVendorsData {
+    return this.vendorsMapper(this.contacts);
+  }
+
+  /**
+   * Retrieve the report columns.
+   */
+  public reportColumns() {
+    return [];
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/TransactionsByVendor/TransactionsByVendorRepository.ts b/packages/server/src/services/FinancialStatements/TransactionsByVendor/TransactionsByVendorRepository.ts
new file mode 100644
index 000000000..d0b50873f
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/TransactionsByVendor/TransactionsByVendorRepository.ts
@@ -0,0 +1,101 @@
+import { Inject, Service } from 'typedi';
+import { isEmpty, map } from 'lodash';
+import { IVendor, IAccount, IAccountTransaction } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ACCOUNT_TYPE } from '@/data/AccountTypes';
+
+@Service()
+export default class TransactionsByVendorRepository {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve the report vendors.
+   * @param {number} tenantId
+   * @returns {Promise<IVendor[]>}
+   */
+  public getVendors(
+    tenantId: number,
+    vendorsIds?: number[]
+  ): Promise<IVendor[]> {
+    const { Vendor } = this.tenancy.models(tenantId);
+
+    return Vendor.query().onBuild((q) => {
+      q.orderBy('displayName');
+
+      if (!isEmpty(vendorsIds)) {
+        q.whereIn('id', vendorsIds);
+      }
+    });
+  }
+
+  /**
+   * Retrieve the accounts receivable.
+   * @param {number} tenantId
+   * @returns {Promise<IAccount[]>}
+   */
+  private async getPayableAccounts(tenantId: number): Promise<IAccount[]> {
+    const { Account } = this.tenancy.models(tenantId);
+
+    const accounts = await Account.query().where(
+      'accountType',
+      ACCOUNT_TYPE.ACCOUNTS_PAYABLE
+    );
+    return accounts;
+  }
+
+  /**
+   * Retrieve the customers opening balance transactions.
+   * @param {number} tenantId
+   * @param {number} openingDate
+   * @param {number} customersIds
+   * @returns {}
+   */
+  public async getVendorsOpeningBalance(
+    tenantId: number,
+    openingDate: Date,
+    customersIds?: number[]
+  ): Promise<IAccountTransaction[]> {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+
+    const payableAccounts = await this.getPayableAccounts(tenantId);
+    const payableAccountsIds = map(payableAccounts, 'id');
+
+    const openingTransactions = await AccountTransaction.query().modify(
+      'contactsOpeningBalance',
+      openingDate,
+      payableAccountsIds,
+      customersIds
+    );
+    return openingTransactions;
+  }
+
+  /**
+   * Retrieve vendors periods transactions.
+   * @param {number} tenantId
+   * @param {Date|string} openingDate
+   * @param {number[]} customersIds
+   */
+  public async getVendorsPeriodTransactions(
+    tenantId: number,
+    fromDate: Date,
+    toDate: Date
+  ): Promise<IAccountTransaction[]> {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+
+    const receivableAccounts = await this.getPayableAccounts(tenantId);
+    const receivableAccountsIds = map(receivableAccounts, 'id');
+
+    const transactions = await AccountTransaction.query().onBuild((query) => {
+      // Filter by date.
+      query.modify('filterDateRange', fromDate, toDate);
+
+      // Filter by customers.
+      query.whereNot('contactId', null);
+
+      // Filter by accounts.
+      query.whereIn('accountId', receivableAccountsIds);
+    });
+    return transactions;
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/TransactionsByVendor/TransactionsByVendorService.ts b/packages/server/src/services/FinancialStatements/TransactionsByVendor/TransactionsByVendorService.ts
new file mode 100644
index 000000000..18be5b7ed
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/TransactionsByVendor/TransactionsByVendorService.ts
@@ -0,0 +1,178 @@
+import { Inject } from 'typedi';
+import moment from 'moment';
+import * as R from 'ramda';
+import { map } from 'lodash';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import {
+  ITransactionsByVendorsService,
+  ITransactionsByVendorsFilter,
+  ITransactionsByVendorsStatement,
+  ILedgerEntry,
+} from '@/interfaces';
+import TransactionsByVendor from './TransactionsByVendor';
+import Ledger from '@/services/Accounting/Ledger';
+import TransactionsByVendorRepository from './TransactionsByVendorRepository';
+import { Tenant } from '@/system/models';
+
+export default class TransactionsByVendorsService
+  implements ITransactionsByVendorsService
+{
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  reportRepository: TransactionsByVendorRepository;
+
+  /**
+   * Defaults balance sheet filter query.
+   * @return {IVendorBalanceSummaryQuery}
+   */
+  get defaultQuery(): ITransactionsByVendorsFilter {
+    return {
+      fromDate: moment().format('YYYY-MM-DD'),
+      toDate: moment().format('YYYY-MM-DD'),
+      numberFormat: {
+        precision: 2,
+        divideOn1000: false,
+        showZero: false,
+        formatMoney: 'total',
+        negativeFormat: 'mines',
+      },
+      comparison: {
+        percentageOfColumn: true,
+      },
+      noneZero: false,
+      noneTransactions: true,
+      vendorsIds: [],
+    };
+  }
+
+  /**
+   * Retrieve the customers opening balance transactions.
+   * @param {number} tenantId
+   * @param {number} openingDate
+   * @param {number} customersIds
+   * @returns {Promise<ILedgerEntry[]>}
+   */
+  private async getVendorsOpeningBalanceEntries(
+    tenantId: number,
+    openingDate: Date,
+    customersIds?: number[]
+  ): Promise<ILedgerEntry[]> {
+    const openingTransactions =
+      await this.reportRepository.getVendorsOpeningBalance(
+        tenantId,
+        openingDate,
+        customersIds
+      );
+    return R.compose(
+      R.map(R.assoc('date', openingDate)),
+      R.map(R.assoc('accountNormal', 'credit'))
+    )(openingTransactions);
+  }
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {Date|string} openingDate
+   * @param {number[]} customersIds
+   */
+  private async getVendorsPeriodEntries(
+    tenantId: number,
+    fromDate: Date,
+    toDate: Date
+  ): Promise<ILedgerEntry[]> {
+    const transactions =
+      await this.reportRepository.getVendorsPeriodTransactions(
+        tenantId,
+        fromDate,
+        toDate
+      );
+    return R.compose(
+      R.map(R.assoc('accountNormal', 'credit')),
+      R.map((trans) => ({
+        ...trans,
+        referenceTypeFormatted: trans.referenceTypeFormatted,
+      }))
+    )(transactions);
+  }
+
+  /**
+   * Retrieve the report ledger entries from repository.
+   * @param {number} tenantId
+   * @param {Date} fromDate
+   * @param {Date} toDate
+   * @returns {Promise<ILedgerEntry[]>}
+   */
+  private async getReportEntries(
+    tenantId: number,
+    fromDate: Date,
+    toDate: Date
+  ): Promise<ILedgerEntry[]> {
+    const openingBalanceDate = moment(fromDate).subtract(1, 'days').toDate();
+
+    return [
+      ...(await this.getVendorsOpeningBalanceEntries(
+        tenantId,
+        openingBalanceDate
+      )),
+      ...(await this.getVendorsPeriodEntries(tenantId, fromDate, toDate)),
+    ];
+  }
+
+  /**
+   * Retrieve transactions by by the customers.
+   * @param {number} tenantId
+   * @param {ITransactionsByVendorsFilter} query
+   * @return {Promise<ITransactionsByVendorsStatement>}
+   */
+  public async transactionsByVendors(
+    tenantId: number,
+    query: ITransactionsByVendorsFilter
+  ): Promise<ITransactionsByVendorsStatement> {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    const i18n = this.tenancy.i18n(tenantId);
+ 
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const filter = { ...this.defaultQuery, ...query };
+
+    // Retrieve the report vendors.
+    const vendors = await this.reportRepository.getVendors(
+      tenantId,
+      filter.vendorsIds
+    );
+    // Retrieve the accounts graph.
+    const accountsGraph = await accountRepository.getDependencyGraph();
+
+    // Journal transactions.
+    const reportEntries = await this.getReportEntries(
+      tenantId,
+      filter.fromDate,
+      filter.toDate
+    );
+    // Ledger collection.
+    const journal = new Ledger(reportEntries);
+
+    // Transactions by customers data mapper.
+    const reportInstance = new TransactionsByVendor(
+      vendors,
+      accountsGraph,
+      journal,
+      filter,
+      tenant.metadata.baseCurrency,
+      i18n
+    );
+    return {
+      data: reportInstance.reportData(),
+      columns: reportInstance.reportColumns(),
+      query: filter,
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/TransactionsByVendor/TransactionsByVendorTableRows.ts b/packages/server/src/services/FinancialStatements/TransactionsByVendor/TransactionsByVendorTableRows.ts
new file mode 100644
index 000000000..e37eeb8fe
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/TransactionsByVendor/TransactionsByVendorTableRows.ts
@@ -0,0 +1,76 @@
+import * as R from 'ramda';
+import { tableRowMapper } from 'utils';
+import { ITransactionsByVendorsVendor, ITableRow } from '@/interfaces';
+import TransactionsByContactsTableRows from '../TransactionsByContact/TransactionsByContactTableRows';
+
+enum ROW_TYPE {
+  OPENING_BALANCE = 'OPENING_BALANCE',
+  CLOSING_BALANCE = 'CLOSING_BALANCE',
+  TRANSACTION = 'TRANSACTION',
+  VENDOR = 'VENDOR',
+}
+
+export default class TransactionsByVendorsTableRows extends TransactionsByContactsTableRows {
+  vendorsTransactions: ITransactionsByVendorsVendor[];
+
+  /**
+   * Constructor method.
+   */
+  constructor(
+    vendorsTransactions: ITransactionsByVendorsVendor[],
+    i18n
+  ) {
+    super();
+
+    this.vendorsTransactions = vendorsTransactions;
+    this.i18n = i18n;
+  }
+
+  /**
+   * Retrieve the table row of vendor details.
+   * @param {ITransactionsByVendorsVendor} vendor -
+   * @returns {ITableRow[]}
+   */
+  private vendorDetails = (vendor: ITransactionsByVendorsVendor) => {
+    const columns = [
+      { key: 'vendorName', accessor: 'vendorName' },
+      ...R.repeat({ key: 'empty', value: '' }, 5),
+      {
+        key: 'closingBalanceValue',
+        accessor: 'closingBalance.formattedAmount',
+      },
+    ];
+
+    return {
+      ...tableRowMapper(vendor, columns, { rowTypes: [ROW_TYPE.VENDOR] }),
+      children: R.pipe(
+        R.when(
+          R.always(vendor.transactions.length > 0),
+          R.pipe(
+            R.concat(this.contactTransactions(vendor)),
+            R.prepend(this.contactOpeningBalance(vendor))
+          )
+        ),
+        R.append(this.contactClosingBalance(vendor))
+      )([]),
+    };
+  };
+
+  /**
+   * Retrieve the table rows of the vendor section.
+   * @param {ITransactionsByVendorsVendor} vendor
+   * @returns {ITableRow[]}
+   */
+  private vendorRowsMapper = (vendor: ITransactionsByVendorsVendor) => {
+    return R.pipe(this.vendorDetails)(vendor);
+  };
+
+  /**
+   * Retrieve the table rows of transactions by vendors report.
+   * @param {ITransactionsByVendorsVendor[]} vendors
+   * @returns {ITableRow[]}
+   */
+  public tableRows = (): ITableRow[] => {
+    return R.map(this.vendorRowsMapper)(this.vendorsTransactions);
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/TrialBalanceSheet/TrialBalanceSheet.ts b/packages/server/src/services/FinancialStatements/TrialBalanceSheet/TrialBalanceSheet.ts
new file mode 100644
index 000000000..980bd1dd4
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/TrialBalanceSheet/TrialBalanceSheet.ts
@@ -0,0 +1,214 @@
+import { sumBy } from 'lodash';
+import * as R from 'ramda';
+import {
+  ITrialBalanceSheetQuery,
+  ITrialBalanceAccount,
+  IAccount,
+  ITrialBalanceTotal,
+  ITrialBalanceSheetData,
+  IAccountType,
+} from '@/interfaces';
+import FinancialSheet from '../FinancialSheet';
+import { allPassedConditionsPass, flatToNestedArray } from 'utils';
+
+export default class TrialBalanceSheet extends FinancialSheet {
+  tenantId: number;
+  query: ITrialBalanceSheetQuery;
+  accounts: IAccount & { type: IAccountType }[];
+  journalFinancial: any;
+  baseCurrency: string;
+
+  /**
+   * Constructor method.
+   * @param {number} tenantId
+   * @param {ITrialBalanceSheetQuery} query
+   * @param {IAccount[]} accounts
+   * @param journalFinancial
+   */
+  constructor(
+    tenantId: number,
+    query: ITrialBalanceSheetQuery,
+    accounts: IAccount & { type: IAccountType }[],
+    journalFinancial: any,
+    baseCurrency: string
+  ) {
+    super();
+
+    this.tenantId = tenantId;
+    this.query = query;
+    this.accounts = accounts;
+    this.journalFinancial = journalFinancial;
+    this.numberFormat = this.query.numberFormat;
+    this.baseCurrency = baseCurrency;
+  }
+
+  /**
+   * Account mapper.
+   * @param {IAccount} account
+   * @return {ITrialBalanceAccount}
+   */
+  private accountTransformer = (
+    account: IAccount & { type: IAccountType }
+  ): ITrialBalanceAccount => {
+    const trial = this.journalFinancial.getTrialBalanceWithDepands(account.id);
+
+    return {
+      id: account.id,
+      parentAccountId: account.parentAccountId,
+      name: account.name,
+      code: account.code,
+      accountNormal: account.accountNormal,
+
+      credit: trial.credit,
+      debit: trial.debit,
+      balance: trial.balance,
+      currencyCode: this.baseCurrency,
+
+      formattedCredit: this.formatNumber(trial.credit),
+      formattedDebit: this.formatNumber(trial.debit),
+      formattedBalance: this.formatNumber(trial.balance),
+    };
+  };
+
+  /**
+   * Filters trial balance sheet accounts nodes based on the given report query.
+   * @param {ITrialBalanceAccount} accountNode
+   * @returns {boolean}
+   */
+  private accountFilter = (accountNode: ITrialBalanceAccount): boolean => {
+    const { noneTransactions, noneZero, onlyActive } = this.query;
+
+    // Conditions pair filter detarminer.
+    const condsPairFilters = [
+      [noneTransactions, this.filterNoneTransactions],
+      [noneZero, this.filterNoneZero],
+      [onlyActive, this.filterActiveOnly],
+    ];
+    return allPassedConditionsPass(condsPairFilters)(accountNode);
+  };
+
+  /**
+   * Fitlers the accounts nodes.
+   * @param {ITrialBalanceAccount[]} accountsNodes
+   * @returns {ITrialBalanceAccount[]}
+   */
+  private accountsFilter = (
+    accountsNodes: ITrialBalanceAccount[]
+  ): ITrialBalanceAccount[] => {
+    return accountsNodes.filter(this.accountFilter);
+  };
+
+  /**
+   * Mappes the given account object to trial balance account node.
+   * @param {IAccount[]} accountsNodes
+   * @returns {ITrialBalanceAccount[]}
+   */
+  private accountsMapper = (
+    accountsNodes: IAccount[]
+  ): ITrialBalanceAccount[] => {
+    return accountsNodes.map(this.accountTransformer);
+  };
+
+  /**
+   * Detarmines whether the given account node is not none transactions.
+   * @param {ITrialBalanceAccount} accountNode
+   * @returns {boolean}
+   */
+  private filterNoneTransactions = (
+    accountNode: ITrialBalanceAccount
+  ): boolean => {
+    const entries = this.journalFinancial.getAccountEntriesWithDepents(
+      accountNode.id
+    );
+    return entries.length > 0;
+  };
+
+  /**
+   * Detarmines whether the given account none zero.
+   * @param {ITrialBalanceAccount} accountNode
+   * @returns {boolean}
+   */
+  private filterNoneZero = (accountNode: ITrialBalanceAccount): boolean => {
+    return accountNode.balance !== 0;
+  };
+
+  /**
+   * Detarmines whether the given account is active.
+   * @param {ITrialBalanceAccount} accountNode
+   * @returns {boolean}
+   */
+  private filterActiveOnly = (accountNode: ITrialBalanceAccount): boolean => {
+    return accountNode.credit !== 0 || accountNode.debit !== 0;
+  };
+
+  /**
+   * Transformes the flatten nodes to nested nodes.
+   * @param {ITrialBalanceAccount[]} flattenAccounts
+   * @returns {ITrialBalanceAccount[]}
+   */
+  private nestedAccountsNode = (
+    flattenAccounts: ITrialBalanceAccount[]
+  ): ITrialBalanceAccount[] => {
+    return flatToNestedArray(flattenAccounts, {
+      id: 'id',
+      parentId: 'parentAccountId',
+    });
+  };
+
+  /**
+   * Retrieve trial balance total section.
+   * @param {ITrialBalanceAccount[]} accountsBalances
+   * @return {ITrialBalanceTotal}
+   */
+  private tatalSection(
+    accountsBalances: ITrialBalanceAccount[]
+  ): ITrialBalanceTotal {
+    const credit = sumBy(accountsBalances, 'credit');
+    const debit = sumBy(accountsBalances, 'debit');
+    const balance = sumBy(accountsBalances, 'balance');
+    const currencyCode = this.baseCurrency;
+
+    return {
+      credit,
+      debit,
+      balance,
+      currencyCode,
+      formattedCredit: this.formatTotalNumber(credit),
+      formattedDebit: this.formatTotalNumber(debit),
+      formattedBalance: this.formatTotalNumber(balance),
+    };
+  }
+
+  /**
+   * Retrieve accounts section of trial balance report.
+   * @param {IAccount[]} accounts
+   * @returns {ITrialBalanceAccount[]}
+   */
+  private accountsSection(accounts: IAccount & { type: IAccountType }[]) {
+    return R.compose(
+      this.nestedAccountsNode,
+      this.accountsFilter,
+      this.accountsMapper
+    )(accounts);
+  }
+
+  /**
+   * Retrieve trial balance sheet statement data.
+   * Note: Retruns null in case there is no transactions between the given date periods.
+   *
+   * @return {ITrialBalanceSheetData}
+   */
+  public reportData(): ITrialBalanceSheetData {
+    // Don't return noting if the journal has no transactions.
+    if (this.journalFinancial.isEmpty()) {
+      return null;
+    }
+    // Retrieve accounts nodes.
+    const accounts = this.accountsSection(this.accounts);
+
+    // Retrieve account node.
+    const total = this.tatalSection(accounts);
+
+    return { accounts, total };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/TrialBalanceSheet/TrialBalanceSheetService.ts b/packages/server/src/services/FinancialStatements/TrialBalanceSheet/TrialBalanceSheetService.ts
new file mode 100644
index 000000000..bf7b9e611
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/TrialBalanceSheet/TrialBalanceSheetService.ts
@@ -0,0 +1,136 @@
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import Journal from '@/services/Accounting/JournalPoster';
+import { ITrialBalanceSheetMeta, ITrialBalanceSheetQuery, ITrialBalanceStatement } from '@/interfaces';
+import TrialBalanceSheet from './TrialBalanceSheet';
+import FinancialSheet from '../FinancialSheet';
+import InventoryService from '@/services/Inventory/Inventory';
+import { parseBoolean } from 'utils';
+import { Tenant } from '@/system/models';
+
+@Service()
+export default class TrialBalanceSheetService extends FinancialSheet {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  inventoryService: InventoryService;
+
+  @Inject('logger')
+  logger: any;
+
+  /**
+   * Defaults trial balance sheet filter query.
+   * @return {IBalanceSheetQuery}
+   */
+  get defaultQuery(): ITrialBalanceSheetQuery {
+    return {
+      fromDate: moment().startOf('year').format('YYYY-MM-DD'),
+      toDate: moment().endOf('year').format('YYYY-MM-DD'),
+      numberFormat: {
+        divideOn1000: false,
+        negativeFormat: 'mines',
+        showZero: false,
+        formatMoney: 'total',
+        precision: 2,
+      },
+      basis: 'accural',
+      noneZero: false,
+      noneTransactions: true,
+      onlyActive: false,
+      accountIds: [],
+    };
+  }
+
+  /**
+   * Retrieve the trial balance sheet meta.
+   * @param {number} tenantId - Tenant id.
+   * @returns {ITrialBalanceSheetMeta}
+   */
+  reportMetadata(tenantId: number): ITrialBalanceSheetMeta {
+    const settings = this.tenancy.settings(tenantId);
+
+    const isCostComputeRunning = this.inventoryService.isItemsCostComputeRunning(
+      tenantId
+    );
+    const organizationName = settings.get({
+      group: 'organization',
+      key: 'name',
+    });
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+
+    return {
+      isCostComputeRunning: parseBoolean(isCostComputeRunning, false),
+      organizationName,
+      baseCurrency,
+    };
+  }
+
+  /**
+   * Retrieve trial balance sheet statement.
+   * -------------
+   * @param {number} tenantId
+   * @param {IBalanceSheetQuery} query
+   *
+   * @return {IBalanceSheetStatement}
+   */
+  public async trialBalanceSheet(
+    tenantId: number,
+    query: ITrialBalanceSheetQuery
+  ): Promise<ITrialBalanceStatement> {
+    const filter = {
+      ...this.defaultQuery,
+      ...query,
+    };
+    const {
+      accountRepository,
+      transactionsRepository,
+    } = this.tenancy.repositories(tenantId);
+
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    this.logger.info('[trial_balance_sheet] trying to calcualte the report.', {
+      tenantId,
+      filter,
+    });
+    // Retrieve all accounts on the storage.
+    const accounts = await accountRepository.all();
+    const accountsGraph = await accountRepository.getDependencyGraph();
+
+    // Retrieve all journal transactions based on the given query.
+    const transactions = await transactionsRepository.journal({
+      fromDate: query.fromDate,
+      toDate: query.toDate,
+      sumationCreditDebit: true,
+      branchesIds: query.branchesIds
+    });
+    // Transform transactions array to journal collection.
+    const transactionsJournal = Journal.fromTransactions(
+      transactions,
+      tenantId,
+      accountsGraph
+    );
+    // Trial balance report instance.
+    const trialBalanceInstance = new TrialBalanceSheet(
+      tenantId,
+      filter,
+      accounts,
+      transactionsJournal,
+      tenant.metadata.baseCurrency,
+    );
+    // Trial balance sheet data.
+    const trialBalanceSheetData = trialBalanceInstance.reportData();
+
+    return {
+      data: trialBalanceSheetData,
+      query: filter,
+      meta: this.reportMetadata(tenantId),
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/VendorBalanceSummary/VendorBalanceSummary.ts b/packages/server/src/services/FinancialStatements/VendorBalanceSummary/VendorBalanceSummary.ts
new file mode 100644
index 000000000..1d84d593f
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/VendorBalanceSummary/VendorBalanceSummary.ts
@@ -0,0 +1,108 @@
+import * as R from 'ramda';
+import { isEmpty } from 'lodash';
+import {
+  ILedger,
+  IVendor,
+  IVendorBalanceSummaryVendor,
+  IVendorBalanceSummaryQuery,
+  IVendorBalanceSummaryData,
+  INumberFormatQuery,
+} from '@/interfaces';
+import { ContactBalanceSummaryReport } from '../ContactBalanceSummary/ContactBalanceSummary';
+
+export class VendorBalanceSummaryReport extends ContactBalanceSummaryReport {
+  readonly ledger: ILedger;
+  readonly baseCurrency: string;
+  readonly vendors: IVendor[];
+  readonly filter: IVendorBalanceSummaryQuery;
+  readonly numberFormat: INumberFormatQuery;
+
+  /**
+   * Constructor method.
+   * @param {IJournalPoster} receivableLedger
+   * @param {IVendor[]} vendors
+   * @param {IVendorBalanceSummaryQuery} filter
+   * @param {string} baseCurrency
+   */
+  constructor(
+    ledger: ILedger,
+    vendors: IVendor[],
+    filter: IVendorBalanceSummaryQuery,
+    baseCurrency: string
+  ) {
+    super();
+
+    this.ledger = ledger;
+    this.baseCurrency = baseCurrency;
+    this.vendors = vendors;
+    this.filter = filter;
+    this.numberFormat = this.filter.numberFormat;
+  }
+
+  /**
+   * Customer section mapper.
+   * @param   {IVendor} vendor
+   * @returns {IVendorBalanceSummaryVendor}
+   */
+  private vendorMapper = (vendor: IVendor): IVendorBalanceSummaryVendor => {
+    const closingBalance = this.ledger
+      .whereContactId(vendor.id)
+      .getClosingBalance();
+
+    return {
+      id: vendor.id,
+      vendorName: vendor.displayName,
+      total: this.getContactTotalFormat(closingBalance),
+    };
+  };
+
+  /**
+   * Mappes the vendor model object to vendor balance summary section.
+   * @param   {IVendor[]} vendors - Customers.
+   * @returns {IVendorBalanceSummaryVendor[]}
+   */
+  private vendorsMapper = (
+    vendors: IVendor[]
+  ): IVendorBalanceSummaryVendor[] => {
+    return vendors.map(this.vendorMapper);
+  };
+
+  /**
+   * Detarmines whether the vendors post filter is active.
+   * @returns {boolean}
+   */
+  private isVendorsPostFilter = (): boolean => {
+    return isEmpty(this.filter.vendorsIds);
+  };
+
+  /**
+   * Retrieve the vendors sections of the report.
+   * @param   {IVendor} vendors
+   * @returns {IVendorBalanceSummaryVendor[]}
+   */
+  private getVendorsSection(vendors: IVendor[]): IVendorBalanceSummaryVendor[] {
+    return R.compose(
+      R.when(this.isVendorsPostFilter, this.contactsFilter),
+      R.when(
+        R.always(this.filter.percentageColumn),
+        this.contactCamparsionPercentageOfColumn
+      ),
+      this.vendorsMapper
+    )(vendors);
+  }
+
+  /**
+   * Retrieve the report statement data.
+   * @returns {IVendorBalanceSummaryData}
+   */
+  public reportData(): IVendorBalanceSummaryData {
+    const vendors = this.getVendorsSection(this.vendors);
+    const total = this.getContactsTotalSection(vendors);
+
+    return { vendors, total };
+  }
+
+  reportColumns() {
+    return [];
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/VendorBalanceSummary/VendorBalanceSummaryRepository.ts b/packages/server/src/services/FinancialStatements/VendorBalanceSummary/VendorBalanceSummaryRepository.ts
new file mode 100644
index 000000000..a8d67089d
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/VendorBalanceSummary/VendorBalanceSummaryRepository.ts
@@ -0,0 +1,69 @@
+import { Inject, Service } from 'typedi';
+import { isEmpty, map } from 'lodash';
+import { IVendor, IAccount } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ACCOUNT_TYPE } from '@/data/AccountTypes';
+
+@Service()
+export default class VendorBalanceSummaryRepository {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve the report vendors.
+   * @param {number} tenantId
+   * @param {number[]} vendorsIds - Vendors ids.
+   * @returns {IVendor[]}
+   */
+  public getVendors(
+    tenantId: number,
+    vendorsIds?: number[]
+  ): Promise<IVendor[]> {
+    const { Vendor } = this.tenancy.models(tenantId);
+
+    const vendorQuery = Vendor.query().orderBy('displayName');
+
+    if (!isEmpty(vendorsIds)) {
+      vendorQuery.whereIn('id', vendorsIds);
+    }
+    return vendorQuery;
+  }
+
+  /**
+   * Retrieve the payable accounts.
+   * @param {number} tenantId
+   * @returns {Promise<IAccount[]>}
+   */
+  public getPayableAccounts(tenantId: number): Promise<IAccount[]> {
+    const { Account } = this.tenancy.models(tenantId);
+
+    return Account.query().where('accountType', ACCOUNT_TYPE.ACCOUNTS_PAYABLE);
+  }
+
+  /**
+   * Retrieve the vendors transactions.
+   * @param {number} tenantId
+   * @param {Date} asDate
+   * @returns
+   */
+  public async getVendorsTransactions(tenantId: number, asDate: Date | string) {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+
+    // Retrieve payable accounts .
+    const payableAccounts = await this.getPayableAccounts(tenantId);
+    const payableAccountsIds = map(payableAccounts, 'id');
+
+    // Retrieve the customers transactions of A/R accounts.
+    const customersTranasctions = await AccountTransaction.query().onBuild(
+      (query) => {
+        query.whereIn('accountId', payableAccountsIds);
+        query.modify('filterDateRange', null, asDate);
+        query.groupBy('contactId');
+        query.sum('credit as credit');
+        query.sum('debit as debit');
+        query.select('contactId');
+      }
+    );
+    return customersTranasctions;
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/VendorBalanceSummary/VendorBalanceSummaryService.ts b/packages/server/src/services/FinancialStatements/VendorBalanceSummary/VendorBalanceSummaryService.ts
new file mode 100644
index 000000000..82dc0475d
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/VendorBalanceSummary/VendorBalanceSummaryService.ts
@@ -0,0 +1,118 @@
+import { Inject } from 'typedi';
+import moment from 'moment';
+import { map } from 'lodash';
+import * as R from 'ramda';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import {
+  IVendor,
+  IVendorBalanceSummaryService,
+  IVendorBalanceSummaryQuery,
+  IVendorBalanceSummaryStatement,
+  ILedgerEntry,
+} from '@/interfaces';
+import { VendorBalanceSummaryReport } from './VendorBalanceSummary';
+import Ledger from '@/services/Accounting/Ledger';
+import VendorBalanceSummaryRepository from './VendorBalanceSummaryRepository';
+import { Tenant } from '@/system/models';
+
+export default class VendorBalanceSummaryService
+  implements IVendorBalanceSummaryService
+{
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  reportRepo: VendorBalanceSummaryRepository;
+
+  /**
+   * Defaults balance sheet filter query.
+   * @return {IVendorBalanceSummaryQuery}
+   */
+  get defaultQuery(): IVendorBalanceSummaryQuery {
+    return {
+      asDate: moment().format('YYYY-MM-DD'),
+      numberFormat: {
+        precision: 2,
+        divideOn1000: false,
+        showZero: false,
+        formatMoney: 'total',
+        negativeFormat: 'mines',
+      },
+      percentageColumn: false,
+      noneZero: false,
+      noneTransactions: true,
+    };
+  }
+
+  /**
+   * Retrieve the vendors ledger entrjes.
+   * @param {number} tenantId -
+   * @param {Date|string} date -
+   * @returns {Promise<ILedgerEntry>}
+   */
+  private async getReportVendorsEntries(
+    tenantId: number,
+    date: Date | string
+  ): Promise<ILedgerEntry[]> {
+    const transactions = await this.reportRepo.getVendorsTransactions(
+      tenantId,
+      date
+    );
+    const commonProps = { accountNormal: 'credit' };
+
+    return R.map(R.merge(commonProps))(transactions);
+  }
+
+  /**
+   * Retrieve the statment of customer balance summary report.
+   * @param {number} tenantId - Tenant id.
+   * @param {IVendorBalanceSummaryQuery} query -
+   * @return {Promise<IVendorBalanceSummaryStatement>}
+   */
+  async vendorBalanceSummary(
+    tenantId: number,
+    query: IVendorBalanceSummaryQuery
+  ): Promise<IVendorBalanceSummaryStatement> {
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const filter = { ...this.defaultQuery, ...query };
+    this.logger.info(
+      '[customer_balance_summary] trying to calculate the report.',
+      {
+        filter,
+        tenantId,
+      }
+    );
+    // Retrieve the vendors transactions.
+    const vendorsEntries = await this.getReportVendorsEntries(
+      tenantId,
+      query.asDate
+    );
+    // Retrieve the customers list ordered by the display name.
+    const vendors = await this.reportRepo.getVendors(
+      tenantId,
+      query.vendorsIds
+    );
+    // Ledger query.
+    const vendorsLedger = new Ledger(vendorsEntries);
+
+    // Report instance.
+    const reportInstance = new VendorBalanceSummaryReport(
+      vendorsLedger,
+      vendors,
+      filter,
+      tenant.metadata.baseCurrency
+    );
+
+    return {
+      data: reportInstance.reportData(),
+      columns: reportInstance.reportColumns(),
+      query: filter,
+    };
+  }
+}
diff --git a/packages/server/src/services/FinancialStatements/VendorBalanceSummary/VendorBalanceSummaryTableRows.ts b/packages/server/src/services/FinancialStatements/VendorBalanceSummary/VendorBalanceSummaryTableRows.ts
new file mode 100644
index 000000000..d65ced56e
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/VendorBalanceSummary/VendorBalanceSummaryTableRows.ts
@@ -0,0 +1,150 @@
+import * as R from 'ramda';
+import { tableMapper, tableRowMapper } from 'utils';
+import {
+  IVendorBalanceSummaryData,
+  IVendorBalanceSummaryVendor,
+  IVendorBalanceSummaryTotal,
+  ITableRow,
+  IColumnMapperMeta,
+  IVendorBalanceSummaryQuery,
+  ITableColumn,
+} from '@/interfaces';
+
+enum TABLE_ROWS_TYPES {
+  VENDOR = 'VENDOR',
+  TOTAL = 'TOTAL',
+}
+
+export default class VendorBalanceSummaryTable {
+  i18n: any;
+  report: IVendorBalanceSummaryData;
+  query: IVendorBalanceSummaryQuery;
+
+  /**
+   * Constructor method.
+   * @param {IVendorBalanceSummaryData} report
+   * @param i18n
+   */
+  constructor(
+    report: IVendorBalanceSummaryData,
+    query: IVendorBalanceSummaryQuery,
+    i18n
+  ) {
+    this.report = report;
+    this.query = query;
+    this.i18n = i18n;
+  }
+
+  /**
+   * Retrieve percentage columns accessor.
+   * @returns {IColumnMapperMeta[]}
+   */
+  private getPercentageColumnsAccessor = (): IColumnMapperMeta[] => {
+    return [
+      {
+        key: 'percentageOfColumn',
+        accessor: 'percentageOfColumn.formattedAmount',
+      },
+    ];
+  };
+
+  /**
+   * Retrieve vendor node columns accessor.
+   * @returns {IColumnMapperMeta[]}
+   */
+  private getVendorColumnsAccessor = (): IColumnMapperMeta[] => {
+    const columns = [
+      { key: 'vendorName', accessor: 'vendorName' },
+      { key: 'total', accessor: 'total.formattedAmount' },
+    ];
+    return R.compose(
+      R.concat(columns),
+      R.when(
+        R.always(this.query.percentageColumn),
+        R.concat(this.getPercentageColumnsAccessor())
+      )
+    )([]);
+  };
+
+  /**
+   * Transformes the vendors to table rows.
+   * @param   {IVendorBalanceSummaryVendor[]} vendors
+   * @returns {ITableRow[]}
+   */
+  private vendorsTransformer = (
+    vendors: IVendorBalanceSummaryVendor[]
+  ): ITableRow[] => {
+    const columns = this.getVendorColumnsAccessor();
+
+    return tableMapper(vendors, columns, {
+      rowTypes: [TABLE_ROWS_TYPES.VENDOR],
+    });
+  };
+
+  /**
+   * Retrieve total node columns accessor.
+   * @returns {IColumnMapperMeta[]}
+   */
+  private getTotalColumnsAccessor = (): IColumnMapperMeta[] => {
+    const columns = [
+      { key: 'total', value: this.i18n.__('Total') },
+      { key: 'total', accessor: 'total.formattedAmount' },
+    ];
+    return R.compose(
+      R.concat(columns),
+      R.when(
+        R.always(this.query.percentageColumn),
+        R.concat(this.getPercentageColumnsAccessor())
+      )
+    )([]);
+  };
+
+  /**
+   * Transformes the total to table row.
+   * @param   {IVendorBalanceSummaryTotal} total
+   * @returns {ITableRow}
+   */
+  private totalTransformer = (total: IVendorBalanceSummaryTotal): ITableRow => {
+    const columns = this.getTotalColumnsAccessor();
+
+    return tableRowMapper(total, columns, {
+      rowTypes: [TABLE_ROWS_TYPES.TOTAL],
+    });
+  };
+
+  /**
+   * Transformes the vendor balance summary to table rows.
+   * @param {IVendorBalanceSummaryData} vendorBalanceSummary
+   * @returns {ITableRow[]}
+   */
+  public tableRows = (): ITableRow[] => {
+    const vendors = this.vendorsTransformer(this.report.vendors);
+    const total = this.totalTransformer(this.report.total);
+
+    return vendors.length > 0 ? [...vendors, total] : [];
+  };
+
+  /**
+   * Retrieve the report statement columns
+   * @returns {ITableColumn[]}
+   */
+  public tableColumns = (): ITableColumn[] => {
+    const columns = [
+      {
+        key: 'name',
+        label: this.i18n.__('contact_summary_balance.account_name'),
+      },
+      { key: 'total', label: this.i18n.__('contact_summary_balance.total') },
+    ];
+    return R.compose(
+      R.when(
+        R.always(this.query.percentageColumn),
+        R.append({
+          key: 'percentage_of_column',
+          label: this.i18n.__('contact_summary_balance.percentage_column'),
+        })
+      ),
+      R.concat(columns)
+    )([]);
+  };
+}
diff --git a/packages/server/src/services/FinancialStatements/utils.ts b/packages/server/src/services/FinancialStatements/utils.ts
new file mode 100644
index 000000000..1114131b9
--- /dev/null
+++ b/packages/server/src/services/FinancialStatements/utils.ts
@@ -0,0 +1,13 @@
+
+
+export const formatNumber = (balance, { noCents, divideOn1000 }): string => {
+  let formattedBalance: number = parseFloat(balance);
+
+  if (noCents) {
+    formattedBalance = parseInt(formattedBalance, 10);
+  }
+  if (divideOn1000) {
+    formattedBalance /= 1000;
+  }
+  return formattedBalance;
+};
\ No newline at end of file
diff --git a/packages/server/src/services/I18n/I18nService.ts b/packages/server/src/services/I18n/I18nService.ts
new file mode 100644
index 000000000..e7771b15f
--- /dev/null
+++ b/packages/server/src/services/I18n/I18nService.ts
@@ -0,0 +1,66 @@
+import * as R from 'ramda';
+import { isUndefined } from 'lodash';
+import * as qim from 'qim';
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export default class I18nService {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * 
+   * @param i18n 
+   * @param attributes 
+   * @param data 
+   * @returns 
+   */
+  private i18nAttributesMapper(i18n, attributes, data) {
+    return attributes.reduce((acc, attr, index) => {
+      return {
+        ...acc,
+        [attr]: i18n.__(acc[attr]),
+      };
+    }, data);
+  }
+
+  /**
+   * Mappes array collection to i18n localization based in given attributes.
+   * @param {Array<any>} data - Array collection.
+   * @param {string[]} attributes - Attributes.
+   * @param {number} tenantId - Tenant id.
+   */
+  public i18nMapper(
+    data: Array<any>,
+    attributes: string[] = [],
+    tenantId: number
+  ) {
+    const i18n = this.tenancy.i18n(tenantId);
+
+    return data.map((_data) => {
+      const newData = this.i18nAttributesMapper(i18n, attributes, _data);
+
+      return {
+        ..._data,
+        ...newData,
+      };
+    });
+  }
+
+  public i18nApply(
+    paths: (string|Function)[][],
+    data: Array<any>,
+    tenantId: number,
+  ) {
+    const i18n = this.tenancy.i18n(tenantId);
+    const applyCurry = R.curryN(3, qim.apply);
+    const transformedData = !isUndefined(data.toJSON) ? data.toJSON() : data;
+
+    const transform = (value) => i18n.__(value) || value;
+
+    const curriedCallbacks = paths.map((path) => applyCurry(path, transform));
+
+    return R.compose(...curriedCallbacks)(transformedData);
+  }
+}
diff --git a/packages/server/src/services/Inventory/Inventory.ts b/packages/server/src/services/Inventory/Inventory.ts
new file mode 100644
index 000000000..c5ec78dee
--- /dev/null
+++ b/packages/server/src/services/Inventory/Inventory.ts
@@ -0,0 +1,377 @@
+import { Container, Service, Inject } from 'typedi';
+import { pick } from 'lodash';
+import config from '@/config';
+import {
+  IInventoryLotCost,
+  IInventoryTransaction,
+  TInventoryTransactionDirection,
+  IItemEntry,
+  IItemEntryTransactionType,
+  IInventoryTransactionsCreatedPayload,
+  IInventoryTransactionsDeletedPayload,
+  IInventoryItemCostScheduledPayload,
+} from '@/interfaces';
+import InventoryAverageCost from '@/services/Inventory/InventoryAverageCost';
+import InventoryCostLotTracker from '@/services/Inventory/InventoryCostLotTracker';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+import { Knex } from 'knex';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+
+type TCostMethod = 'FIFO' | 'LIFO' | 'AVG';
+
+@Service()
+export default class InventoryService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  itemsEntriesService: ItemsEntriesService;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  /**
+   * Transforms the items entries to inventory transactions.
+   */
+  transformItemEntriesToInventory(transaction: {
+    transactionId: number;
+    transactionType: IItemEntryTransactionType;
+    transactionNumber?: string;
+
+    exchangeRate?: number;
+
+    warehouseId: number | null;
+
+    date: Date | string;
+    direction: TInventoryTransactionDirection;
+    entries: IItemEntry[];
+    createdAt: Date;
+  }): IInventoryTransaction[] {
+    const exchangeRate = transaction.exchangeRate || 1;
+
+    return transaction.entries.map((entry: IItemEntry) => ({
+      ...pick(entry, ['itemId', 'quantity']),
+      rate: entry.rate * exchangeRate,
+      transactionType: transaction.transactionType,
+      transactionId: transaction.transactionId,
+      direction: transaction.direction,
+      date: transaction.date,
+      entryId: entry.id,
+      createdAt: transaction.createdAt,
+      costAccountId: entry.costAccountId,
+
+      warehouseId: entry.warehouseId || transaction.warehouseId,
+      meta: {
+        transactionNumber: transaction.transactionNumber,
+        description: entry.description,
+      },
+    }));
+  }
+
+  async computeItemCost(tenantId: number, fromDate: Date, itemId: number) {
+    return this.uow.withTransaction(tenantId, (trx: Knex.Transaction) => {
+      return this.computeInventoryItemCost(tenantId, fromDate, itemId);
+    });
+  }
+
+  /**
+   * Computes the given item cost and records the inventory lots transactions
+   * and journal entries based on the cost method FIFO, LIFO or average cost rate.
+   * @param {number} tenantId - Tenant id.
+   * @param {Date} fromDate - From date.
+   * @param {number} itemId - Item id.
+   */
+  async computeInventoryItemCost(
+    tenantId: number,
+    fromDate: Date,
+    itemId: number,
+    trx?: Knex.Transaction
+  ) {
+    const { Item } = this.tenancy.models(tenantId);
+
+    // Fetches the item with assocaited item category.
+    const item = await Item.query().findById(itemId);
+
+    // Cannot continue if the given item was not inventory item.
+    if (item.type !== 'inventory') {
+      throw new Error('You could not compute item cost has no inventory type.');
+    }
+    let costMethodComputer: IInventoryCostMethod;
+
+    // Switch between methods based on the item cost method.
+    switch ('AVG') {
+      case 'FIFO':
+      case 'LIFO':
+        costMethodComputer = new InventoryCostLotTracker(
+          tenantId,
+          fromDate,
+          itemId
+        );
+        break;
+      case 'AVG':
+        costMethodComputer = new InventoryAverageCost(
+          tenantId,
+          fromDate,
+          itemId,
+          trx
+        );
+        break;
+    }
+    return costMethodComputer.computeItemCost();
+  }
+
+  /**
+   * Schedule item cost compute job.
+   * @param {number} tenantId
+   * @param {number} itemId
+   * @param {Date} startingDate
+   */
+  async scheduleComputeItemCost(
+    tenantId: number,
+    itemId: number,
+    startingDate: Date | string
+  ) {
+    const agenda = Container.get('agenda');
+
+    // Cancel any `compute-item-cost` in the queue has upper starting date
+    // with the same given item.
+    await agenda.cancel({
+      name: 'compute-item-cost',
+      nextRunAt: { $ne: null },
+      'data.tenantId': tenantId,
+      'data.itemId': itemId,
+      'data.startingDate': { $gt: startingDate },
+    });
+    // Retrieve any `compute-item-cost` in the queue has lower starting date
+    // with the same given item.
+    const dependsJobs = await agenda.jobs({
+      name: 'compute-item-cost',
+      nextRunAt: { $ne: null },
+      'data.tenantId': tenantId,
+      'data.itemId': itemId,
+      'data.startingDate': { $lte: startingDate },
+    });
+    if (dependsJobs.length === 0) {
+      await agenda.schedule(
+        config.scheduleComputeItemCost,
+        'compute-item-cost',
+        {
+          startingDate,
+          itemId,
+          tenantId,
+        }
+      );
+      // Triggers `onComputeItemCostJobScheduled` event.
+      await this.eventPublisher.emitAsync(
+        events.inventory.onComputeItemCostJobScheduled,
+        { startingDate, itemId, tenantId } as IInventoryItemCostScheduledPayload
+      );
+    }
+  }
+
+  /**
+   * Records the inventory transactions.
+   * @param  {number} tenantId - Tenant id.
+   * @param  {Bill} bill - Bill model object.
+   * @param  {number} billId - Bill id.
+   * @return {Promise<void>}
+   */
+  async recordInventoryTransactions(
+    tenantId: number,
+    transactions: IInventoryTransaction[],
+    override: boolean = false,
+    trx?: Knex.Transaction
+  ): Promise<void> {
+    const bulkInsertOpers = [];
+
+    transactions.forEach((transaction: IInventoryTransaction) => {
+      const oper = this.recordInventoryTransaction(
+        tenantId,
+        transaction,
+        override,
+        trx
+      );
+      bulkInsertOpers.push(oper);
+    });
+    const inventoryTransactions = await Promise.all(bulkInsertOpers);
+
+    // Triggers `onInventoryTransactionsCreated` event.
+    await this.eventPublisher.emitAsync(
+      events.inventory.onInventoryTransactionsCreated,
+      {
+        tenantId,
+        inventoryTransactions,
+        trx,
+      } as IInventoryTransactionsCreatedPayload
+    );
+  }
+
+  /**
+   * Writes the inventory transactiosn on the storage from the given
+   * inventory transactions entries.
+   *
+   * @param {number} tenantId -
+   * @param {IInventoryTransaction} inventoryEntry -
+   * @param {boolean} deleteOld -
+   */
+  async recordInventoryTransaction(
+    tenantId: number,
+    inventoryEntry: IInventoryTransaction,
+    deleteOld: boolean = false,
+    trx: Knex.Transaction
+  ): Promise<IInventoryTransaction> {
+    const { InventoryTransaction } = this.tenancy.models(tenantId);
+
+    if (deleteOld) {
+      await this.deleteInventoryTransactions(
+        tenantId,
+        inventoryEntry.transactionId,
+        inventoryEntry.transactionType,
+        trx
+      );
+    }
+    return InventoryTransaction.query(trx).insertGraph({
+      ...inventoryEntry,
+    });
+  }
+
+  /**
+   * Records the inventory transactions from items entries that have (inventory) type.
+   *
+   * @param {number} tenantId
+   * @param {number} transactionId
+   * @param {string} transactionType
+   * @param {Date|string} transactionDate
+   * @param {boolean} override
+   */
+  async recordInventoryTransactionsFromItemsEntries(
+    tenantId: number,
+    transaction: {
+      transactionId: number;
+      transactionType: IItemEntryTransactionType;
+      exchangeRate: number;
+
+      date: Date | string;
+      direction: TInventoryTransactionDirection;
+      entries: IItemEntry[];
+      createdAt: Date | string;
+
+      warehouseId: number;
+    },
+    override: boolean = false,
+    trx?: Knex.Transaction
+  ): Promise<void> {
+    // Can't continue if there is no entries has inventory items in the invoice.
+    if (transaction.entries.length <= 0) {
+      return;
+    }
+    // Inventory transactions.
+    const inventoryTranscations =
+      this.transformItemEntriesToInventory(transaction);
+
+    // Records the inventory transactions of the given sale invoice.
+    await this.recordInventoryTransactions(
+      tenantId,
+      inventoryTranscations,
+      override,
+      trx
+    );
+  }
+
+  /**
+   * Deletes the given inventory transactions.
+   * @param {number} tenantId - Tenant id.
+   * @param {string} transactionType
+   * @param {number} transactionId
+   * @return {Promise<{
+   *    oldInventoryTransactions: IInventoryTransaction[]
+   * }>}
+   */
+  async deleteInventoryTransactions(
+    tenantId: number,
+    transactionId: number,
+    transactionType: string,
+    trx?: Knex.Transaction
+  ): Promise<{ oldInventoryTransactions: IInventoryTransaction[] }> {
+    const { InventoryTransaction } = this.tenancy.models(tenantId);
+
+    // Retrieve the inventory transactions of the given sale invoice.
+    const oldInventoryTransactions = await InventoryTransaction.query(
+      trx
+    ).where({ transactionId, transactionType });
+
+    // Deletes the inventory transactions by the given transaction type and id.
+    await InventoryTransaction.query(trx)
+      .where({ transactionType, transactionId })
+      .delete();
+
+    // Triggers `onInventoryTransactionsDeleted` event.
+    await this.eventPublisher.emitAsync(
+      events.inventory.onInventoryTransactionsDeleted,
+      {
+        tenantId,
+        oldInventoryTransactions,
+        transactionId,
+        transactionType,
+        trx,
+      } as IInventoryTransactionsDeletedPayload
+    );
+    return { oldInventoryTransactions };
+  }
+
+  /**
+   * Records the inventory cost lot transaction.
+   * @param {number} tenantId
+   * @param {IInventoryLotCost} inventoryLotEntry
+   * @return {Promise<IInventoryLotCost>}
+   */
+  async recordInventoryCostLotTransaction(
+    tenantId: number,
+    inventoryLotEntry: IInventoryLotCost
+  ): Promise<void> {
+    const { InventoryCostLotTracker } = this.tenancy.models(tenantId);
+
+    return InventoryCostLotTracker.query().insert({
+      ...inventoryLotEntry,
+    });
+  }
+
+  /**
+   * Mark item cost computing is running.
+   * @param {number} tenantId -
+   * @param {boolean} isRunning -
+   */
+  async markItemsCostComputeRunning(
+    tenantId: number,
+    isRunning: boolean = true
+  ) {
+    const settings = this.tenancy.settings(tenantId);
+
+    settings.set({
+      key: 'cost_compute_running',
+      group: 'inventory',
+      value: isRunning,
+    });
+    await settings.save();
+  }
+
+  /**
+   *
+   * @param {number} tenantId
+   * @returns
+   */
+  isItemsCostComputeRunning(tenantId) {
+    const settings = this.tenancy.settings(tenantId);
+
+    return settings.get({
+      key: 'cost_compute_running',
+      group: 'inventory',
+    });
+  }
+}
diff --git a/packages/server/src/services/Inventory/InventoryAdjustmentGL.ts b/packages/server/src/services/Inventory/InventoryAdjustmentGL.ts
new file mode 100644
index 000000000..7d03c7558
--- /dev/null
+++ b/packages/server/src/services/Inventory/InventoryAdjustmentGL.ts
@@ -0,0 +1,226 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import * as R from 'ramda';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import {
+  AccountNormal,
+  IInventoryAdjustment,
+  IInventoryAdjustmentEntry,
+  ILedgerEntry,
+} from '@/interfaces';
+import Ledger from '@/services/Accounting/Ledger';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import { TenantMetadata } from '@/system/models';
+
+@Service()
+export default class InventoryAdjustmentsGL {
+  @Inject()
+  private tenancy: TenancyService;
+
+  @Inject()
+  private ledgerStorage: LedgerStorageService;
+
+  /**
+   * Retrieves the inventory adjustment common GL entry.
+   * @param   {InventoryAdjustment} inventoryAdjustment -
+   * @param   {string} baseCurrency -
+   * @returns {ILedgerEntry}
+   */
+  private getAdjustmentGLCommonEntry = (
+    inventoryAdjustment: IInventoryAdjustment,
+    baseCurrency: string
+  ) => {
+    return {
+      currencyCode: baseCurrency,
+      exchangeRate: 1,
+
+      transactionId: inventoryAdjustment.id,
+      transactionType: 'InventoryAdjustment',
+      referenceNumber: inventoryAdjustment.referenceNo,
+
+      date: inventoryAdjustment.date,
+
+      userId: inventoryAdjustment.userId,
+      branchId: inventoryAdjustment.branchId,
+
+      createdAt: inventoryAdjustment.createdAt,
+
+      credit: 0,
+      debit: 0,
+    };
+  };
+
+  /**
+   * Retrieve the inventory adjustment inventory GL entry.
+   * @param   {IInventoryAdjustment} inventoryAdjustment -Inventory adjustment model.
+   * @param   {string} baseCurrency - Base currency of the organization.
+   * @param   {IInventoryAdjustmentEntry} entry -
+   * @param   {number} index -
+   * @returns {ILedgerEntry}
+   */
+  private getAdjustmentGLInventoryEntry = R.curry(
+    (
+      inventoryAdjustment: IInventoryAdjustment,
+      baseCurrency: string,
+      entry: IInventoryAdjustmentEntry,
+      index: number
+    ): ILedgerEntry => {
+      const commonEntry = this.getAdjustmentGLCommonEntry(
+        inventoryAdjustment,
+        baseCurrency
+      );
+      const amount = entry.cost * entry.quantity;
+
+      return {
+        ...commonEntry,
+        debit: amount,
+        accountId: entry.item.inventoryAccountId,
+        accountNormal: AccountNormal.DEBIT,
+        index,
+      };
+    }
+  );
+
+  /**
+   * Retrieves the inventory adjustment
+   * @param   {IInventoryAdjustment} inventoryAdjustment
+   * @param   {IInventoryAdjustmentEntry} entry
+   * @returns {ILedgerEntry}
+   */
+  private getAdjustmentGLCostEntry = R.curry(
+    (
+      inventoryAdjustment: IInventoryAdjustment,
+      baseCurrency: string,
+      entry: IInventoryAdjustmentEntry,
+      index: number
+    ): ILedgerEntry => {
+      const commonEntry = this.getAdjustmentGLCommonEntry(
+        inventoryAdjustment,
+        baseCurrency
+      );
+      const amount = entry.cost * entry.quantity;
+
+      return {
+        ...commonEntry,
+        accountId: inventoryAdjustment.adjustmentAccountId,
+        accountNormal: AccountNormal.DEBIT,
+        credit: amount,
+        index: index + 2,
+      };
+    }
+  );
+
+  /**
+   * Retrieve the inventory adjustment GL item entry.
+   * @param {InventoryAdjustment} adjustment
+   * @param {string} baseCurrency
+   * @param {InventoryAdjustmentEntry} entry
+   * @param {number} index
+   * @returns {}
+   */
+  private getAdjustmentGLItemEntry = R.curry(
+    (
+      adjustment: IInventoryAdjustment,
+      baseCurrency: string,
+      entry: IInventoryAdjustmentEntry,
+      index: number
+    ): ILedgerEntry[] => {
+      const getInventoryEntry = this.getAdjustmentGLInventoryEntry(
+        adjustment,
+        baseCurrency
+      );
+      const inventoryEntry = getInventoryEntry(entry, index);
+      const costEntry = this.getAdjustmentGLCostEntry(
+        adjustment,
+        baseCurrency,
+        entry,
+        index
+      );
+      return [inventoryEntry, costEntry];
+    }
+  );
+
+  /**
+   * Writes increment inventroy adjustment GL entries.
+   * @param   {InventoryAdjustment} inventoryAdjustment -
+   * @param   {JournalPoster} jorunal -
+   * @returns {ILedgerEntry[]}
+   */
+  public getIncrementAdjustmentGLEntries(
+    inventoryAdjustment: IInventoryAdjustment,
+    baseCurrency: string
+  ): ILedgerEntry[] {
+    const getItemEntry = this.getAdjustmentGLItemEntry(
+      inventoryAdjustment,
+      baseCurrency
+    );
+    return inventoryAdjustment.entries.map(getItemEntry).flat();
+  }
+
+  /**
+   * Writes inventory increment adjustment GL entries.
+   * @param {number} tenantId
+   * @param {number} inventoryAdjustmentId
+   */
+  public writeAdjustmentGLEntries = async (
+    tenantId: number,
+    inventoryAdjustmentId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { InventoryAdjustment } = this.tenancy.models(tenantId);
+
+    // Retrieves the inventory adjustment with associated entries.
+    const adjustment = await InventoryAdjustment.query(trx)
+      .findById(inventoryAdjustmentId)
+      .withGraphFetched('entries.item');
+
+    const tenantMeta = await TenantMetadata.query().findOne({ tenantId });
+
+    // Retrieves the inventory adjustment GL entries.
+    const entries = this.getIncrementAdjustmentGLEntries(
+      adjustment,
+      tenantMeta.baseCurrency
+    );
+    const ledger = new Ledger(entries);
+
+    // Commits the ledger entries to the storage.
+    await this.ledgerStorage.commit(tenantId, ledger, trx);
+  };
+
+  /**
+   * Reverts the adjustment transactions GL entries.
+   * @param   {number} tenantId
+   * @param   {number} inventoryAdjustmentId
+   * @returns {Promise<void>}
+   */
+  public revertAdjustmentGLEntries = (
+    tenantId: number,
+    inventoryAdjustmentId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    return this.ledgerStorage.deleteByReference(
+      tenantId,
+      inventoryAdjustmentId,
+      'InventoryAdjustment',
+      trx
+    );
+  };
+
+  /**
+   * Rewrite inventory adjustment GL entries.
+   * @param {number} tenantId
+   * @param {number} inventoryAdjustmentId
+   * @param {Knex.Transaction} trx
+   */
+  public rewriteAdjustmentGLEntries = async (
+    tenantId: number,
+    inventoryAdjustmentId: number,
+    trx?: Knex.Transaction
+  ) => {
+    // Reverts GL entries of the given inventory adjustment.
+    await this.revertAdjustmentGLEntries(tenantId, inventoryAdjustmentId, trx);
+
+    // Writes GL entries of th egiven inventory adjustment.
+    await this.writeAdjustmentGLEntries(tenantId, inventoryAdjustmentId, trx);
+  };
+}
diff --git a/packages/server/src/services/Inventory/InventoryAdjustmentService.ts b/packages/server/src/services/Inventory/InventoryAdjustmentService.ts
new file mode 100644
index 000000000..44df986e1
--- /dev/null
+++ b/packages/server/src/services/Inventory/InventoryAdjustmentService.ts
@@ -0,0 +1,475 @@
+import { Inject, Service } from 'typedi';
+import { omit } from 'lodash';
+import moment from 'moment';
+import * as R from 'ramda';
+import { Knex } from 'knex';
+import { ServiceError } from '@/exceptions';
+import {
+  IQuickInventoryAdjustmentDTO,
+  IInventoryAdjustment,
+  IPaginationMeta,
+  IInventoryAdjustmentsFilter,
+  ISystemUser,
+  IInventoryTransaction,
+  IInventoryAdjustmentEventCreatedPayload,
+  IInventoryAdjustmentEventPublishedPayload,
+  IInventoryAdjustmentEventDeletedPayload,
+  IInventoryAdjustmentCreatingPayload,
+  IInventoryAdjustmentDeletingPayload,
+  IInventoryAdjustmentPublishingPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import InventoryService from './Inventory';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import InventoryAdjustmentTransformer from './InventoryAdjustmentTransformer';
+import { BranchTransactionDTOTransform } from '@/services/Branches/Integrations/BranchTransactionDTOTransform';
+import { WarehouseTransactionDTOTransform } from '@/services/Warehouses/Integrations/WarehouseTransactionDTOTransform';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+const ERRORS = {
+  INVENTORY_ADJUSTMENT_NOT_FOUND: 'INVENTORY_ADJUSTMENT_NOT_FOUND',
+  ITEM_SHOULD_BE_INVENTORY_TYPE: 'ITEM_SHOULD_BE_INVENTORY_TYPE',
+  INVENTORY_ADJUSTMENT_ALREADY_PUBLISHED:
+    'INVENTORY_ADJUSTMENT_ALREADY_PUBLISHED',
+};
+
+@Service()
+export default class InventoryAdjustmentService {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private inventoryService: InventoryService;
+
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private branchDTOTransform: BranchTransactionDTOTransform;
+
+  @Inject()
+  private warehouseDTOTransform: WarehouseTransactionDTOTransform;
+
+  @Inject()
+  private transfromer: TransformerInjectable;
+
+  /**
+   * Transformes the quick inventory adjustment DTO to model object.
+   * @param  {IQuickInventoryAdjustmentDTO} adjustmentDTO -
+   * @return {IInventoryAdjustment}
+   */
+  private transformQuickAdjToModel(
+    tenantId: number,
+    adjustmentDTO: IQuickInventoryAdjustmentDTO,
+    authorizedUser: ISystemUser
+  ): IInventoryAdjustment {
+    const entries = [
+      {
+        index: 1,
+        itemId: adjustmentDTO.itemId,
+        ...('increment' === adjustmentDTO.type
+          ? {
+              quantity: adjustmentDTO.quantity,
+              cost: adjustmentDTO.cost,
+            }
+          : {}),
+        ...('decrement' === adjustmentDTO.type
+          ? {
+              quantity: adjustmentDTO.quantity,
+            }
+          : {}),
+      },
+    ];
+    const initialDTO = {
+      ...omit(adjustmentDTO, ['quantity', 'cost', 'itemId', 'publish']),
+      userId: authorizedUser.id,
+      ...(adjustmentDTO.publish
+        ? {
+            publishedAt: moment().toMySqlDateTime(),
+          }
+        : {}),
+      entries,
+    };
+    return R.compose(
+      this.warehouseDTOTransform.transformDTO<IInventoryAdjustment>(tenantId),
+      this.branchDTOTransform.transformDTO<IInventoryAdjustment>(tenantId)
+    )(initialDTO);
+  }
+
+  /**
+   * Validate the item inventory type.
+   * @param {IItem} item
+   */
+  validateItemInventoryType(item) {
+    if (item.type !== 'inventory') {
+      throw new ServiceError(ERRORS.ITEM_SHOULD_BE_INVENTORY_TYPE);
+    }
+  }
+
+  /**
+   * Retrieve the inventory adjustment or throw not found service error.
+   * @param {number} tenantId -
+   * @param {number} adjustmentId -
+   */
+  async getInventoryAdjustmentOrThrowError(
+    tenantId: number,
+    adjustmentId: number
+  ) {
+    const { InventoryAdjustment } = this.tenancy.models(tenantId);
+
+    const inventoryAdjustment = await InventoryAdjustment.query()
+      .findById(adjustmentId)
+      .withGraphFetched('entries');
+
+    if (!inventoryAdjustment) {
+      throw new ServiceError(ERRORS.INVENTORY_ADJUSTMENT_NOT_FOUND);
+    }
+    return inventoryAdjustment;
+  }
+
+  /**
+   * Creates a quick inventory adjustment for specific item.
+   * @param {number} tenantId - Tenant id.
+   * @param {IQuickInventoryAdjustmentDTO} quickAdjustmentDTO - qucik adjustment DTO.
+   */
+  public async createQuickAdjustment(
+    tenantId: number,
+    quickAdjustmentDTO: IQuickInventoryAdjustmentDTO,
+    authorizedUser: ISystemUser
+  ): Promise<IInventoryAdjustment> {
+    const { InventoryAdjustment, Account, Item } =
+      this.tenancy.models(tenantId);
+
+    // Retrieve the adjustment account or throw not found error.
+    const adjustmentAccount = await Account.query()
+      .findById(quickAdjustmentDTO.adjustmentAccountId)
+      .throwIfNotFound();
+
+    // Retrieve the item model or throw not found service error.
+    const item = await Item.query()
+      .findById(quickAdjustmentDTO.itemId)
+      .throwIfNotFound();
+
+    // Validate item inventory type.
+    this.validateItemInventoryType(item);
+
+    // Transform the DTO to inventory adjustment model.
+    const invAdjustmentObject = this.transformQuickAdjToModel(
+      tenantId,
+      quickAdjustmentDTO,
+      authorizedUser
+    );
+    // Writes inventory adjustment transaction with associated transactions
+    // under unit-of-work envirment.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onInventoryAdjustmentCreating` event.
+      await this.eventPublisher.emitAsync(
+        events.inventoryAdjustment.onQuickCreating,
+        {
+          tenantId,
+          trx,
+          quickAdjustmentDTO,
+        } as IInventoryAdjustmentCreatingPayload
+      );
+      // Saves the inventory adjustment with assocaited entries to the storage.
+      const inventoryAdjustment = await InventoryAdjustment.query(
+        trx
+      ).upsertGraph({
+        ...invAdjustmentObject,
+      });
+      // Triggers `onInventoryAdjustmentQuickCreated` event.
+      await this.eventPublisher.emitAsync(
+        events.inventoryAdjustment.onQuickCreated,
+        {
+          tenantId,
+          inventoryAdjustment,
+          inventoryAdjustmentId: inventoryAdjustment.id,
+          trx,
+        } as IInventoryAdjustmentEventCreatedPayload
+      );
+      return inventoryAdjustment;
+    });
+  }
+
+  /**
+   * Deletes the inventory adjustment transaction.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} inventoryAdjustmentId - Inventory adjustment id.
+   */
+  public async deleteInventoryAdjustment(
+    tenantId: number,
+    inventoryAdjustmentId: number
+  ): Promise<void> {
+    const { InventoryAdjustmentEntry, InventoryAdjustment } =
+      this.tenancy.models(tenantId);
+
+    // Retrieve the inventory adjustment or throw not found service error.
+    const oldInventoryAdjustment =
+      await this.getInventoryAdjustmentOrThrowError(
+        tenantId,
+        inventoryAdjustmentId
+      );
+    // Deletes the inventory adjustment transaction and associated transactions
+    // under unit-of-work env.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onInventoryAdjustmentDeleting` event.
+      await this.eventPublisher.emitAsync(
+        events.inventoryAdjustment.onDeleting,
+        {
+          trx,
+          oldInventoryAdjustment,
+          tenantId,
+        } as IInventoryAdjustmentDeletingPayload
+      );
+
+      // Deletes the inventory adjustment entries.
+      await InventoryAdjustmentEntry.query(trx)
+        .where('adjustment_id', inventoryAdjustmentId)
+        .delete();
+
+      // Deletes the inventory adjustment transaction.
+      await InventoryAdjustment.query(trx)
+        .findById(inventoryAdjustmentId)
+        .delete();
+
+      // Triggers `onInventoryAdjustmentDeleted` event.
+      await this.eventPublisher.emitAsync(
+        events.inventoryAdjustment.onDeleted,
+        {
+          tenantId,
+          inventoryAdjustmentId,
+          oldInventoryAdjustment,
+          trx,
+        } as IInventoryAdjustmentEventDeletedPayload
+      );
+    });
+  }
+
+  /**
+   * Publish the inventory adjustment transaction.
+   * @param {number} tenantId
+   * @param {number} inventoryAdjustmentId
+   */
+  public async publishInventoryAdjustment(
+    tenantId: number,
+    inventoryAdjustmentId: number
+  ): Promise<void> {
+    const { InventoryAdjustment } = this.tenancy.models(tenantId);
+
+    // Retrieve the inventory adjustment or throw not found service error.
+    const oldInventoryAdjustment =
+      await this.getInventoryAdjustmentOrThrowError(
+        tenantId,
+        inventoryAdjustmentId
+      );
+
+    // Validate adjustment not already published.
+    this.validateAdjustmentTransactionsNotPublished(oldInventoryAdjustment);
+
+    // Publishes inventory adjustment with associated inventory transactions
+    // under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      await this.eventPublisher.emitAsync(
+        events.inventoryAdjustment.onPublishing,
+        {
+          trx,
+          tenantId,
+          oldInventoryAdjustment,
+        } as IInventoryAdjustmentPublishingPayload
+      );
+
+      // Publish the inventory adjustment transaction.
+      await InventoryAdjustment.query().findById(inventoryAdjustmentId).patch({
+        publishedAt: moment().toMySqlDateTime(),
+      });
+      // Retrieve the inventory adjustment after the modification.
+      const inventoryAdjustment = await InventoryAdjustment.query()
+        .findById(inventoryAdjustmentId)
+        .withGraphFetched('entries');
+
+      // Triggers `onInventoryAdjustmentDeleted` event.
+      await this.eventPublisher.emitAsync(
+        events.inventoryAdjustment.onPublished,
+        {
+          tenantId,
+          inventoryAdjustmentId,
+          inventoryAdjustment,
+          oldInventoryAdjustment,
+          trx,
+        } as IInventoryAdjustmentEventPublishedPayload
+      );
+    });
+  }
+
+  /**
+   * Parses inventory adjustments list filter DTO.
+   * @param filterDTO -
+   */
+  private parseListFilterDTO(filterDTO) {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  }
+
+  /**
+   * Retrieve the inventory adjustments paginated list.
+   * @param {number} tenantId
+   * @param {IInventoryAdjustmentsFilter} adjustmentsFilter
+   */
+  public async getInventoryAdjustments(
+    tenantId: number,
+    filterDTO: IInventoryAdjustmentsFilter
+  ): Promise<{
+    inventoryAdjustments: IInventoryAdjustment[];
+    pagination: IPaginationMeta;
+  }> {
+    const { InventoryAdjustment } = this.tenancy.models(tenantId);
+
+    // Parses inventory adjustments list filter DTO.
+    const filter = this.parseListFilterDTO(filterDTO);
+
+    // Dynamic list service.
+    const dynamicFilter = await this.dynamicListService.dynamicList(
+      tenantId,
+      InventoryAdjustment,
+      filter
+    );
+    const { results, pagination } = await InventoryAdjustment.query()
+      .onBuild((query) => {
+        query.withGraphFetched('entries.item');
+        query.withGraphFetched('adjustmentAccount');
+
+        dynamicFilter.buildQuery()(query);
+      })
+      .pagination(filter.page - 1, filter.pageSize);
+
+    // Retrieves the transformed inventory adjustments.
+    const inventoryAdjustments = await this.transfromer.transform(
+      tenantId,
+      results,
+      new InventoryAdjustmentTransformer()
+    );
+    return {
+      inventoryAdjustments,
+      pagination,
+    };
+  }
+
+  /**
+   * Writes the inventory transactions from the inventory adjustment transaction.
+   * @param  {number} tenantId -
+   * @param  {IInventoryAdjustment} inventoryAdjustment -
+   * @param  {boolean} override -
+   * @param  {Knex.Transaction} trx -
+   * @return {Promise<void>}
+   */
+  public async writeInventoryTransactions(
+    tenantId: number,
+    inventoryAdjustment: IInventoryAdjustment,
+    override: boolean = false,
+    trx?: Knex.Transaction
+  ): Promise<void> {
+    const commonTransaction = {
+      direction: inventoryAdjustment.inventoryDirection,
+      date: inventoryAdjustment.date,
+      transactionType: 'InventoryAdjustment',
+      transactionId: inventoryAdjustment.id,
+      createdAt: inventoryAdjustment.createdAt,
+      costAccountId: inventoryAdjustment.adjustmentAccountId,
+
+      branchId: inventoryAdjustment.branchId,
+      warehouseId: inventoryAdjustment.warehouseId,
+    };
+    const inventoryTransactions = [];
+
+    inventoryAdjustment.entries.forEach((entry) => {
+      inventoryTransactions.push({
+        ...commonTransaction,
+        itemId: entry.itemId,
+        quantity: entry.quantity,
+        rate: entry.cost,
+      });
+    });
+    // Saves the given inventory transactions to the storage.
+    await this.inventoryService.recordInventoryTransactions(
+      tenantId,
+      inventoryTransactions,
+      override,
+      trx
+    );
+  }
+
+  /**
+   * Reverts the inventory transactions from the inventory adjustment transaction.
+   * @param {number} tenantId
+   * @param {number} inventoryAdjustmentId
+   */
+  async revertInventoryTransactions(
+    tenantId: number,
+    inventoryAdjustmentId: number,
+    trx?: Knex.Transaction
+  ): Promise<{ oldInventoryTransactions: IInventoryTransaction[] }> {
+    return this.inventoryService.deleteInventoryTransactions(
+      tenantId,
+      inventoryAdjustmentId,
+      'InventoryAdjustment',
+      trx
+    );
+  }
+
+  /**
+   * Retrieve specific inventory adjustment transaction details.
+   * @param {number} tenantId
+   * @param {number} inventoryAdjustmentId
+   */
+  async getInventoryAdjustment(
+    tenantId: number,
+    inventoryAdjustmentId: number
+  ) {
+    const { InventoryAdjustment } = this.tenancy.models(tenantId);
+
+    // Retrieve inventory adjustment transation with associated models.
+    const inventoryAdjustment = await InventoryAdjustment.query()
+      .findById(inventoryAdjustmentId)
+      .withGraphFetched('entries.item')
+      .withGraphFetched('adjustmentAccount');
+
+    // Throw not found if the given adjustment transaction not exists.
+    this.throwIfAdjustmentNotFound(inventoryAdjustment);
+
+    return this.transfromer.transform(
+      tenantId,
+      inventoryAdjustment,
+      new InventoryAdjustmentTransformer()
+    );
+  }
+
+  /**
+   * Validate the adjustment transaction is exists.
+   * @param {IInventoryAdjustment} inventoryAdjustment
+   */
+  private throwIfAdjustmentNotFound(inventoryAdjustment: IInventoryAdjustment) {
+    if (!inventoryAdjustment) {
+      throw new ServiceError(ERRORS.INVENTORY_ADJUSTMENT_NOT_FOUND);
+    }
+  }
+
+  /**
+   * Validates the adjustment transaction is not already published.
+   * @param {IInventoryAdjustment} oldInventoryAdjustment
+   */
+  private validateAdjustmentTransactionsNotPublished(
+    oldInventoryAdjustment: IInventoryAdjustment
+  ) {
+    if (oldInventoryAdjustment.isPublished) {
+      throw new ServiceError(ERRORS.INVENTORY_ADJUSTMENT_ALREADY_PUBLISHED);
+    }
+  }
+}
diff --git a/packages/server/src/services/Inventory/InventoryAdjustmentTransformer.ts b/packages/server/src/services/Inventory/InventoryAdjustmentTransformer.ts
new file mode 100644
index 000000000..f98acaaf8
--- /dev/null
+++ b/packages/server/src/services/Inventory/InventoryAdjustmentTransformer.ts
@@ -0,0 +1,25 @@
+import { IInventoryAdjustment } from '@/interfaces';
+import { Transformer } from '@/lib/Transformer/Transformer';
+
+export default class InventoryAdjustmentTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return ['formattedType'];
+  };
+
+  /**
+   * Retrieves the formatted and localized adjustment type.
+   * @param   {IInventoryAdjustment} inventoryAdjustment
+   * @returns {string}
+   */
+  formattedType(inventoryAdjustment: IInventoryAdjustment) {
+    const types = {
+      increment: 'inventory_adjustment.type.increment',
+      decrement: 'inventory_adjustment.type.decrement',
+    };
+    return this.context.i18n.__(types[inventoryAdjustment.type] || '');
+  }
+}
diff --git a/packages/server/src/services/Inventory/InventoryAverageCost.ts b/packages/server/src/services/Inventory/InventoryAverageCost.ts
new file mode 100644
index 000000000..0108cab16
--- /dev/null
+++ b/packages/server/src/services/Inventory/InventoryAverageCost.ts
@@ -0,0 +1,257 @@
+import { pick } from 'lodash';
+import { Knex } from 'knex';
+import { IInventoryTransaction } from '@/interfaces';
+import InventoryCostMethod from '@/services/Inventory/InventoryCostMethod';
+
+export default class InventoryAverageCostMethod
+  extends InventoryCostMethod
+  implements IInventoryCostMethod
+{
+  startingDate: Date;
+  itemId: number;
+  costTransactions: any[];
+  trx: Knex.Transaction;
+
+  /**
+   * Constructor method.
+   * @param {number} tenantId - The given tenant id.
+   * @param {Date} startingDate -
+   * @param {number} itemId - The given inventory item id.
+   */
+  constructor(
+    tenantId: number,
+    startingDate: Date,
+    itemId: number,
+    trx?: Knex.Transaction
+  ) {
+    super(tenantId, startingDate, itemId);
+
+    this.trx = trx;
+    this.startingDate = startingDate;
+    this.itemId = itemId;
+    this.costTransactions = [];
+  }
+
+  /**
+   * Computes items costs from the given date using average cost method.
+   * ----------
+   * - Calculate the items average cost in the given date.
+   * - Remove the journal entries that associated to the inventory transacions
+   *   after the given date.
+   * - Re-compute the inventory transactions and re-write the journal entries
+   *   after the given date.
+   * ----------
+   * @async
+   * @param {Date} startingDate
+   * @param {number} referenceId
+   * @param {string} referenceType
+   */
+  public async computeItemCost() {
+    const { InventoryTransaction } = this.tenantModels;
+    const { averageCost, openingQuantity, openingCost } =
+      await this.getOpeningAvaregeCost(this.startingDate, this.itemId);
+
+    const afterInvTransactions: IInventoryTransaction[] =
+      await InventoryTransaction.query()
+        .modify('filterDateRange', this.startingDate)
+        .orderBy('date', 'ASC')
+        .orderByRaw("FIELD(direction, 'IN', 'OUT')")
+        .orderBy('createdAt', 'ASC')
+        .where('item_id', this.itemId)
+        .withGraphFetched('item');
+
+    // Tracking inventroy transactions and retrieve cost transactions based on
+    // average rate cost method.
+    const costTransactions = this.trackingCostTransactions(
+      afterInvTransactions,
+      openingQuantity,
+      openingCost
+    );
+    // Revert the inveout out lots transactions
+    await this.revertTheInventoryOutLotTrans();
+
+    // Store inventory lots cost transactions.
+    await this.storeInventoryLotsCost(costTransactions);
+  }
+
+  /**
+   * Get items Avarege cost from specific date from inventory transactions.
+   * @async
+   * @param {Date} closingDate
+   * @return {number}
+   */
+  public async getOpeningAvaregeCost(closingDate: Date, itemId: number) {
+    const { InventoryCostLotTracker } = this.tenantModels;
+
+    const commonBuilder = (builder: any) => {
+      if (closingDate) {
+        builder.where('date', '<', closingDate);
+      }
+      builder.where('item_id', itemId);
+      builder.sum('rate as rate');
+      builder.sum('quantity as quantity');
+      builder.sum('cost as cost');
+      builder.first();
+    };
+    // Calculates the total inventory total quantity and rate `IN` transactions.
+    const inInvSumationOper: Promise<any> = InventoryCostLotTracker.query()
+      .onBuild(commonBuilder)
+      .where('direction', 'IN');
+
+    // Calculates the total inventory total quantity and rate `OUT` transactions.
+    const outInvSumationOper: Promise<any> = InventoryCostLotTracker.query()
+      .onBuild(commonBuilder)
+      .where('direction', 'OUT');
+
+    const [inInvSumation, outInvSumation] = await Promise.all([
+      inInvSumationOper,
+      outInvSumationOper,
+    ]);
+    return this.computeItemAverageCost(
+      inInvSumation?.cost || 0,
+      inInvSumation?.quantity || 0,
+      outInvSumation?.cost || 0,
+      outInvSumation?.quantity || 0
+    );
+  }
+
+  /**
+   * Computes the item average cost.
+   * @static
+   * @param {number} quantityIn
+   * @param {number} rateIn
+   * @param {number} quantityOut
+   * @param {number} rateOut
+   */
+  public computeItemAverageCost(
+    totalCostIn: number,
+    totalQuantityIn: number,
+
+    totalCostOut: number,
+    totalQuantityOut: number
+  ) {
+    const openingCost = totalCostIn - totalCostOut;
+    const openingQuantity = totalQuantityIn - totalQuantityOut;
+
+    const averageCost = openingQuantity ? openingCost / openingQuantity : 0;
+
+    return { averageCost, openingCost, openingQuantity };
+  }
+
+  private getCost(rate: number, quantity: number) {
+    return quantity ? rate * quantity : rate;
+  }
+
+  /**
+   * Records the journal entries from specific item inventory transactions.
+   * @param {IInventoryTransaction[]} invTransactions
+   * @param {number} openingAverageCost
+   * @param {string} referenceType
+   * @param {number} referenceId
+   * @param {JournalCommand} journalCommands
+   */
+  public trackingCostTransactions(
+    invTransactions: IInventoryTransaction[],
+    openingQuantity: number = 0,
+    openingCost: number = 0
+  ) {
+    const costTransactions: any[] = [];
+
+    // Cumulative item quantity and cost. This will decrement after
+    // each out transactions depends on its quantity and cost.
+    let accQuantity: number = openingQuantity;
+    let accCost: number = openingCost;
+
+    invTransactions.forEach((invTransaction: IInventoryTransaction) => {
+      const commonEntry = {
+        invTransId: invTransaction.id,
+        ...pick(invTransaction, [
+          'date',
+          'direction',
+          'itemId',
+          'quantity',
+          'rate',
+          'entryId',
+          'transactionId',
+          'transactionType',
+          'createdAt',
+          'costAccountId',
+          'branchId',
+          'warehouseId',
+        ]),
+        inventoryTransactionId: invTransaction.id,
+      };
+      switch (invTransaction.direction) {
+        case 'IN':
+          const inCost = this.getCost(
+            invTransaction.rate,
+            invTransaction.quantity
+          );
+          // Increases the quantity and cost in `IN` inventory transactions.
+          accQuantity += invTransaction.quantity;
+          accCost += inCost;
+
+          costTransactions.push({
+            ...commonEntry,
+            cost: inCost,
+          });
+          break;
+        case 'OUT':
+          // Average cost = Total cost / Total quantity
+          const averageCost = accQuantity ? accCost / accQuantity : 0;
+
+          const quantity =
+            accQuantity > 0
+              ? Math.min(invTransaction.quantity, accQuantity)
+              : invTransaction.quantity;
+
+          // Cost = the transaction quantity * Average cost.
+          const cost = this.getCost(averageCost, quantity);
+
+          // Revenue = transaction quanity * rate.
+          // const revenue = quantity * invTransaction.rate;
+          costTransactions.push({
+            ...commonEntry,
+            quantity,
+            cost,
+          });
+          accQuantity = Math.max(accQuantity - quantity, 0);
+          accCost = Math.max(accCost - cost, 0);
+
+          if (invTransaction.quantity > quantity) {
+            const remainingQuantity = Math.max(
+              invTransaction.quantity - quantity,
+              0
+            );
+            const remainingIncome = remainingQuantity * invTransaction.rate;
+
+            costTransactions.push({
+              ...commonEntry,
+              quantity: remainingQuantity,
+              cost: 0,
+            });
+            accQuantity = Math.max(accQuantity - remainingQuantity, 0);
+            accCost = Math.max(accCost - remainingIncome, 0);
+          }
+          break;
+      }
+    });
+    return costTransactions;
+  }
+
+  /**
+   * Reverts the inventory lots `OUT` transactions.
+   * @param {Date} openingDate - Opening date.
+   * @param {number} itemId - Item id.
+   * @returns {Promise<void>}
+   */
+  async revertTheInventoryOutLotTrans(): Promise<void> {
+    const { InventoryCostLotTracker } = this.tenantModels;
+
+    await InventoryCostLotTracker.query(this.trx)
+      .modify('filterDateRange', this.startingDate)
+      .orderBy('date', 'DESC')
+      .where('item_id', this.itemId)
+      .delete();
+  }
+}
diff --git a/packages/server/src/services/Inventory/InventoryCostApplication.ts b/packages/server/src/services/Inventory/InventoryCostApplication.ts
new file mode 100644
index 000000000..3fd3b021a
--- /dev/null
+++ b/packages/server/src/services/Inventory/InventoryCostApplication.ts
@@ -0,0 +1,29 @@
+import { IInventoryItemCostMeta } from '@/interfaces';
+import { Service, Inject } from 'typedi';
+import { InventoryItemCostService } from './InventoryCostsService';
+
+@Service()
+export class InventoryCostApplication {
+  @Inject()
+  inventoryCost: InventoryItemCostService;
+
+  /**
+   * Retrieves the items inventory valuation list.
+   * @param   {number} tenantId
+   * @param   {number[]} itemsId
+   * @param   {Date} date
+   * @returns {Promise<IInventoryItemCostMeta[]>}
+   */
+  public getItemsInventoryValuationList = async (
+    tenantId: number,
+    itemsId: number[],
+    date: Date
+  ): Promise<IInventoryItemCostMeta[]> => {
+    const itemsMap = await this.inventoryCost.getItemsInventoryValuation(
+      tenantId,
+      itemsId,
+      date
+    );
+    return [...itemsMap.values()];
+  };
+}
diff --git a/packages/server/src/services/Inventory/InventoryCostGLStorage.ts b/packages/server/src/services/Inventory/InventoryCostGLStorage.ts
new file mode 100644
index 000000000..2860b0d66
--- /dev/null
+++ b/packages/server/src/services/Inventory/InventoryCostGLStorage.ts
@@ -0,0 +1,40 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import Ledger from '@/services/Accounting/Ledger';
+
+@Service()
+export class InventoryCostGLStorage {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private ledgerStorage: LedgerStorageService;
+
+  /**
+   * Reverts the inventory cost GL entries from the given starting date.
+   * @param {number} tenantId
+   * @param {Date} startingDate
+   * @param {Knex.Transaction} trx
+   */
+  public revertInventoryCostGLEntries = async (
+    tenantId: number,
+    startingDate: Date,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+
+    // Retrieve transactions from specific date range and costable transactions only.
+    const transactions = await AccountTransaction.query()
+      .where('costable', true)
+      .modify('filterDateRange', startingDate)
+      .withGraphFetched('account');
+
+    // Transform transaction to ledger entries and reverse them.
+    const reversedLedger = Ledger.fromTransactions(transactions).reverse();
+
+    // Deletes and reverts balances of the given ledger.
+    await this.ledgerStorage.delete(tenantId, reversedLedger, trx);
+  };
+}
diff --git a/packages/server/src/services/Inventory/InventoryCostLotTracker.ts b/packages/server/src/services/Inventory/InventoryCostLotTracker.ts
new file mode 100644
index 000000000..9ce03880a
--- /dev/null
+++ b/packages/server/src/services/Inventory/InventoryCostLotTracker.ts
@@ -0,0 +1,302 @@
+import { pick, chain } from 'lodash';
+import moment from 'moment';
+import { IInventoryLotCost, IInventoryTransaction } from "interfaces";
+import InventoryCostMethod from '@/services/Inventory/InventoryCostMethod';
+
+type TCostMethod = 'FIFO' | 'LIFO';
+
+export default class InventoryCostLotTracker extends InventoryCostMethod implements IInventoryCostMethod {
+  startingDate: Date;
+  itemId: number;
+  costMethod: TCostMethod;
+  itemsById: Map<number, any>;
+  inventoryINTrans: any;
+  inventoryByItem: any;
+  costLotsTransactions: IInventoryLotCost[];
+  inTransactions: any[];
+  outTransactions: IInventoryTransaction[];
+  revertJEntriesTransactions: IInventoryTransaction[];
+
+  /**
+   * Constructor method.
+   * @param {Date} startingDate -
+   * @param {number} itemId -
+   * @param {string} costMethod - 
+   */
+  constructor(
+    tenantId: number,
+    startingDate: Date,
+    itemId: number,
+    costMethod: TCostMethod = 'FIFO'
+  ) {
+    super(tenantId, startingDate, itemId);
+
+    this.startingDate = startingDate;
+    this.itemId = itemId;
+    this.costMethod = costMethod;
+
+    // Collect cost lots transactions to insert them to the storage in bulk.
+    this.costLotsTransactions= [];
+    // Collect inventory transactions by item id.
+    this.inventoryByItem = {};
+    // Collection `IN` inventory tranaction by transaction id.
+    this.inventoryINTrans = {};
+    // Collects `IN` transactions.
+    this.inTransactions = [];
+    // Collects `OUT` transactions.
+    this.outTransactions = [];
+  }
+
+  /**
+   * Computes items costs from the given date using FIFO or LIFO cost method.
+   * -------- 
+   * - Revert the inventory lots after the given date.
+   * - Remove all the journal entries from the inventory transactions
+   *   after the given date.
+   * - Re-tracking the inventory lots from inventory transactions.
+   * - Re-write the journal entries from the given inventory transactions.
+   * @async
+   * @return {void}
+   */
+  public async computeItemCost(): Promise<any> {
+    await this.revertInventoryLots(this.startingDate);
+    await this.fetchInvINTransactions();
+    await this.fetchInvOUTTransactions(); 
+    await this.fetchRevertInvJReferenceIds();
+    await this.fetchItemsMapped();
+
+    this.trackingInventoryINLots(this.inTransactions);
+    this.trackingInventoryOUTLots(this.outTransactions);
+
+    // Re-tracking the inventory `IN` and `OUT` lots costs.
+    const storedTrackedInvLotsOper = this.storeInventoryLotsCost(
+      this.costLotsTransactions,
+    );
+    return Promise.all([
+      storedTrackedInvLotsOper,
+    ]);
+  }
+
+  /**
+   * Fetched inventory transactions that has date from the starting date and
+   * fetches availiable IN LOTs transactions that has remaining bigger than zero.
+   * @private
+   */
+  private async fetchInvINTransactions() {
+    const { InventoryTransaction, InventoryLotCostTracker } = this.tenantModels;
+
+    const commonBuilder = (builder: any) => {
+      builder.orderBy('date', (this.costMethod === 'LIFO') ? 'DESC': 'ASC');
+      builder.where('item_id', this.itemId);
+    };
+    const afterInvTransactions: IInventoryTransaction[] =
+      await InventoryTransaction.query()
+        .modify('filterDateRange', this.startingDate)
+        .orderByRaw("FIELD(direction, 'IN', 'OUT')")
+        .onBuild(commonBuilder)
+        .orderBy('lot_number', (this.costMethod === 'LIFO') ? 'DESC' : 'ASC')
+        .withGraphFetched('item');
+
+    const availiableINLots: IInventoryLotCost[] = 
+      await InventoryLotCostTracker.query()
+        .modify('filterDateRange', null, this.startingDate)
+        .orderBy('date', 'ASC')
+        .where('direction', 'IN')
+        .orderBy('lot_number', 'ASC')
+        .onBuild(commonBuilder)
+        .whereNot('remaining', 0);
+
+    this.inTransactions = [
+      ...availiableINLots.map((trans) => ({ lotTransId: trans.id, ...trans })),
+      ...afterInvTransactions.map((trans) => ({ invTransId: trans.id, ...trans })),
+    ];
+  }
+
+  /**
+   * Fetches inventory OUT transactions that has date from the starting date.
+   * @private
+   */
+  private async fetchInvOUTTransactions() {
+    const { InventoryTransaction } = this.tenantModels;
+
+    const afterOUTTransactions: IInventoryTransaction[] = 
+      await InventoryTransaction.query()
+        .modify('filterDateRange', this.startingDate)
+        .orderBy('date', 'ASC')
+        .orderBy('lot_number', 'ASC')
+        .where('item_id', this.itemId)
+        .where('direction', 'OUT')
+        .withGraphFetched('item');
+
+    this.outTransactions = [ ...afterOUTTransactions ];
+  }  
+
+  private async fetchItemsMapped() {
+    const itemsIds = chain(this.inTransactions).map((e) => e.itemId).uniq().value();
+    const { Item } = this.tenantModels;
+    const storedItems = await Item.query()
+      .where('type', 'inventory')
+      .whereIn('id', itemsIds);
+
+    this.itemsById = new Map(storedItems.map((item: any) => [item.id, item]));
+  }
+
+  /**
+   * Fetch the inventory transactions that should revert its journal entries.
+   * @private
+   */
+  private async fetchRevertInvJReferenceIds() {
+    const { InventoryTransaction } = this.tenantModels;
+    const revertJEntriesTransactions: IInventoryTransaction[] = 
+      await InventoryTransaction.query()
+        .select(['transactionId', 'transactionType'])
+        .modify('filterDateRange', this.startingDate)
+        .where('direction', 'OUT')
+        .where('item_id', this.itemId);
+
+    this.revertJEntriesTransactions = revertJEntriesTransactions; 
+  }
+
+  /**
+   * Revert the inventory lots to the given date by removing the inventory lots
+   * transactions after the given date and increment the remaining that
+   * associate to lot number.
+   * @async
+   * @return {Promise}
+   */
+  public async revertInventoryLots(startingDate: Date) {
+    const { InventoryLotCostTracker } = this.tenantModels;
+    const asyncOpers: any[] = [];
+    const inventoryLotsTrans = await InventoryLotCostTracker.query()
+      .modify('filterDateRange', this.startingDate)
+      .orderBy('date', 'DESC')
+      .where('item_id', this.itemId)
+      .where('direction', 'OUT');
+
+    const deleteInvLotsTrans = InventoryLotCostTracker.query()
+      .modify('filterDateRange', this.startingDate)
+      .where('item_id', this.itemId)      
+      .delete();
+
+    inventoryLotsTrans.forEach((inventoryLot: IInventoryLotCost) => {
+      if (!inventoryLot.lotNumber) { return; }
+
+      const incrementOper = InventoryLotCostTracker.query()
+        .where('lot_number', inventoryLot.lotNumber)
+        .where('direction', 'IN')
+        .increment('remaining', inventoryLot.quantity);
+
+      asyncOpers.push(incrementOper);
+    });
+    return Promise.all([deleteInvLotsTrans, ...asyncOpers]);
+  }
+
+  /**
+   * Tracking inventory `IN` lots transactions.
+   * @public
+   * @param {IInventoryTransaction[]} inventoryTransactions -
+   * @return {void}
+   */
+  public trackingInventoryINLots(
+    inventoryTransactions: IInventoryTransaction[],
+  ) {
+    inventoryTransactions.forEach((transaction: IInventoryTransaction) => {
+      const { itemId, id } = transaction;
+      (this.inventoryByItem[itemId] || (this.inventoryByItem[itemId] = []));
+
+      const commonLotTransaction: IInventoryLotCost = {
+        ...pick(transaction, [
+          'date', 'rate', 'itemId', 'quantity', 'invTransId', 'lotTransId',
+          'direction', 'transactionType', 'transactionId', 'lotNumber', 'remaining'
+        ]),
+      };
+      this.inventoryByItem[itemId].push(id);
+      this.inventoryINTrans[id] = {
+        ...commonLotTransaction,
+        decrement: 0,
+        remaining: commonLotTransaction.remaining || commonLotTransaction.quantity,
+      };
+      this.costLotsTransactions.push(this.inventoryINTrans[id]);
+    });
+  }
+
+  /**
+   * Tracking inventory `OUT` lots transactions.
+   * @public
+   * @param {IInventoryTransaction[]} inventoryTransactions -
+   * @return {void}
+   */
+  public trackingInventoryOUTLots(
+    inventoryTransactions: IInventoryTransaction[],
+  ) {
+    inventoryTransactions.forEach((transaction: IInventoryTransaction) => {
+      const { itemId, id } = transaction;
+      (this.inventoryByItem[itemId] || (this.inventoryByItem[itemId] = []));
+
+      const commonLotTransaction: IInventoryLotCost = {
+        ...pick(transaction, [
+          'date', 'rate', 'itemId', 'quantity', 'invTransId', 'lotTransId', 'entryId',
+          'direction', 'transactionType', 'transactionId', 'lotNumber', 'remaining'
+        ]),
+      };
+      let invRemaining = transaction.quantity;
+      const idsShouldDel: number[] = [];
+
+      this.inventoryByItem?.[itemId]?.some((_invTransactionId: number) => {
+        const _invINTransaction = this.inventoryINTrans[_invTransactionId];
+
+        // Can't continue if the IN transaction remaining equals zero.
+        if (invRemaining <= 0) { return true; }
+
+        // Can't continue if the IN transaction date is after the current transaction date.
+        if (moment(_invINTransaction.date).isAfter(transaction.date)) {
+          return true;
+        }
+        // Detarmines the 'OUT' lot tranasctions whether bigger than 'IN' remaining transaction.
+        const biggerThanRemaining = (_invINTransaction.remaining - transaction.quantity) > 0;
+        const decrement = (biggerThanRemaining) ? transaction.quantity : _invINTransaction.remaining;
+        const maxDecrement = Math.min(decrement, invRemaining);
+        const cost = maxDecrement * _invINTransaction.rate;
+
+        _invINTransaction.decrement += maxDecrement;
+        _invINTransaction.remaining = Math.max(
+          _invINTransaction.remaining - maxDecrement,
+          0,
+        );
+        invRemaining = Math.max(invRemaining - maxDecrement, 0);
+
+        this.costLotsTransactions.push({
+          ...commonLotTransaction,
+          cost,
+          quantity: maxDecrement,
+          lotNumber: _invINTransaction.lotNumber,
+        });
+        // Pop the 'IN' lots that has zero remaining. 
+        if (_invINTransaction.remaining === 0) {
+          idsShouldDel.push(_invTransactionId);
+        }
+        return false;
+      });
+      if (invRemaining > 0) {
+        this.costLotsTransactions.push({ 
+          ...commonLotTransaction,
+          quantity: invRemaining,
+        });
+      }
+      this.removeInventoryItems(itemId, idsShouldDel);
+    });
+  }
+
+  /**
+   * Remove inventory transactions for specific item id.
+   * @private
+   * @param {number} itemId 
+   * @param {number[]} idsShouldDel 
+   * @return {void}
+   */
+  private removeInventoryItems(itemId: number, idsShouldDel: number[]) {
+    // Remove the IN transactions that has zero remaining amount.
+    this.inventoryByItem[itemId] = this.inventoryByItem?.[itemId]
+      ?.filter((transId: number) => idsShouldDel.indexOf(transId) === -1);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Inventory/InventoryCostMethod.ts b/packages/server/src/services/Inventory/InventoryCostMethod.ts
new file mode 100644
index 000000000..b90711db7
--- /dev/null
+++ b/packages/server/src/services/Inventory/InventoryCostMethod.ts
@@ -0,0 +1,46 @@
+import { omit } from 'lodash';
+import { Container } from 'typedi';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import { IInventoryLotCost } from '@/interfaces';
+
+export default class InventoryCostMethod {
+  tenancy: TenancyService;
+  tenantModels: any;
+
+  /**
+   * Constructor method.
+   * @param {number} tenantId - The given tenant id.
+   */
+  constructor(tenantId: number, startingDate: Date, itemId: number) {
+    const tenancyService = Container.get(TenancyService);
+
+    this.tenantModels = tenancyService.models(tenantId);
+  }
+
+  /**
+   * Stores the inventory lots costs transactions in bulk.
+   * @param  {IInventoryLotCost[]} costLotsTransactions
+   * @return {Promise[]}
+   */
+  public storeInventoryLotsCost(
+    costLotsTransactions: IInventoryLotCost[]
+  ): Promise<object> {
+    const { InventoryCostLotTracker } = this.tenantModels;
+    const opers: any = [];
+
+    costLotsTransactions.forEach((transaction: any) => {
+      if (transaction.lotTransId && transaction.decrement) {
+        const decrementOper = InventoryCostLotTracker.query(this.trx)
+          .where('id', transaction.lotTransId)
+          .decrement('remaining', transaction.decrement);
+        opers.push(decrementOper);
+      } else if (!transaction.lotTransId) {
+        const operation = InventoryCostLotTracker.query(this.trx).insert({
+          ...omit(transaction, ['decrement', 'invTransId', 'lotTransId']),
+        });
+        opers.push(operation);
+      }
+    });
+    return Promise.all(opers);
+  }
+}
diff --git a/packages/server/src/services/Inventory/InventoryCostsService.ts b/packages/server/src/services/Inventory/InventoryCostsService.ts
new file mode 100644
index 000000000..7008e802f
--- /dev/null
+++ b/packages/server/src/services/Inventory/InventoryCostsService.ts
@@ -0,0 +1,147 @@
+import { keyBy, get } from 'lodash';
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import * as R from 'ramda';
+import { IInventoryItemCostMeta } from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import ItemWarehouseQuantity from 'models/ItemWarehouseQuantity';
+import { ModelUpdateOptions } from 'mongoose';
+
+@Service()
+export class InventoryItemCostService {
+  @Inject()
+  tenancy: TenancyService;
+
+  /**
+   * Common query of items inventory valuation.
+   * @param {number[]} itemsIds - 
+   * @param {Date} date - 
+   * @param {Knex.QueryBuilder} builder - 
+   */
+  private itemsInventoryValuationCommonQuery = R.curry(
+    (itemsIds: number[], date: Date, builder: Knex.QueryBuilder) => {
+      if (date) {
+        builder.where('date', '<', date);
+      }
+      builder.whereIn('item_id', itemsIds);
+      builder.sum('rate as rate');
+      builder.sum('quantity as quantity');
+      builder.sum('cost as cost');
+
+      builder.groupBy('item_id');
+      builder.select(['item_id']);
+    }
+  );
+
+  /**
+   * 
+   * @param {} INValuationMap -
+   * @param {} OUTValuationMap - 
+   * @param {number} itemId
+   */
+  private getItemInventoryMeta = R.curry(
+    (
+      INValuationMap,
+      OUTValuationMap,
+      itemId: number
+    ): IInventoryItemCostMeta => {
+      const INCost = get(INValuationMap, `[${itemId}].cost`, 0);
+      const INQuantity = get(INValuationMap, `[${itemId}].quantity`, 0);
+
+      const OUTCost = get(OUTValuationMap, `[${itemId}].cost`, 0);
+      const OUTQuantity = get(OUTValuationMap, `[${itemId}].quantity`, 0);
+
+      const valuation = INCost - OUTCost;
+      const quantity = INQuantity - OUTQuantity;
+      const average = quantity ? valuation / quantity : 0;
+
+      return { itemId, valuation, quantity, average };
+    }
+  );
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {number} itemsId
+   * @param {Date} date
+   * @returns
+   */
+  private getItemsInventoryINAndOutAggregated = (
+    tenantId: number,
+    itemsId: number[],
+    date: Date
+  ): Promise<any> => {
+    const { InventoryCostLotTracker } = this.tenancy.models(tenantId);
+
+    const commonBuilder = this.itemsInventoryValuationCommonQuery(
+      itemsId,
+      date
+    );
+    const INValuationOper = InventoryCostLotTracker.query()
+      .onBuild(commonBuilder)
+      .where('direction', 'IN');
+
+    const OUTValuationOper = InventoryCostLotTracker.query()
+      .onBuild(commonBuilder)
+      .where('direction', 'OUT');
+
+    return Promise.all([OUTValuationOper, INValuationOper]);
+  };
+
+  /**
+   * 
+   * @param {number} tenantId - 
+   * @param {number[]} itemsIds - 
+   * @param {Date} date - 
+   */
+  private getItemsInventoryInOutMap = async (
+    tenantId: number,
+    itemsId: number[],
+    date: Date
+  ) => {
+    const [OUTValuation, INValuation] =
+      await this.getItemsInventoryINAndOutAggregated(tenantId, itemsId, date);
+
+    const OUTValuationMap = keyBy(OUTValuation, 'itemId');
+    const INValuationMap = keyBy(INValuation, 'itemId');
+
+    return [OUTValuationMap, INValuationMap];
+  };
+
+  /**
+   *
+   * @param   {number} tenantId
+   * @param   {number} itemId
+   * @param   {Date} date
+   * @returns {Promise<Map<number, IInventoryItemCostMeta>>}
+   */
+  public getItemsInventoryValuation = async (
+    tenantId: number,
+    itemsId: number[],
+    date: Date
+  ): Promise<Map<number, IInventoryItemCostMeta>> => {
+    const { Item } = this.tenancy.models(tenantId);
+
+    // Retrieves the inventory items.
+    const items = await Item.query()
+      .whereIn('id', itemsId)
+      .where('type', 'inventory');
+
+    // Retrieves the inventory items ids.
+    const inventoryItemsIds: number[] = items.map((item) => item.id);
+
+    // Retreives the items inventory IN/OUT map.
+    const [OUTValuationMap, INValuationMap] =
+      await this.getItemsInventoryInOutMap(tenantId, itemsId, date);
+
+    const getItemValuation = this.getItemInventoryMeta(
+      INValuationMap,
+      OUTValuationMap
+    );
+    const itemsValuations = inventoryItemsIds.map(getItemValuation);
+    const itemsValuationsMap = new Map(
+      itemsValuations.map((i) => [i.itemId, i])
+    );
+    return itemsValuationsMap;
+  };
+}
diff --git a/packages/server/src/services/Inventory/InventoryItemsQuantitySync.ts b/packages/server/src/services/Inventory/InventoryItemsQuantitySync.ts
new file mode 100644
index 000000000..9d7e832be
--- /dev/null
+++ b/packages/server/src/services/Inventory/InventoryItemsQuantitySync.ts
@@ -0,0 +1,95 @@
+import { Inject, Service } from 'typedi';
+import { toSafeInteger } from 'lodash';
+import { IInventoryTransaction, IItemsQuantityChanges } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import Knex from 'knex';
+
+/**
+ * Syncs the inventory transactions with inventory items quantity.
+ */
+@Service()
+export default class InventoryItemsQuantitySync {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Reverse the given inventory transactions.
+   * @param {IInventoryTransaction[]} inventroyTransactions
+   * @return {IInventoryTransaction[]}
+   */
+  reverseInventoryTransactions(
+    inventroyTransactions: IInventoryTransaction[]
+  ): IInventoryTransaction[] {
+    return inventroyTransactions.map((transaction) => ({
+      ...transaction,
+      direction: transaction.direction === 'OUT' ? 'IN' : 'OUT',
+    }));
+  }
+
+  /**
+   * Reverses the inventory transactions.
+   * @param {IInventoryTransaction[]} inventroyTransactions -
+   * @return {IItemsQuantityChanges[]}
+   */
+  getReverseItemsQuantityChanges(
+    inventroyTransactions: IInventoryTransaction[]
+  ): IItemsQuantityChanges[] {
+    const reversedTransactions = this.reverseInventoryTransactions(
+      inventroyTransactions
+    );
+    return this.getItemsQuantityChanges(reversedTransactions);
+  }
+
+  /**
+   * Retrieve the items quantity changes from the given inventory transactions.
+   * @param {IInventoryTransaction[]} inventroyTransactions - Inventory transactions.
+   * @return {IItemsQuantityChanges[]}
+   */
+  getItemsQuantityChanges(
+    inventroyTransactions: IInventoryTransaction[]
+  ): IItemsQuantityChanges[] {
+    const balanceMap: { [itemId: number]: number } = {};
+
+    inventroyTransactions.forEach(
+      (inventoryTransaction: IInventoryTransaction) => {
+        const { itemId, direction, quantity } = inventoryTransaction;
+
+        if (!balanceMap[itemId]) {
+          balanceMap[itemId] = 0;
+        }
+        balanceMap[itemId] += direction === 'IN' ? quantity : 0;
+        balanceMap[itemId] -= direction === 'OUT' ? quantity : 0;
+      }
+    );
+
+    return Object.entries(balanceMap).map(([itemId, balanceChange]) => ({
+      itemId: toSafeInteger(itemId),
+      balanceChange,
+    }));
+  }
+
+  /**
+   * Changes the items quantity changes.
+   * @param {IItemsQuantityChanges[]} itemsQuantity - Items quantity changes.
+   * @return {Promise<void>}
+   */
+  async changeItemsQuantity(
+    tenantId: number,
+    itemsQuantity: IItemsQuantityChanges[],
+    trx?: Knex.Transaction
+  ): Promise<void> {
+    const { itemRepository } = this.tenancy.repositories(tenantId);
+    const opers = [];
+
+    itemsQuantity.forEach((itemQuantity: IItemsQuantityChanges) => {
+      const changeQuantityOper = itemRepository.changeNumber(
+        { id: itemQuantity.itemId, type: 'inventory' },
+        'quantityOnHand',
+        itemQuantity.balanceChange,
+        trx
+      );
+      opers.push(changeQuantityOper);
+    });
+    await Promise.all(opers);
+  }
+}
diff --git a/packages/server/src/services/Inventory/subscribers/InventoryCostGLBeforeWriteSubscriber.ts b/packages/server/src/services/Inventory/subscribers/InventoryCostGLBeforeWriteSubscriber.ts
new file mode 100644
index 000000000..4ae087238
--- /dev/null
+++ b/packages/server/src/services/Inventory/subscribers/InventoryCostGLBeforeWriteSubscriber.ts
@@ -0,0 +1,36 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import { IInventoryCostLotsGLEntriesWriteEvent } from '@/interfaces';
+import { InventoryCostGLStorage } from '../InventoryCostGLStorage';
+
+@Service()
+export class InventoryCostGLBeforeWriteSubscriber {
+  @Inject()
+  private inventoryCostGLStorage: InventoryCostGLStorage;
+
+  /**
+   * Attaches events.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.inventory.onCostLotsGLEntriesBeforeWrite,
+      this.revertsInventoryCostGLEntries
+    );
+  }
+
+  /**
+   * Writes the receipts cost GL entries once the inventory cost lots be written.
+   * @param {IInventoryCostLotsGLEntriesWriteEvent}
+   */
+  private revertsInventoryCostGLEntries = async ({
+    trx,
+    startingDate,
+    tenantId,
+  }: IInventoryCostLotsGLEntriesWriteEvent) => {
+    await this.inventoryCostGLStorage.revertInventoryCostGLEntries(
+      tenantId,
+      startingDate,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Inventory/utils.ts b/packages/server/src/services/Inventory/utils.ts
new file mode 100644
index 000000000..f961694b1
--- /dev/null
+++ b/packages/server/src/services/Inventory/utils.ts
@@ -0,0 +1,15 @@
+import { chain } from 'lodash';
+
+/**
+ * Grpups by transaction type and id the inventory transactions.
+ * @param {IInventoryTransaction} invTransactions
+ * @returns
+ */
+export function groupInventoryTransactionsByTypeId(
+  transactions: { transactionType: string; transactionId: number }[]
+): { transactionType: string; transactionId: number }[][] {
+  return chain(transactions)
+    .groupBy((t) => `${t.transactionType}-${t.transactionId}`)
+    .values()
+    .value();
+}
diff --git a/packages/server/src/services/InviteUsers/AcceptInviteUser.ts b/packages/server/src/services/InviteUsers/AcceptInviteUser.ts
new file mode 100644
index 000000000..628e630ac
--- /dev/null
+++ b/packages/server/src/services/InviteUsers/AcceptInviteUser.ts
@@ -0,0 +1,146 @@
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import { ServiceError } from '@/exceptions';
+import { Invite, SystemUser, Tenant } from '@/system/models';
+import { hashPassword } from 'utils';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import InviteUsersMailMessages from '@/services/InviteUsers/InviteUsersMailMessages';
+import events from '@/subscribers/events';
+import {
+  IAcceptInviteEventPayload,
+  IInviteUserInput,
+  ICheckInviteEventPayload,
+  IUserInvite,
+} from '@/interfaces';
+import TenantsManagerService from '@/services/Tenancy/TenantsManager';
+import { ERRORS } from './constants';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+@Service()
+export default class AcceptInviteUserService {
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  mailMessages: InviteUsersMailMessages;
+
+  @Inject('repositories')
+  sysRepositories: any;
+
+  @Inject()
+  tenantsManager: TenantsManagerService;
+
+  /**
+   * Accept the received invite.
+   * @param {string} token
+   * @param {IInviteUserInput} inviteUserInput
+   * @throws {ServiceErrors}
+   * @returns {Promise<void>}
+   */
+  public async acceptInvite(
+    token: string,
+    inviteUserDTO: IInviteUserInput
+  ): Promise<void> {
+    // Retrieve the invite token or throw not found error.
+    const inviteToken = await this.getInviteTokenOrThrowError(token);
+
+    // Validates the user phone number.
+    await this.validateUserPhoneNumberNotExists(inviteUserDTO.phoneNumber);
+
+    // Hash the given password.
+    const hashedPassword = await hashPassword(inviteUserDTO.password);
+
+    // Retrieve the system user.
+    const user = await SystemUser.query().findOne('email', inviteToken.email);
+
+    // Sets the invited user details after invite accepting.
+    const systemUser = await SystemUser.query().updateAndFetchById(
+      inviteToken.userId,
+      {
+        ...inviteUserDTO,
+        inviteAcceptedAt: moment().format('YYYY-MM-DD'),
+        password: hashedPassword,
+      }
+    );
+    // Clear invite token by the given user id.
+    await this.clearInviteTokensByUserId(inviteToken.userId);
+
+    // Triggers `onUserAcceptInvite` event.
+    await this.eventPublisher.emitAsync(events.inviteUser.acceptInvite, {
+      inviteToken,
+      user: systemUser,
+      inviteUserDTO,
+    } as IAcceptInviteEventPayload);
+  }
+
+  /**
+   * Validate the given invite token.
+   * @param {string} token - the given token string.
+   * @throws {ServiceError}
+   */
+  public async checkInvite(
+    token: string
+  ): Promise<{ inviteToken: IUserInvite; orgName: object }> {
+    const inviteToken = await this.getInviteTokenOrThrowError(token);
+
+    // Find the tenant that associated to the given token.
+    const tenant = await Tenant.query()
+      .findById(inviteToken.tenantId)
+      .withGraphFetched('metadata');
+
+    // Triggers `onUserCheckInvite` event.
+    await this.eventPublisher.emitAsync(events.inviteUser.checkInvite, {
+      inviteToken,
+      tenant,
+    } as ICheckInviteEventPayload);
+
+    return { inviteToken, orgName: tenant.metadata.name };
+  }
+
+  /**
+   * Retrieve invite model from the given token or throw error.
+   * @param {string} token - Then given token string.
+   * @throws {ServiceError}
+   * @returns {Invite}
+   */
+  private getInviteTokenOrThrowError = async (
+    token: string
+  ): Promise<IUserInvite> => {
+    const inviteToken = await Invite.query()
+      .modify('notExpired')
+      .findOne('token', token);
+
+    if (!inviteToken) {
+      throw new ServiceError(ERRORS.INVITE_TOKEN_INVALID);
+    }
+    return inviteToken;
+  };
+
+  /**
+   * Validate the given user email and phone number uniquine.
+   * @param {IInviteUserInput} inviteUserInput
+   */
+  private validateUserPhoneNumberNotExists = async (
+    phoneNumber: string
+  ): Promise<void> => {
+    const foundUser = await SystemUser.query().findOne({ phoneNumber });
+
+    if (foundUser) {
+      throw new ServiceError(ERRORS.PHONE_NUMBER_EXISTS);
+    }
+  };
+
+  /**
+   * Clear invite tokens of the given user id.
+   * @param {number} userId - User id.
+   */
+  private clearInviteTokensByUserId = async (userId: number) => {
+    await Invite.query().where('user_id', userId).delete();
+  };
+}
diff --git a/packages/server/src/services/InviteUsers/InviteSendMailNotification.ts b/packages/server/src/services/InviteUsers/InviteSendMailNotification.ts
new file mode 100644
index 000000000..00482b38a
--- /dev/null
+++ b/packages/server/src/services/InviteUsers/InviteSendMailNotification.ts
@@ -0,0 +1,39 @@
+import {
+  IUserInvitedEventPayload,
+  IUserInviteTenantSyncedEventPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import { Inject, Service } from 'typedi';
+
+@Service()
+export default class InviteSendMainNotificationSubscribe {
+  @Inject('agenda')
+  agenda: any;
+
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.inviteUser.sendInviteTenantSynced,
+      this.sendMailNotification
+    );
+  }
+
+  /**
+   * Sends mail notification.
+   * @param {IUserInvitedEventPayload} payload
+   */
+  private sendMailNotification = (
+    payload: IUserInviteTenantSyncedEventPayload
+  ) => {
+    const { invite, authorizedUser, tenantId } = payload;
+
+    this.agenda.now('user-invite-mail', {
+      invite,
+      authorizedUser,
+      tenantId,
+    });
+  };
+}
diff --git a/packages/server/src/services/InviteUsers/InviteUsersMailMessages.ts b/packages/server/src/services/InviteUsers/InviteUsersMailMessages.ts
new file mode 100644
index 000000000..957c6e362
--- /dev/null
+++ b/packages/server/src/services/InviteUsers/InviteUsersMailMessages.ts
@@ -0,0 +1,46 @@
+import { ISystemUser } from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import Mail from '@/lib/Mail';
+import { Service, Container } from 'typedi';
+import config from '@/config';
+import { Tenant } from '@/system/models';
+
+@Service()
+export default class InviteUsersMailMessages {
+  /**
+   * Sends invite mail to the given email.
+   * @param user
+   * @param invite
+   */
+  async sendInviteMail(tenantId: number, fromUser: ISystemUser, invite: any) {
+    // Retreive tenant orgnaization name.
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const root = __dirname + '/../../../views/images/bigcapital.png';
+
+    const mail = new Mail()
+      .setSubject(`${fromUser.firstName} has invited you to join a Bigcapital`)
+      .setView('mail/UserInvite.html')
+      .setTo(invite.email)
+      .setAttachments([
+        {
+          filename: 'bigcapital.png',
+          path: root,
+          cid: 'bigcapital_logo',
+        },
+      ])
+      .setData({
+        root,
+        acceptUrl: `${config.baseURL}/auth/invite/${invite.token}/accept`,
+        fullName: `${fromUser.firstName} ${fromUser.lastName}`,
+        firstName: fromUser.firstName,
+        lastName: fromUser.lastName,
+        email: fromUser.email,
+        organizationName: tenant.metadata.name,
+      });
+
+    await mail.send();
+  }
+}
diff --git a/packages/server/src/services/InviteUsers/InviteUsersSMSMessages.ts b/packages/server/src/services/InviteUsers/InviteUsersSMSMessages.ts
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/server/src/services/InviteUsers/SyncSystemSendInvite.ts b/packages/server/src/services/InviteUsers/SyncSystemSendInvite.ts
new file mode 100644
index 000000000..58dbe141b
--- /dev/null
+++ b/packages/server/src/services/InviteUsers/SyncSystemSendInvite.ts
@@ -0,0 +1,109 @@
+import { Inject, Service } from 'typedi';
+import {
+  IUserInvitedEventPayload,
+  IUserInviteResendEventPayload,
+  IUserInviteTenantSyncedEventPayload,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import { Invite, SystemUser } from '@/system/models';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+@Service()
+export default class SyncSystemSendInvite {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  public attach(bus) {
+    bus.subscribe(events.inviteUser.sendInvite, this.syncSendInviteSystem);
+    bus.subscribe(
+      events.inviteUser.resendInvite,
+      this.syncResendInviteSystemUser
+    );
+  }
+
+  /**
+   * Syncs send invite to system user.
+   * @param {IUserInvitedEventPayload} payload -
+   */
+  private syncSendInviteSystem = async ({
+    inviteToken,
+    user,
+    tenantId,
+    authorizedUser,
+  }: IUserInvitedEventPayload) => {
+    const { User } = this.tenancy.models(tenantId);
+
+    // Creates a new system user.
+    const systemUser = await SystemUser.query().insert({
+      email: user.email,
+      active: user.active,
+      tenantId,
+    });
+    // Creates a invite user token.
+    const invite = await Invite.query().insert({
+      email: user.email,
+      tenantId,
+      userId: systemUser.id,
+      token: inviteToken,
+    });
+    // Links the tenant user with created system user.
+    await User.query().findById(user.id).patch({
+      systemUserId: systemUser.id,
+    });
+    // Triggers `onUserSendInviteTenantSynced` event.
+    await this.eventPublisher.emitAsync(
+      events.inviteUser.sendInviteTenantSynced,
+      {
+        invite,
+        tenantId,
+        user,
+        authorizedUser,
+      } as IUserInviteTenantSyncedEventPayload
+    );
+  };
+
+  /**
+   * Syncs resend invite to system user.
+   * @param {IUserInviteResendEventPayload} payload -
+   */
+  private syncResendInviteSystemUser = async ({
+    inviteToken,
+    authorizedUser,
+    tenantId,
+    user,
+  }: IUserInviteResendEventPayload) => {
+    // Clear all invite tokens of the given user id.
+    await this.clearInviteTokensByUserId(user.systemUserId, tenantId);
+
+    const invite = await Invite.query().insert({
+      email: user.email,
+      tenantId,
+      userId: user.systemUserId,
+      token: inviteToken,
+    });
+  };
+
+  /**
+   * Clear invite tokens of the given user id.
+   * @param {number} userId - User id.
+   */
+  private clearInviteTokensByUserId = async (
+    userId: number,
+    tenantId: number
+  ) => {
+    await Invite.query()
+      .where({
+        userId,
+        tenantId,
+      })
+      .delete();
+  };
+}
diff --git a/packages/server/src/services/InviteUsers/SyncTenantAcceptInvite.ts b/packages/server/src/services/InviteUsers/SyncTenantAcceptInvite.ts
new file mode 100644
index 000000000..c5eb2d648
--- /dev/null
+++ b/packages/server/src/services/InviteUsers/SyncTenantAcceptInvite.ts
@@ -0,0 +1,39 @@
+import { Service, Inject } from 'typedi';
+import { omit } from 'lodash';
+import moment from 'moment';
+import events from '@/subscribers/events';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { IAcceptInviteEventPayload } from '@/interfaces';
+
+@Service()
+export default class SyncTenantAcceptInvite {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  public attach(bus) {
+    bus.subscribe(events.inviteUser.acceptInvite, this.syncTenantAcceptInvite);
+  }
+
+  /**
+   * Syncs accept invite to tenant user.
+   * @param {IAcceptInviteEventPayload} payload -
+   */
+  private syncTenantAcceptInvite = async ({
+    inviteToken,
+    user,
+    inviteUserDTO,
+  }: IAcceptInviteEventPayload) => {
+    const { User } = this.tenancy.models(inviteToken.tenantId);
+
+    await User.query()
+      .where('systemUserId', inviteToken.userId)
+      .update({
+        ...omit(inviteUserDTO, ['password']),
+        inviteAcceptedAt: moment().format('YYYY-MM-DD'),
+      });
+  };
+}
diff --git a/packages/server/src/services/InviteUsers/TenantInviteUser.ts b/packages/server/src/services/InviteUsers/TenantInviteUser.ts
new file mode 100644
index 000000000..d5fd09514
--- /dev/null
+++ b/packages/server/src/services/InviteUsers/TenantInviteUser.ts
@@ -0,0 +1,188 @@
+import { Service, Inject } from 'typedi';
+import uniqid from 'uniqid';
+import moment from 'moment';
+import { ServiceError } from '@/exceptions';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import InviteUsersMailMessages from '@/services/InviteUsers/InviteUsersMailMessages';
+import events from '@/subscribers/events';
+import {
+  ISystemUser,
+  IUserSendInviteDTO,
+  IInviteUserService,
+  ITenantUser,
+  IUserInvitedEventPayload,
+  IUserInviteResendEventPayload,
+} from '@/interfaces';
+import TenantsManagerService from '@/services/Tenancy/TenantsManager';
+import { ERRORS } from './constants';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import RolesService from '@/services/Roles/RolesService';
+
+@Service()
+export default class InviteTenantUserService implements IInviteUserService {
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  mailMessages: InviteUsersMailMessages;
+
+  @Inject('repositories')
+  sysRepositories: any;
+
+  @Inject()
+  tenantsManager: TenantsManagerService;
+
+  @Inject()
+  rolesService: RolesService;
+
+  /**
+   * Sends invite mail to the given email from the given tenant and user.
+   * @param {number} tenantId -
+   * @param {string} email -
+   * @param {IUser} authorizedUser -
+   * @return {Promise<IUserInvite>}
+   */
+  public async sendInvite(
+    tenantId: number,
+    sendInviteDTO: IUserSendInviteDTO,
+    authorizedUser: ISystemUser
+  ): Promise<{
+    invitedUser: ITenantUser;
+  }> {
+    const { User } = this.tenancy.models(tenantId);
+
+    // Get the given role or throw not found service error.
+    const role = await this.rolesService.getRoleOrThrowError(
+      tenantId,
+      sendInviteDTO.roleId
+    );
+    // Validates the given email not exists on the storage.
+    await this.validateUserEmailNotExists(tenantId, sendInviteDTO.email);
+
+    // Generates a new invite token.
+    const inviteToken = uniqid();
+
+    // Creates and fetches a tenant user.
+    const user = await User.query().insertAndFetch({
+      email: sendInviteDTO.email,
+      roleId: sendInviteDTO.roleId,
+      active: true,
+      invitedAt: new Date(),
+    });
+    // Triggers `onUserSendInvite` event.
+    await this.eventPublisher.emitAsync(events.inviteUser.sendInvite, {
+      inviteToken,
+      authorizedUser,
+      tenantId,
+      user,
+    } as IUserInvitedEventPayload);
+
+    return { invitedUser: user };
+  }
+
+  /**
+   * Re-send user invite.
+   * @param  {number} tenantId -
+   * @param  {string} email    -
+   * @return {Promise<{ invite: IUserInvite }>}
+   */
+  public async resendInvite(
+    tenantId: number,
+    userId: number,
+    authorizedUser: ISystemUser
+  ): Promise<{
+    user: ITenantUser;
+  }> {
+    const { User } = this.tenancy.models(tenantId);
+
+    // Retrieve the user by id or throw not found service error.
+    const user = await this.getUserByIdOrThrowError(tenantId, userId);
+
+    // Validate the user is not invited recently.
+    this.validateUserInviteThrottle(user);
+
+    // Validate the given user is not accepted yet.
+    this.validateInviteUserNotAccept(user);
+
+    // Generates a new invite token.
+    const inviteToken = uniqid();
+
+    // Triggers `onUserSendInvite` event.
+    await this.eventPublisher.emitAsync(events.inviteUser.resendInvite, {
+      authorizedUser,
+      tenantId,
+      user,
+      inviteToken,
+    } as IUserInviteResendEventPayload);
+
+    return { user };
+  }
+
+  /**
+   * Validate the given user has no active invite token.
+   * @param {number} tenantId
+   * @param {number} userId - User id.
+   */
+  private validateInviteUserNotAccept = (user: ITenantUser) => {
+    // Throw the error if the one invite tokens is still active.
+    if (user.inviteAcceptedAt) {
+      throw new ServiceError(ERRORS.USER_RECENTLY_INVITED);
+    }
+  };
+
+  /**
+   * Validates user invite is not invited recently before specific time point.
+   * @param {ITenantUser} user
+   */
+  private validateUserInviteThrottle = (user: ITenantUser) => {
+    const PARSE_FORMAT = 'M/D/YYYY, H:mm:ss A';
+    const beforeTime = moment().subtract(5, 'minutes');
+
+    if (moment(user.invitedAt, PARSE_FORMAT).isAfter(beforeTime)) {
+      throw new ServiceError(ERRORS.USER_RECENTLY_INVITED);
+    }
+  };
+
+  /**
+   * Retrieve the given user by id or throw not found service error.
+   * @param {number} userId - User id.
+   */
+  private getUserByIdOrThrowError = async (
+    tenantId: number,
+    userId: number
+  ): Promise<ITenantUser> => {
+    const { User } = this.tenancy.models(tenantId);
+
+    // Retrieve the tenant user.
+    const user = await User.query().findById(userId);
+
+    // Throw if the user not found.
+    if (!user) {
+      throw new ServiceError(ERRORS.USER_NOT_FOUND);
+    }
+    return user;
+  };
+
+  /**
+   * Throws error in case the given user email not exists on the storage.
+   * @param {string} email
+   * @throws {ServiceError}
+   */
+  private async validateUserEmailNotExists(
+    tenantId: number,
+    email: string
+  ): Promise<void> {
+    const { User } = this.tenancy.models(tenantId);
+    const foundUser = await User.query().findOne('email', email);
+
+    if (foundUser) {
+      throw new ServiceError(ERRORS.EMAIL_EXISTS);
+    }
+  }
+}
diff --git a/packages/server/src/services/InviteUsers/constants.ts b/packages/server/src/services/InviteUsers/constants.ts
new file mode 100644
index 000000000..1e0516917
--- /dev/null
+++ b/packages/server/src/services/InviteUsers/constants.ts
@@ -0,0 +1,11 @@
+
+
+export const ERRORS = {
+  EMAIL_ALREADY_INVITED: 'EMAIL_ALREADY_INVITED',
+  INVITE_TOKEN_INVALID: 'INVITE_TOKEN_INVALID',
+  PHONE_NUMBER_EXISTS: 'PHONE_NUMBER_EXISTS',
+  USER_NOT_FOUND: 'USER_NOT_FOUND',
+  EMAIL_EXISTS: 'EMAIL_EXISTS',
+  EMAIL_NOT_EXISTS: 'EMAIL_NOT_EXISTS',
+  USER_RECENTLY_INVITED: 'USER_RECENTLY_INVITED',
+};
\ No newline at end of file
diff --git a/packages/server/src/services/ItemCategories/ItemCategoriesService.ts b/packages/server/src/services/ItemCategories/ItemCategoriesService.ts
new file mode 100644
index 000000000..76a6f1c18
--- /dev/null
+++ b/packages/server/src/services/ItemCategories/ItemCategoriesService.ts
@@ -0,0 +1,375 @@
+import { Inject } from 'typedi';
+import * as R from 'ramda';
+import Knex from 'knex';
+import { ServiceError } from '@/exceptions';
+import {
+  IItemCategory,
+  IItemCategoryOTD,
+  IItemCategoriesService,
+  IItemCategoriesFilter,
+  ISystemUser,
+  IFilterMeta,
+  IItemCategoryCreatedPayload,
+  IItemCategoryEditedPayload,
+  IItemCategoryDeletedPayload,
+} from '@/interfaces';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import { ACCOUNT_ROOT_TYPE, ACCOUNT_TYPE } from '@/data/AccountTypes';
+import { ERRORS } from './constants';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+export default class ItemCategoriesService implements IItemCategoriesService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  /**
+   * Retrieve item category or throw not found error.
+   * @param {number} tenantId
+   * @param {number} itemCategoryId
+   */
+  private async getItemCategoryOrThrowError(
+    tenantId: number,
+    itemCategoryId: number
+  ) {
+    const { ItemCategory } = this.tenancy.models(tenantId);
+    const category = await ItemCategory.query().findById(itemCategoryId);
+
+    if (!category) {
+      throw new ServiceError(ERRORS.CATEGORY_NOT_FOUND);
+    }
+    return category;
+  }
+
+  /**
+   * Transforms OTD to model object.
+   * @param {IItemCategoryOTD} itemCategoryOTD
+   * @param {ISystemUser} authorizedUser
+   */
+  private transformOTDToObject(
+    itemCategoryOTD: IItemCategoryOTD,
+    authorizedUser: ISystemUser
+  ) {
+    return { ...itemCategoryOTD, userId: authorizedUser.id };
+  }
+
+  /**
+   * Retrieve item category of the given id.
+   * @param {number} tenantId -
+   * @param {number} itemCategoryId -
+   * @returns {IItemCategory}
+   */
+  public async getItemCategory(
+    tenantId: number,
+    itemCategoryId: number,
+    user: ISystemUser
+  ) {
+    return this.getItemCategoryOrThrowError(tenantId, itemCategoryId);
+  }
+
+  /**
+   * Validates the category name uniquiness.
+   * @param {number} tenantId - Tenant id.
+   * @param {string} categoryName - Category name.
+   * @param {number} notAccountId - Ignore the account id.
+   */
+  private async validateCategoryNameUniquiness(
+    tenantId: number,
+    categoryName: string,
+    notCategoryId?: number
+  ) {
+    const { ItemCategory } = this.tenancy.models(tenantId);
+
+    const foundItemCategory = await ItemCategory.query()
+      .findOne('name', categoryName)
+      .onBuild((query) => {
+        if (notCategoryId) {
+          query.whereNot('id', notCategoryId);
+        }
+      });
+    if (foundItemCategory) {
+      throw new ServiceError(ERRORS.CATEGORY_NAME_EXISTS);
+    }
+  }
+
+  /**
+   * Inserts a new item category.
+   * @param {number} tenantId
+   * @param {IItemCategoryOTD} itemCategoryOTD
+   * @return {Promise<void>}
+   */
+  public async newItemCategory(
+    tenantId: number,
+    itemCategoryOTD: IItemCategoryOTD,
+    authorizedUser: ISystemUser
+  ): Promise<IItemCategory> {
+    const { ItemCategory } = this.tenancy.models(tenantId);
+
+    // Validate the category name uniquiness.
+    await this.validateCategoryNameUniquiness(tenantId, itemCategoryOTD.name);
+
+    if (itemCategoryOTD.sellAccountId) {
+      await this.validateSellAccount(tenantId, itemCategoryOTD.sellAccountId);
+    }
+    if (itemCategoryOTD.costAccountId) {
+      await this.validateCostAccount(tenantId, itemCategoryOTD.costAccountId);
+    }
+    if (itemCategoryOTD.inventoryAccountId) {
+      await this.validateInventoryAccount(
+        tenantId,
+        itemCategoryOTD.inventoryAccountId
+      );
+    }
+    const itemCategoryObj = this.transformOTDToObject(
+      itemCategoryOTD,
+      authorizedUser
+    );
+    // Creates item category under unit-of-work evnirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Inserts the item category.
+      const itemCategory = await ItemCategory.query(trx).insert({
+        ...itemCategoryObj,
+      });
+      // Triggers `onItemCategoryCreated` event.
+      await this.eventPublisher.emitAsync(events.itemCategory.onCreated, {
+        itemCategory,
+        tenantId,
+        trx,
+      } as IItemCategoryCreatedPayload);
+
+      return itemCategory;
+    });
+  }
+
+  /**
+   * Validates sell account existance and type.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} sellAccountId - Sell account id.
+   * @return {Promise<void>}
+   */
+  private async validateSellAccount(tenantId: number, sellAccountId: number) {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    const foundAccount = await accountRepository.findOneById(sellAccountId);
+
+    if (!foundAccount) {
+      throw new ServiceError(ERRORS.SELL_ACCOUNT_NOT_FOUND);
+    } else if (!foundAccount.isRootType(ACCOUNT_ROOT_TYPE.INCOME)) {
+      throw new ServiceError(ERRORS.SELL_ACCOUNT_NOT_INCOME);
+    }
+  }
+
+  /**
+   * Validates COGS account existance and type.
+   * @param {number} tenantId -
+   * @param {number} costAccountId -
+   * @return {Promise<void>}
+   */
+  private async validateCostAccount(tenantId: number, costAccountId: number) {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    const foundAccount = await accountRepository.findOneById(costAccountId);
+
+    if (!foundAccount) {
+      throw new ServiceError(ERRORS.COST_ACCOUNT_NOT_FOUMD);
+    } else if (!foundAccount.isRootType(ACCOUNT_ROOT_TYPE.EXPENSE)) {
+      throw new ServiceError(ERRORS.COST_ACCOUNT_NOT_COGS);
+    }
+  }
+
+  /**
+   * Validates inventory account existance and type.
+   * @param {number} tenantId
+   * @param {number} inventoryAccountId
+   * @return {Promise<void>}
+   */
+  private async validateInventoryAccount(
+    tenantId: number,
+    inventoryAccountId: number
+  ) {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    const foundAccount = await accountRepository.findOneById(
+      inventoryAccountId
+    );
+    if (!foundAccount) {
+      throw new ServiceError(ERRORS.INVENTORY_ACCOUNT_NOT_FOUND);
+    } else if (!foundAccount.isAccountType(ACCOUNT_TYPE.INVENTORY)) {
+      throw new ServiceError(ERRORS.INVENTORY_ACCOUNT_NOT_INVENTORY);
+    }
+  }
+
+  /**
+   * Edits item category.
+   * @param {number} tenantId
+   * @param {number} itemCategoryId
+   * @param {IItemCategoryOTD} itemCategoryOTD
+   * @return {Promise<void>}
+   */
+  public async editItemCategory(
+    tenantId: number,
+    itemCategoryId: number,
+    itemCategoryOTD: IItemCategoryOTD,
+    authorizedUser: ISystemUser
+  ): Promise<IItemCategory> {
+    const { ItemCategory } = this.tenancy.models(tenantId);
+
+    // Retrieve the item category from the storage.
+    const oldItemCategory = await this.getItemCategoryOrThrowError(
+      tenantId,
+      itemCategoryId
+    );
+    // Validate the category name whether unique on the storage.
+    await this.validateCategoryNameUniquiness(
+      tenantId,
+      itemCategoryOTD.name,
+      itemCategoryId
+    );
+    if (itemCategoryOTD.sellAccountId) {
+      await this.validateSellAccount(tenantId, itemCategoryOTD.sellAccountId);
+    }
+    if (itemCategoryOTD.costAccountId) {
+      await this.validateCostAccount(tenantId, itemCategoryOTD.costAccountId);
+    }
+    if (itemCategoryOTD.inventoryAccountId) {
+      await this.validateInventoryAccount(
+        tenantId,
+        itemCategoryOTD.inventoryAccountId
+      );
+    }
+    const itemCategoryObj = this.transformOTDToObject(
+      itemCategoryOTD,
+      authorizedUser
+    );
+    //
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      //
+      const itemCategory = await ItemCategory.query().patchAndFetchById(
+        itemCategoryId,
+        { ...itemCategoryObj }
+      );
+      // Triggers `onItemCategoryEdited` event.
+      await this.eventPublisher.emitAsync(events.itemCategory.onEdited, {
+        oldItemCategory,
+        tenantId,
+        trx,
+      } as IItemCategoryEditedPayload);
+
+      return itemCategory;
+    });
+  }
+
+  /**
+   * Deletes the given item category.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} itemCategoryId - Item category id.
+   * @return {Promise<void>}
+   */
+  public async deleteItemCategory(
+    tenantId: number,
+    itemCategoryId: number,
+    authorizedUser: ISystemUser
+  ) {
+    const { ItemCategory } = this.tenancy.models(tenantId);
+
+    // Retrieve item category or throw not found error.
+    const oldItemCategory = await this.getItemCategoryOrThrowError(
+      tenantId,
+      itemCategoryId
+    );
+
+    //
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Unassociate items with item category.
+      await this.unassociateItemsWithCategories(tenantId, itemCategoryId, trx);
+
+      //
+      await ItemCategory.query(trx).findById(itemCategoryId).delete();
+
+      //
+      await this.eventPublisher.emitAsync(events.itemCategory.onDeleted, {
+        tenantId,
+        itemCategoryId,
+        oldItemCategory,
+      } as IItemCategoryDeletedPayload);
+    });
+  }
+ 
+  /**
+   * Parses items categories filter DTO.
+   * @param {} filterDTO
+   * @returns
+   */
+  private parsesListFilterDTO(filterDTO) {
+    return R.compose(
+      // Parses stringified filter roles.
+      this.dynamicListService.parseStringifiedFilter
+    )(filterDTO);
+  }
+
+  /**
+   * Retrieve item categories list.
+   * @param {number} tenantId
+   * @param filter
+   */
+  public async getItemCategoriesList(
+    tenantId: number,
+    filterDTO: IItemCategoriesFilter,
+    authorizedUser: ISystemUser
+  ): Promise<{ itemCategories: IItemCategory[]; filterMeta: IFilterMeta }> {
+    const { ItemCategory } = this.tenancy.models(tenantId);
+
+    // Parses list filter DTO.
+    const filter = this.parsesListFilterDTO(filterDTO);
+
+    // Dynamic list service.
+    const dynamicList = await this.dynamicListService.dynamicList(
+      tenantId,
+      ItemCategory,
+      filter
+    );
+    // Items categories.
+    const itemCategories = await ItemCategory.query().onBuild((query) => {
+      // Subquery to calculate sumation of assocaited items to the item category.
+      query.select('*', ItemCategory.relatedQuery('items').count().as('count'));
+
+      dynamicList.buildQuery()(query);
+    });
+    return { itemCategories, filterMeta: dynamicList.getResponseMeta() };
+  }
+
+  /**
+   * Unlink items relations with item categories.
+   * @param {number} tenantId
+   * @param {number|number[]} itemCategoryId -
+   * @return {Promise<void>}
+   */
+  private async unassociateItemsWithCategories(
+    tenantId: number,
+    itemCategoryId: number | number[],
+    trx?: Knex.Transaction
+  ): Promise<void> {
+    const { Item } = this.tenancy.models(tenantId);
+    const ids = Array.isArray(itemCategoryId)
+      ? itemCategoryId
+      : [itemCategoryId];
+
+    await Item.query(trx)
+      .whereIn('category_id', ids)
+      .patch({ category_id: null });
+  }
+}
diff --git a/packages/server/src/services/ItemCategories/constants.ts b/packages/server/src/services/ItemCategories/constants.ts
new file mode 100644
index 000000000..bbf5aea77
--- /dev/null
+++ b/packages/server/src/services/ItemCategories/constants.ts
@@ -0,0 +1,13 @@
+// eslint-disable-next-line import/prefer-default-export
+export const ERRORS = {
+  ITEM_CATEGORIES_NOT_FOUND: 'ITEM_CATEGORIES_NOT_FOUND',
+  CATEGORY_NAME_EXISTS: 'CATEGORY_NAME_EXISTS',
+  CATEGORY_NOT_FOUND: 'CATEGORY_NOT_FOUND',
+  COST_ACCOUNT_NOT_FOUMD: 'COST_ACCOUNT_NOT_FOUMD',
+  COST_ACCOUNT_NOT_COGS: 'COST_ACCOUNT_NOT_COGS',
+  SELL_ACCOUNT_NOT_INCOME: 'SELL_ACCOUNT_NOT_INCOME',
+  SELL_ACCOUNT_NOT_FOUND: 'SELL_ACCOUNT_NOT_FOUND',
+  INVENTORY_ACCOUNT_NOT_FOUND: 'INVENTORY_ACCOUNT_NOT_FOUND',
+  INVENTORY_ACCOUNT_NOT_INVENTORY: 'INVENTORY_ACCOUNT_NOT_INVENTORY',
+  CATEGORY_HAVE_ITEMS: 'CATEGORY_HAVE_ITEMS',
+};
diff --git a/packages/server/src/services/Items/ActivateItem.ts b/packages/server/src/services/Items/ActivateItem.ts
new file mode 100644
index 000000000..1e417d881
--- /dev/null
+++ b/packages/server/src/services/Items/ActivateItem.ts
@@ -0,0 +1,40 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+
+@Service()
+export class ActivateItem {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  /**
+   * Activates the given item on the storage.
+   * @param {number} tenantId -
+   * @param {number} itemId -
+   * @return {Promise<void>}
+   */
+  public async activateItem(tenantId: number, itemId: number): Promise<void> {
+    const { Item } = this.tenancy.models(tenantId);
+
+    // Retreives the given item or throw not found error.
+    const oldItem = await Item.query().findById(itemId).throwIfNotFound();
+
+    // Activate the given item with associated transactions under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Mutate item on the storage.
+      await Item.query(trx).findById(itemId).patch({ active: true });
+
+      // Triggers `onItemActivated` event.
+      await this.eventPublisher.emitAsync(events.item.onActivated, {});
+    });
+  }
+}
diff --git a/packages/server/src/services/Items/CreateItem.ts b/packages/server/src/services/Items/CreateItem.ts
new file mode 100644
index 000000000..ffebdae3d
--- /dev/null
+++ b/packages/server/src/services/Items/CreateItem.ts
@@ -0,0 +1,106 @@
+import { Knex } from 'knex';
+import { defaultTo } from 'lodash';
+import { Service, Inject } from 'typedi';
+import { IItem, IItemDTO, IItemEventCreatedPayload } from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import { ItemsValidators } from './ItemValidators';
+
+@Service()
+export class CreateItem {
+  @Inject()
+  private validators: ItemsValidators;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  /**
+   * Authorize the creating item.
+   * @param {number} tenantId
+   * @param {IItemDTO} itemDTO
+   */
+  async authorize(tenantId: number, itemDTO: IItemDTO) {
+    // Validate whether the given item name already exists on the storage.
+    await this.validators.validateItemNameUniquiness(tenantId, itemDTO.name);
+
+    if (itemDTO.categoryId) {
+      await this.validators.validateItemCategoryExistance(
+        tenantId,
+        itemDTO.categoryId
+      );
+    }
+    if (itemDTO.sellAccountId) {
+      await this.validators.validateItemSellAccountExistance(
+        tenantId,
+        itemDTO.sellAccountId
+      );
+    }
+    if (itemDTO.costAccountId) {
+      await this.validators.validateItemCostAccountExistance(
+        tenantId,
+        itemDTO.costAccountId
+      );
+    }
+    if (itemDTO.inventoryAccountId) {
+      await this.validators.validateItemInventoryAccountExistance(
+        tenantId,
+        itemDTO.inventoryAccountId
+      );
+    }
+  }
+
+  /**
+   * Transforms the item DTO to model.
+   * @param  {IItemDTO} itemDTO - Item DTO.
+   * @return {IItem}
+   */
+  private transformNewItemDTOToModel(itemDTO: IItemDTO) {
+    return {
+      ...itemDTO,
+      active: defaultTo(itemDTO.active, 1),
+      quantityOnHand: itemDTO.type === 'inventory' ? 0 : null,
+    };
+  }
+
+  /**
+   * Creates a new item.
+   * @param {number} tenantId DTO
+   * @param {IItemDTO} item
+   * @return {Promise<IItem>}
+   */
+  public async createItem(tenantId: number, itemDTO: IItemDTO): Promise<IItem> {
+    const { Item } = this.tenancy.models(tenantId);
+
+    // Authorize the item before creating.
+    await this.authorize(tenantId, itemDTO);
+
+    // Creates a new item with associated transactions under unit-of-work envirement.
+    const item = this.uow.withTransaction(
+      tenantId,
+      async (trx: Knex.Transaction) => {
+        // Inserts a new item and fetch the created item.
+        const item = await Item.query(trx).insertAndFetch({
+          ...this.transformNewItemDTOToModel(itemDTO),
+        });
+        // Triggers `onItemCreated` event.
+        await this.eventPublisher.emitAsync(events.item.onCreated, {
+          tenantId,
+          item,
+          itemId: item.id,
+          trx,
+        } as IItemEventCreatedPayload);
+
+        return item;
+      }
+    );
+    return item;
+  }
+}
diff --git a/packages/server/src/services/Items/DeleteItem.ts b/packages/server/src/services/Items/DeleteItem.ts
new file mode 100644
index 000000000..dd27a80e5
--- /dev/null
+++ b/packages/server/src/services/Items/DeleteItem.ts
@@ -0,0 +1,66 @@
+import { Service, Inject } from 'typedi';
+import {
+  IItemEventDeletedPayload,
+  IItemEventDeletingPayload,
+} from '@/interfaces';
+import { Knex } from 'knex';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import { ERRORS } from './constants';
+import { ItemsValidators } from './ItemValidators';
+
+@Service()
+export class DeleteItem {
+  @Inject()
+  private validators: ItemsValidators;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  /**
+   * Delete the given item from the storage.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} itemId - Item id.
+   * @return {Promise<void>}
+   */
+  public async deleteItem(tenantId: number, itemId: number) {
+    const { Item } = this.tenancy.models(tenantId);
+
+    // Retreive the given item or throw not found service error.
+    const oldItem = await Item.query()
+      .findById(itemId)
+      .throwIfNotFound()
+      .queryAndThrowIfHasRelations({
+        type: ERRORS.ITEM_HAS_ASSOCIATED_TRANSACTIONS,
+      });
+    // Delete item in unit of work.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onItemDeleting` event.
+      await this.eventPublisher.emitAsync(events.item.onDeleting, {
+        tenantId,
+        trx,
+        oldItem,
+      } as IItemEventDeletingPayload);
+
+      // Deletes the item.
+      await Item.query(trx).findById(itemId).delete();
+
+      const eventPayload: IItemEventDeletedPayload = {
+        tenantId,
+        oldItem,
+        itemId,
+        trx,
+      };
+      // Triggers `onItemDeleted` event.
+      await this.eventPublisher.emitAsync(events.item.onDeleted, eventPayload);
+    });
+  }
+}
diff --git a/packages/server/src/services/Items/EditItem.ts b/packages/server/src/services/Items/EditItem.ts
new file mode 100644
index 000000000..8227f3b5f
--- /dev/null
+++ b/packages/server/src/services/Items/EditItem.ts
@@ -0,0 +1,147 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import {
+  IItem,
+  IItemDTO,
+  IItemEditDTO,
+  IItemEventEditedPayload,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { ItemsValidators } from './ItemValidators';
+import events from '@/subscribers/events';
+
+@Service()
+export class EditItem {
+  @Inject()
+  private validators: ItemsValidators;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  /**
+   * Authorize the editing item.
+   * @param {number} tenantId
+   * @param {IItemEditDTO} itemDTO
+   * @param {IItem} oldItem
+   */
+  async authorize(tenantId: number, itemDTO: IItemEditDTO, oldItem: IItem) {
+    // Validate edit item type from inventory type.
+    this.validators.validateEditItemFromInventory(itemDTO, oldItem);
+
+    // Validate edit item type to inventory type.
+    await this.validators.validateEditItemTypeToInventory(
+      tenantId,
+      oldItem,
+      itemDTO
+    );
+    // Validate whether the given item name already exists on the storage.
+    await this.validators.validateItemNameUniquiness(
+      tenantId,
+      itemDTO.name,
+      oldItem.id
+    );
+    // Validate the item category existance on the storage,
+    if (itemDTO.categoryId) {
+      await this.validators.validateItemCategoryExistance(
+        tenantId,
+        itemDTO.categoryId
+      );
+    }
+    // Validate the sell account existance on the storage.
+    if (itemDTO.sellAccountId) {
+      await this.validators.validateItemSellAccountExistance(
+        tenantId,
+        itemDTO.sellAccountId
+      );
+    }
+    // Validate the cost account existance on the storage.
+    if (itemDTO.costAccountId) {
+      await this.validators.validateItemCostAccountExistance(
+        tenantId,
+        itemDTO.costAccountId
+      );
+    }
+    // Validate the inventory account existance onthe storage.
+    if (itemDTO.inventoryAccountId) {
+      await this.validators.validateItemInventoryAccountExistance(
+        tenantId,
+        itemDTO.inventoryAccountId
+      );
+    }
+    // Validate inventory account should be modified in inventory item
+    // has inventory transactions.
+    await this.validators.validateItemInvnetoryAccountModified(
+      tenantId,
+      oldItem,
+      itemDTO
+    );
+  }
+
+  /**
+   * Transformes edit item DTO to model.
+   * @param {IItemDTO} itemDTO - Item DTO.
+   * @param {IItem} oldItem -
+   */
+  private transformEditItemDTOToModel(itemDTO: IItemDTO, oldItem: IItem) {
+    return {
+      ...itemDTO,
+      ...(itemDTO.type === 'inventory' && oldItem.type !== 'inventory'
+        ? {
+            quantityOnHand: 0,
+          }
+        : {}),
+    };
+  }
+
+  /**
+   * Edits the item metadata.
+   * @param {number} tenantId
+   * @param {number} itemId
+   * @param {IItemDTO} itemDTO
+   */
+  public async editItem(tenantId: number, itemId: number, itemDTO: IItemDTO) {
+    const { Item } = this.tenancy.models(tenantId);
+
+    // Validates the given item existance on the storage.
+    const oldItem = await Item.query().findById(itemId).throwIfNotFound();
+
+    // Authorize before editing item.
+    await this.authorize(tenantId, itemDTO, oldItem);
+
+    // Transform the edit item DTO to model.
+    const itemModel = this.transformEditItemDTOToModel(itemDTO, oldItem);
+
+    // Edits the item with associated transactions under unit-of-work envirement.
+    const newItem = this.uow.withTransaction(
+      tenantId,
+      async (trx: Knex.Transaction) => {
+        // Updates the item on the storage and fetches the updated once.
+        const newItem = await Item.query(trx).patchAndFetchById(itemId, {
+          ...itemModel,
+        });
+        // Edit event payload.
+        const eventPayload: IItemEventEditedPayload = {
+          tenantId,
+          item: newItem,
+          oldItem,
+          itemId: newItem.id,
+          trx,
+        };
+        // Triggers `onItemEdited` event.
+        await this.eventPublisher.emitAsync(events.item.onEdited, eventPayload);
+
+        return newItem;
+      }
+    );
+
+    return newItem;
+  }
+}
diff --git a/packages/server/src/services/Items/GetItem.ts b/packages/server/src/services/Items/GetItem.ts
new file mode 100644
index 000000000..7b078bac5
--- /dev/null
+++ b/packages/server/src/services/Items/GetItem.ts
@@ -0,0 +1,34 @@
+import { Inject } from 'typedi';
+import { IItem } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import ItemTransformer from './ItemTransformer';
+
+@Inject()
+export class GetItem {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the item details of the given id with associated details.
+   * @param {number} tenantId
+   * @param {number} itemId
+   */
+  public async getItem(tenantId: number, itemId: number): Promise<IItem> {
+    const { Item } = this.tenancy.models(tenantId);
+
+    const item = await Item.query()
+      .findById(itemId)
+      .withGraphFetched('sellAccount')
+      .withGraphFetched('inventoryAccount')
+      .withGraphFetched('category')
+      .withGraphFetched('costAccount')
+      .withGraphFetched('itemWarehouses.warehouse')
+      .throwIfNotFound();
+
+    return this.transformer.transform(tenantId, item, new ItemTransformer());
+  }
+}
diff --git a/packages/server/src/services/Items/GetItems.ts b/packages/server/src/services/Items/GetItems.ts
new file mode 100644
index 000000000..24a7745ea
--- /dev/null
+++ b/packages/server/src/services/Items/GetItems.ts
@@ -0,0 +1,70 @@
+import { Service, Inject } from 'typedi';
+import * as R from 'ramda';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { IItemsFilter } from '@/interfaces';
+import ItemTransformer from './ItemTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export class GetItems {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Parses items list filter DTO.
+   * @param {} filterDTO - Filter DTO.
+   */
+  private parseItemsListFilterDTO(filterDTO) {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  }
+
+  /**
+   * Retrieve items datatable list.
+   * @param {number} tenantId -
+   * @param {IItemsFilter} itemsFilter -
+   */
+  public async getItems(tenantId: number, filterDTO: IItemsFilter) {
+    const { Item } = this.tenancy.models(tenantId);
+
+    // Parses items list filter DTO.
+    const filter = this.parseItemsListFilterDTO(filterDTO);
+
+    // Dynamic list service.
+    const dynamicFilter = await this.dynamicListService.dynamicList(
+      tenantId,
+      Item,
+      filter
+    );
+    const { results: items, pagination } = await Item.query()
+      .onBuild((builder) => {
+        builder.modify('inactiveMode', filter.inactiveMode);
+
+        builder.withGraphFetched('inventoryAccount');
+        builder.withGraphFetched('sellAccount');
+        builder.withGraphFetched('costAccount');
+        builder.withGraphFetched('category');
+
+        dynamicFilter.buildQuery()(builder);
+      })
+      .pagination(filter.page - 1, filter.pageSize);
+
+    // Retrieves the transformed items.
+    const transformedItems = await this.transformer.transform(
+      tenantId,
+      items,
+      new ItemTransformer()
+    );
+    return {
+      items: transformedItems,
+      pagination,
+      filterMeta: dynamicFilter.getResponseMeta(),
+    };
+  }
+}
diff --git a/packages/server/src/services/Items/InactivateItem.ts b/packages/server/src/services/Items/InactivateItem.ts
new file mode 100644
index 000000000..5f1ccb83b
--- /dev/null
+++ b/packages/server/src/services/Items/InactivateItem.ts
@@ -0,0 +1,40 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+
+@Service()
+export class InactivateItem {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  /**
+   * Inactivates the given item on the storage.
+   * @param {number} tenantId
+   * @param {number} itemId
+   * @return {Promise<void>}
+   */
+  public async inactivateItem(tenantId: number, itemId: number): Promise<void> {
+    const { Item } = this.tenancy.models(tenantId);
+
+    // Retrieves the item or throw not found error.
+    const oldItem = await Item.query().findById(itemId).throwIfNotFound();
+
+    // Inactivate item under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Activate item on the storage.
+      await Item.query(trx).findById(itemId).patch({ active: false });
+
+      // Triggers `onItemInactivated` event.
+      await this.eventPublisher.emitAsync(events.item.onInactivated, { trx });
+    });
+  }
+}
diff --git a/packages/server/src/services/Items/ItemBillsTransactionsTransformer.ts b/packages/server/src/services/Items/ItemBillsTransactionsTransformer.ts
new file mode 100644
index 000000000..434de3b8c
--- /dev/null
+++ b/packages/server/src/services/Items/ItemBillsTransactionsTransformer.ts
@@ -0,0 +1,97 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class ItemBillTransactionTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedAmount',
+      'formattedBillDate',
+      'formattedRate',
+      'formattedCost',
+    ];
+  };
+
+  /**
+   * Formatted sell price.
+   * @param item
+   * @returns {string}
+   */
+  public formattedAmount(item): string {
+    return formatNumber(item.amount, {
+      currencyCode: item.bill.currencyCode,
+    });
+  }
+
+  /**
+   * Formatted bill date.
+   * @param item
+   * @returns {string}
+   */
+  public formattedBillDate = (entry): string => {
+    return this.formatDate(entry.bill.billDate);
+  };
+
+  /**
+   * Formatted quantity.
+   * @returns {string}
+   */
+  public formattedQuantity = (entry): string => {
+    return entry.quantity;
+  };
+
+  /**
+   * Formatted rate.
+   * @param entry
+   * @returns {string}
+   */
+  public formattedRate = (entry): string => {
+    return formatNumber(entry.rate, {
+      currencyCode: entry.bill.currencyCode,
+    });
+  };
+
+  /**
+   * Formatted bill due date.
+   * @param entry
+   * @returns
+   */
+  public formattedBillDueDate = (entry): string => {
+    return this.formatDate(entry.bill.dueDate);
+  };
+
+  /**
+   *
+   * @param entry
+   * @returns
+   */
+  public transform = (entry) => {
+    return {
+      billId: entry.bill.id,
+
+      billNumber: entry.bill.billNumber,
+      referenceNumber: entry.bill.referenceNo,
+
+      billDate: entry.bill.billDate,
+      formattedBillDate: entry.formattedBillDate,
+
+      billDueDate: entry.bill.dueDate,
+      formattedBillDueDate: entry.formattedBillDueDate,
+
+      amount: entry.amount,
+      formattedAmount: entry.formattedAmount,
+
+      quantity: entry.quantity,
+      formattedQuantity: entry.formattedQuantity,
+
+      rate: entry.rate,
+      formattedRate: entry.formattedRate,
+
+      vendorDisplayName: entry.bill.vendor.displayName,
+      vendorCurrencyCode: entry.bill.vendor.currencyCode,
+    };
+  };
+}
diff --git a/packages/server/src/services/Items/ItemEstimatesTransactionTransformer.ts b/packages/server/src/services/Items/ItemEstimatesTransactionTransformer.ts
new file mode 100644
index 000000000..256419d91
--- /dev/null
+++ b/packages/server/src/services/Items/ItemEstimatesTransactionTransformer.ts
@@ -0,0 +1,82 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class ItemEstimateTransactionTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedAmount',
+      'formattedEstimateDate',
+      'formattedRate',
+      'formattedCost',
+    ];
+  };
+
+  /**
+   * Formatted sell price.
+   * @returns {string}
+   */
+  public formattedAmount(item): string {
+    return formatNumber(item.amount, {
+      currencyCode: item.estimate.currencyCode,
+    });
+  }
+
+  /**
+   * Formatted estimate date.
+   * @returns {string}
+   */
+  public formattedEstimateDate = (entry): string => {
+    return this.formatDate(entry.estimate.estimateDate);
+  };
+
+  /**
+   * Formatted quantity.
+   * @returns {string}
+   */
+  public formattedQuantity = (entry): string => {
+    return entry.quantity;
+  };
+
+  /**
+   * Formatted rate.
+   * @returns {string}
+   */
+  public formattedRate = (entry): string => {
+    return formatNumber(entry.rate, {
+      currencyCode: entry.estimate.currencyCode,
+    });
+  };
+
+  /**
+   *
+   * @param entry
+   * @returns
+   */
+  public transform = (entry) => {
+    return {
+      estimateId: entry.estimate.id,
+
+      estimateNumber: entry.estimate.estimateNumber,
+      referenceNumber: entry.estimate.referenceNo,
+
+      estimateDate: entry.estimate.estimateDate,
+      formattedEstimateDate: entry.formattedEstimateDate,
+
+      amount: entry.amount,
+      formattedAmount: entry.formattedAmount,
+
+      quantity: entry.quantity,
+      formattedQuantity: entry.formattedQuantity,
+
+      rate: entry.rate,
+      formattedRate: entry.formattedRate,
+
+      customerDisplayName: entry.estimate.customer.displayName,
+      customerCurrencyCode: entry.estimate.customer.currencyCode,
+    };
+  };
+}
diff --git a/packages/server/src/services/Items/ItemInvoicesTransactionsTransformer.ts b/packages/server/src/services/Items/ItemInvoicesTransactionsTransformer.ts
new file mode 100644
index 000000000..9cab83380
--- /dev/null
+++ b/packages/server/src/services/Items/ItemInvoicesTransactionsTransformer.ts
@@ -0,0 +1,84 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class ItemInvoicesTransactionsTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedAmount',
+      'formattedInvoiceDate',
+      'formattedRate',
+      'formattedCost',
+    ];
+  };
+
+  /**
+   * Formatted sell price.
+   * @param item
+   * @returns {string}
+   */
+  public formattedAmount(item): string {
+    return formatNumber(item.amount, {
+      currencyCode: item.invoice.currencyCode,
+    });
+  }
+
+  /**
+   *
+   * @param item
+   * @returns
+   */
+  public formattedInvoiceDate = (entry): string => {
+    return this.formatDate(entry.invoice.invoiceDate);
+  };
+
+  /**
+   *
+   */
+  public formattedQuantity = (entry): string => {
+    return entry.quantity;
+  };
+
+  /**
+   *
+   * @param entry
+   * @returns
+   */
+  public formattedRate = (entry): string => {
+    return formatNumber(entry.rate, {
+      currencyCode: entry.invoice.currencyCode,
+    });
+  };
+
+  /**
+   *
+   * @param entry
+   * @returns
+   */
+  public transform = (entry) => {
+    return {
+      invoiceId: entry.invoice.id,
+
+      invoiceNumber: entry.invoice.invoiceNo,
+      referenceNumber: entry.invoice.referenceNo,
+
+      invoiceDate: entry.invoice.invoiceDate,
+      formattedInvoiceDate: entry.formattedInvoiceDate,
+
+      amount: entry.amount,
+      formattedAmount: entry.formattedAmount,
+
+      quantity: entry.quantity,
+      formattedQuantity: entry.formattedQuantity,
+
+      rate: entry.rate,
+      formattedRate: entry.formattedRate,
+
+      customerDisplayName: entry.invoice.customer.displayName,
+      customerCurrencyCode: entry.invoice.customer.currencyCode,
+    };
+  };
+}
diff --git a/packages/server/src/services/Items/ItemReceiptsTransactionsTransformer.ts b/packages/server/src/services/Items/ItemReceiptsTransactionsTransformer.ts
new file mode 100644
index 000000000..2d50e02f1
--- /dev/null
+++ b/packages/server/src/services/Items/ItemReceiptsTransactionsTransformer.ts
@@ -0,0 +1,84 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class ItemReceiptTransactionTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedAmount',
+      'formattedReceiptDate',
+      'formattedRate',
+      'formattedCost',
+    ];
+  };
+
+  /**
+   * Formatted sell price.
+   * @param item
+   * @returns {string}
+   */
+  public formattedAmount(item): string {
+    return formatNumber(item.amount, {
+      currencyCode: item.receipt.currencyCode,
+    });
+  }
+
+  /**
+   *
+   * @param item
+   * @returns
+   */
+  public formattedReceiptDate = (entry): string => {
+    return this.formatDate(entry.receipt.receiptDate);
+  };
+
+  /**
+   *
+   */
+  public formattedQuantity = (entry): string => {
+    return entry.quantity;
+  };
+
+  /**
+   *
+   * @param entry
+   * @returns
+   */
+  public formattedRate = (entry): string => {
+    return formatNumber(entry.rate, {
+      currencyCode: entry.receipt.currencyCode,
+    });
+  };
+
+  /**
+   *
+   * @param entry
+   * @returns
+   */
+  public transform = (entry) => {
+    return {
+      receiptId: entry.receipt.id,
+
+      receipNumber: entry.receipt.receiptNumber,
+      referenceNumber: entry.receipt.referenceNo,
+
+      receiptDate: entry.receipt.receiptDate,
+      formattedReceiptDate: entry.formattedReceiptDate,
+
+      amount: entry.amount,
+      formattedAmount: entry.formattedAmount,
+
+      quantity: entry.quantity,
+      formattedQuantity: entry.formattedQuantity,
+
+      rate: entry.rate,
+      formattedRate: entry.formattedRate,
+
+      customerDisplayName: entry.receipt.customer.displayName,
+      customerCurrencyCode: entry.receipt.customer.currencyCode,
+    };
+  };
+}
diff --git a/packages/server/src/services/Items/ItemTransactionsService.ts b/packages/server/src/services/Items/ItemTransactionsService.ts
new file mode 100644
index 000000000..5defa6362
--- /dev/null
+++ b/packages/server/src/services/Items/ItemTransactionsService.ts
@@ -0,0 +1,123 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ItemInvoicesTransactionsTransformer } from './ItemInvoicesTransactionsTransformer';
+import { ItemEstimateTransactionTransformer } from './ItemEstimatesTransactionTransformer';
+import { ItemBillTransactionTransformer } from './ItemBillsTransactionsTransformer';
+import { ItemReceiptTransactionTransformer } from './ItemReceiptsTransactionsTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export default class ItemTransactionsService {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the item associated invoices transactions.
+   * @param {number} tenantId -
+   * @param {number} itemId -
+   */
+  public async getItemInvoicesTransactions(tenantId: number, itemId: number) {
+    const { ItemEntry } = this.tenancy.models(tenantId);
+
+    const invoiceEntries = await ItemEntry.query()
+      .where('itemId', itemId)
+      .where('referenceType', 'SaleInvoice')
+      .withGraphJoined('invoice.customer(selectCustomerColumns)')
+      .orderBy('invoice:invoiceDate', 'ASC')
+      .modifiers({
+        selectCustomerColumns: (builder) => {
+          builder.select('displayName', 'currencyCode', 'id');
+        },
+      });
+    // Retrieves the transformed invoice entries.
+    return this.transformer.transform(
+      tenantId,
+      invoiceEntries,
+      new ItemInvoicesTransactionsTransformer()
+    );
+  }
+
+  /**
+   * Retrieve the item associated invoices transactions.
+   * @param {number} tenantId
+   * @param {number} itemId
+   * @returns
+   */
+  public async getItemBillTransactions(tenantId: number, itemId: number) {
+    const { ItemEntry } = this.tenancy.models(tenantId);
+
+    const billEntries = await ItemEntry.query()
+      .where('itemId', itemId)
+      .where('referenceType', 'Bill')
+      .withGraphJoined('bill.vendor(selectVendorColumns)')
+      .orderBy('bill:billDate', 'ASC')
+      .modifiers({
+        selectVendorColumns: (builder) => {
+          builder.select('displayName', 'currencyCode', 'id');
+        },
+      });
+    // Retrieves the transformed bill entries.
+    return this.transformer.transform(
+      tenantId,
+      billEntries,
+      new ItemBillTransactionTransformer()
+    );
+  }
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {number} itemId
+   * @returns
+   */
+  public async getItemEstimateTransactions(tenantId: number, itemId: number) {
+    const { ItemEntry } = this.tenancy.models(tenantId);
+
+    const estimatesEntries = await ItemEntry.query()
+      .where('itemId', itemId)
+      .where('referenceType', 'SaleEstimate')
+      .withGraphJoined('estimate.customer(selectCustomerColumns)')
+      .orderBy('estimate:estimateDate', 'ASC')
+      .modifiers({
+        selectCustomerColumns: (builder) => {
+          builder.select('displayName', 'currencyCode', 'id');
+        },
+      });
+    // Retrieves the transformed estimates entries.
+    return this.transformer.transform(
+      tenantId,
+      estimatesEntries,
+      new ItemEstimateTransactionTransformer()
+    );
+  }
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {number} itemId
+   * @returns
+   */
+  public async getItemReceiptTransactions(tenantId: number, itemId: number) {
+    const { ItemEntry } = this.tenancy.models(tenantId);
+
+    const receiptsEntries = await ItemEntry.query()
+      .where('itemId', itemId)
+      .where('referenceType', 'SaleReceipt')
+      .withGraphJoined('receipt.customer(selectCustomerColumns)')
+      .orderBy('receipt:receiptDate', 'ASC')
+      .modifiers({
+        selectCustomerColumns: (builder) => {
+          builder.select('displayName', 'currencyCode', 'id');
+        },
+      });
+    // Retrieves the transformed receipts entries.
+    return this.transformer.transform(
+      tenantId,
+      receiptsEntries,
+      new ItemReceiptTransactionTransformer()
+    );
+  }
+}
diff --git a/packages/server/src/services/Items/ItemTransformer.ts b/packages/server/src/services/Items/ItemTransformer.ts
new file mode 100644
index 000000000..8952599f7
--- /dev/null
+++ b/packages/server/src/services/Items/ItemTransformer.ts
@@ -0,0 +1,62 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { GetItemWarehouseTransformer } from '@/services/Warehouses/Items/GettItemWarehouseTransformer';
+import { formatNumber } from 'utils';
+
+export default class ItemTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'typeFormatted',
+      'sellPriceFormatted',
+      'costPriceFormatted',
+      'itemWarehouses',
+    ];
+  };
+
+  /**
+   * Formatted item type.
+   * @param {IItem} item
+   * @returns {string}
+   */
+  public typeFormatted(item): string {
+    return this.context.i18n.__(`item.field.type.${item.type}`);
+  }
+
+  /**
+   * Formatted sell price.
+   * @param item
+   * @returns {string}
+   */
+  public sellPriceFormatted(item): string {
+    return formatNumber(item.sellPrice, {
+      currencyCode: this.context.organization.baseCurrency,
+    });
+  }
+
+  /**
+   * Formatted cost price.
+   * @param item
+   * @returns {string}
+   */
+  public costPriceFormatted(item): string {
+    return formatNumber(item.costPrice, {
+      currencyCode: this.context.organization.baseCurrency,
+    });
+  }
+
+  /**
+   * Associate the item warehouses quantity.
+   * @param item
+   * @returns
+   */
+  public itemWarehouses = (item) => {
+    return this.item(
+      item.itemWarehouses,
+      new GetItemWarehouseTransformer(),
+      {}
+    );
+  };
+}
diff --git a/packages/server/src/services/Items/ItemValidators.ts b/packages/server/src/services/Items/ItemValidators.ts
new file mode 100644
index 000000000..d902c3872
--- /dev/null
+++ b/packages/server/src/services/Items/ItemValidators.ts
@@ -0,0 +1,244 @@
+import {
+  ACCOUNT_PARENT_TYPE,
+  ACCOUNT_ROOT_TYPE,
+  ACCOUNT_TYPE,
+} from '@/data/AccountTypes';
+import { ServiceError } from '@/exceptions';
+import { IItem, IItemDTO } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+import { ERRORS } from './constants';
+
+@Service()
+export class ItemsValidators {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Validate wether the given item name already exists on the storage.
+   * @param  {number} tenantId
+   * @param  {string} itemName
+   * @param  {number} notItemId
+   * @return {Promise<void>}
+   */
+  public async validateItemNameUniquiness(
+    tenantId: number,
+    itemName: string,
+    notItemId?: number
+  ): Promise<void> {
+    const { Item } = this.tenancy.models(tenantId);
+
+    const foundItems: [] = await Item.query().onBuild((builder: any) => {
+      builder.where('name', itemName);
+      if (notItemId) {
+        builder.whereNot('id', notItemId);
+      }
+    });
+    if (foundItems.length > 0) {
+      throw new ServiceError(ERRORS.ITEM_NAME_EXISTS);
+    }
+  }
+
+  /**
+   * Validate item COGS account existance and type.
+   * @param {number} tenantId
+   * @param {number} costAccountId
+   * @return {Promise<void>}
+   */
+  public async validateItemCostAccountExistance(
+    tenantId: number,
+    costAccountId: number
+  ): Promise<void> {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    const foundAccount = await accountRepository.findOneById(costAccountId);
+
+    if (!foundAccount) {
+      throw new ServiceError(ERRORS.COST_ACCOUNT_NOT_FOUMD);
+
+      // Detarmines the cost of goods sold account.
+    } else if (!foundAccount.isParentType(ACCOUNT_PARENT_TYPE.EXPENSE)) {
+      throw new ServiceError(ERRORS.COST_ACCOUNT_NOT_COGS);
+    }
+  }
+
+  /**
+   * Validate item sell account existance and type.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} sellAccountId - Sell account id.
+   */
+  public async validateItemSellAccountExistance(
+    tenantId: number,
+    sellAccountId: number
+  ) {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    const foundAccount = await accountRepository.findOneById(sellAccountId);
+
+    if (!foundAccount) {
+      throw new ServiceError(ERRORS.SELL_ACCOUNT_NOT_FOUND);
+    } else if (!foundAccount.isParentType(ACCOUNT_ROOT_TYPE.INCOME)) {
+      throw new ServiceError(ERRORS.SELL_ACCOUNT_NOT_INCOME);
+    }
+  }
+
+  /**
+   * Validate item inventory account existance and type.
+   * @param {number} tenantId
+   * @param {number} inventoryAccountId
+   */
+  public async validateItemInventoryAccountExistance(
+    tenantId: number,
+    inventoryAccountId: number
+  ) {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    const foundAccount = await accountRepository.findOneById(
+      inventoryAccountId
+    );
+
+    if (!foundAccount) {
+      throw new ServiceError(ERRORS.INVENTORY_ACCOUNT_NOT_FOUND);
+    } else if (!foundAccount.isAccountType(ACCOUNT_TYPE.INVENTORY)) {
+      throw new ServiceError(ERRORS.INVENTORY_ACCOUNT_NOT_INVENTORY);
+    }
+  }
+
+  /**
+   * Validate item category existance.
+   * @param {number} tenantId
+   * @param {number} itemCategoryId
+   */
+  public async validateItemCategoryExistance(
+    tenantId: number,
+    itemCategoryId: number
+  ) {
+    const { ItemCategory } = this.tenancy.models(tenantId);
+    const foundCategory = await ItemCategory.query().findById(itemCategoryId);
+
+    if (!foundCategory) {
+      throw new ServiceError(ERRORS.ITEM_CATEOGRY_NOT_FOUND);
+    }
+  }
+
+  /**
+   * Validates the given item or items have no associated invoices or bills.
+   * @param  {number} tenantId - Tenant id.
+   * @param  {number|number[]} itemId - Item id.
+   * @throws {ServiceError}
+   */
+  public async validateHasNoInvoicesOrBills(
+    tenantId: number,
+    itemId: number[] | number
+  ) {
+    const { ItemEntry } = this.tenancy.models(tenantId);
+
+    const ids = Array.isArray(itemId) ? itemId : [itemId];
+    const foundItemEntries = await ItemEntry.query().whereIn('item_id', ids);
+
+    if (foundItemEntries.length > 0) {
+      throw new ServiceError(
+        ids.length > 1
+          ? ERRORS.ITEMS_HAVE_ASSOCIATED_TRANSACTIONS
+          : ERRORS.ITEM_HAS_ASSOCIATED_TRANSACTINS
+      );
+    }
+  }
+
+  /**
+   * Validates the given item has no associated inventory adjustment transactions.
+   * @param {number} tenantId -
+   * @param {number} itemId -
+   */
+  public async validateHasNoInventoryAdjustments(
+    tenantId: number,
+    itemId: number[] | number
+  ): Promise<void> {
+    const { InventoryAdjustmentEntry } = this.tenancy.models(tenantId);
+    const itemsIds = Array.isArray(itemId) ? itemId : [itemId];
+
+    const inventoryAdjEntries = await InventoryAdjustmentEntry.query().whereIn(
+      'item_id',
+      itemsIds
+    );
+    if (inventoryAdjEntries.length > 0) {
+      throw new ServiceError(ERRORS.ITEM_HAS_ASSOCIATED_INVENTORY_ADJUSTMENT);
+    }
+  }
+
+  /**
+   * Validates edit item type from service/non-inventory to inventory.
+   * Should item has no any relations with accounts transactions.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} itemId - Item id.
+   */
+  public async validateEditItemTypeToInventory(
+    tenantId: number,
+    oldItem: IItem,
+    newItemDTO: IItemDTO
+  ) {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+
+    // We have no problem in case the item type not modified.
+    if (newItemDTO.type === oldItem.type || oldItem.type === 'inventory') {
+      return;
+    }
+    // Retrieve all transactions that associated to the given item id.
+    const itemTransactionsCount = await AccountTransaction.query()
+      .where('item_id', oldItem.id)
+      .count('item_id', { as: 'transactions' })
+      .first();
+
+    if (itemTransactionsCount.transactions > 0) {
+      throw new ServiceError(
+        ERRORS.TYPE_CANNOT_CHANGE_WITH_ITEM_HAS_TRANSACTIONS
+      );
+    }
+  }
+
+  /**
+   * Validate the item inventory account whether modified and item
+   * has assocaited inventory transactions.
+   * @param {numnber} tenantId
+   * @param {IItem} oldItem
+   * @param {IItemDTO} newItemDTO
+   * @returns
+   */
+  async validateItemInvnetoryAccountModified(
+    tenantId: number,
+    oldItem: IItem,
+    newItemDTO: IItemDTO
+  ) {
+    const { AccountTransaction } = this.tenancy.models(tenantId);
+
+    if (
+      newItemDTO.type !== 'inventory' ||
+      oldItem.inventoryAccountId === newItemDTO.inventoryAccountId
+    ) {
+      return;
+    }
+    // Inventory transactions associated to the given item id.
+    const transactions = await AccountTransaction.query().where({
+      itemId: oldItem.id,
+    });
+    // Throw the service error in case item has associated inventory transactions.
+    if (transactions.length > 0) {
+      throw new ServiceError(ERRORS.INVENTORY_ACCOUNT_CANNOT_MODIFIED);
+    }
+  }
+
+  /**
+   * Validate edit item type from inventory to another type that not allowed.
+   * @param {IItemDTO} itemDTO - Item DTO.
+   * @param {IItem} oldItem - Old item.
+   */
+  public validateEditItemFromInventory(itemDTO: IItemDTO, oldItem: IItem) {
+    if (
+      itemDTO.type &&
+      oldItem.type === 'inventory' &&
+      itemDTO.type !== oldItem.type
+    ) {
+      throw new ServiceError(ERRORS.ITEM_CANNOT_CHANGE_INVENTORY_TYPE);
+    }
+  }
+}
diff --git a/packages/server/src/services/Items/ItemsApplication.ts b/packages/server/src/services/Items/ItemsApplication.ts
new file mode 100644
index 000000000..a19a9db8f
--- /dev/null
+++ b/packages/server/src/services/Items/ItemsApplication.ts
@@ -0,0 +1,112 @@
+import { Service, Inject } from 'typedi';
+import {
+  IItem,
+  IItemCreateDTO,
+  IItemDTO,
+  IItemEditDTO,
+  IItemsFilter,
+} from '@/interfaces';
+import { CreateItem } from './CreateItem';
+import { EditItem } from './EditItem';
+import { DeleteItem } from './DeleteItem';
+import { GetItem } from './GetItem';
+import { GetItems } from './GetItems';
+import { ActivateItem } from './ActivateItem';
+import { InactivateItem } from './InactivateItem';
+
+@Service()
+export class ItemsApplication {
+  @Inject()
+  private createItemService: CreateItem;
+
+  @Inject()
+  private editItemService: EditItem;
+
+  @Inject()
+  private getItemService: GetItem;
+
+  @Inject()
+  private getItemsService: GetItems;
+
+  @Inject()
+  private deleteItemService: DeleteItem;
+
+  @Inject()
+  private activateItemService: ActivateItem;
+
+  @Inject()
+  private inactivateItemService: InactivateItem;
+
+  /**
+   * Creates a new item (service/product).
+   * @param   {number} tenantId
+   * @param   {IItemCreateDTO} itemDTO
+   * @returns {Promise<IItem>}
+   */
+  public async createItem(
+    tenantId: number,
+    itemDTO: IItemCreateDTO
+  ): Promise<IItem> {
+    return this.createItemService.createItem(tenantId, itemDTO);
+  }
+
+  /**
+   * Retrieves the given item.
+   * @param   {number} tenantId
+   * @param   {number} itemId
+   * @returns {Promise<IItem>}
+   */
+  public getItem(tenantId: number, itemId: number): Promise<IItem> {
+    return this.getItemService.getItem(tenantId, itemId);
+  }
+
+  /**
+   * Edits the given item (service/product).
+   * @param   {number} tenantId
+   * @param   {number} itemId
+   * @param   {IItemEditDTO} itemDTO
+   * @returns {Promise<IItem>}
+   */
+  public editItem(tenantId: number, itemId: number, itemDTO: IItemEditDTO) {
+    return this.editItemService.editItem(tenantId, itemId, itemDTO);
+  }
+
+  /**
+   * Deletes the given item (service/product).
+   * @param   {number} tenantId
+   * @param   {number} itemId
+   * @returns {Promise<void>}
+   */
+  public deleteItem(tenantId: number, itemId: number) {
+    return this.deleteItemService.deleteItem(tenantId, itemId);
+  }
+
+  /**
+   * Activates the given item (service/product).
+   * @param {number} tenantId
+   * @param {number} itemId
+   * @returns
+   */
+  public activateItem(tenantId: number, itemId: number): Promise<void> {
+    return this.activateItemService.activateItem(tenantId, itemId);
+  }
+
+  /**
+   * Inactivates the given item.
+   * @param {number} tenantId -
+   * @param {number} itemId -
+   */
+  public inactivateItem(tenantId: number, itemId: number): Promise<void> {
+    return this.inactivateItemService.inactivateItem(tenantId, itemId);
+  }
+
+  /**
+   * Retrieves the items paginated list.
+   * @param {number} tenantId
+   * @param {IItemsFilter} filterDTO
+   * @returns {}
+   */
+  public getItems(tenantId: number, filterDTO: IItemsFilter) {
+    return this.getItemsService.getItems(tenantId, filterDTO);
+  }
+}
diff --git a/packages/server/src/services/Items/ItemsCostService.ts b/packages/server/src/services/Items/ItemsCostService.ts
new file mode 100644
index 000000000..6f028f808
--- /dev/null
+++ b/packages/server/src/services/Items/ItemsCostService.ts
@@ -0,0 +1,5 @@
+
+
+export default class ItemsCostService {
+  
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Items/ItemsEntriesService.ts b/packages/server/src/services/Items/ItemsEntriesService.ts
new file mode 100644
index 000000000..354e529da
--- /dev/null
+++ b/packages/server/src/services/Items/ItemsEntriesService.ts
@@ -0,0 +1,267 @@
+import { sumBy, difference, map } from 'lodash';
+import { Inject, Service } from 'typedi';
+import { IItemEntry, IItemEntryDTO, IItem } from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import { entriesAmountDiff } from 'utils';
+import { ItemEntry } from 'models';
+
+const ERRORS = {
+  ITEMS_NOT_FOUND: 'ITEMS_NOT_FOUND',
+  ENTRIES_IDS_NOT_FOUND: 'ENTRIES_IDS_NOT_FOUND',
+  NOT_PURCHASE_ABLE_ITEMS: 'NOT_PURCHASE_ABLE_ITEMS',
+  NOT_SELL_ABLE_ITEMS: 'NOT_SELL_ABLE_ITEMS',
+};
+
+@Service()
+export default class ItemsEntriesService {
+  @Inject()
+  tenancy: TenancyService;
+
+  /**
+   * Retrieve the inventory items entries of the reference id and type.
+   * @param {number} tenantId
+   * @param {string} referenceType
+   * @param {string} referenceId
+   * @return {Promise<IItemEntry[]>}
+   */
+  public async getInventoryEntries(
+    tenantId: number,
+    referenceType: string,
+    referenceId: number
+  ): Promise<IItemEntry[]> {
+    const { Item, ItemEntry } = this.tenancy.models(tenantId);
+
+    const itemsEntries = await ItemEntry.query()
+      .where('reference_type', referenceType)
+      .where('reference_id', referenceId);
+
+    // Inventory items.
+    const inventoryItems = await Item.query()
+      .whereIn('id', map(itemsEntries, 'itemId'))
+      .where('type', 'inventory');
+
+    // Inventory items ids.
+    const inventoryItemsIds = map(inventoryItems, 'id');
+
+    // Filtering the inventory items entries.
+    const inventoryItemsEntries = itemsEntries.filter(
+      (itemEntry) => inventoryItemsIds.indexOf(itemEntry.itemId) !== -1
+    );
+    return inventoryItemsEntries;
+  }
+
+  /**
+   * Filter the given entries to inventory entries.
+   * @param {IItemEntry[]} entries -
+   * @returns {IItemEntry[]}
+   */
+  public async filterInventoryEntries(
+    tenantId: number,
+    entries: IItemEntry[]
+  ): Promise<IItemEntry[]> {
+    const { Item } = this.tenancy.models(tenantId);
+    const entriesItemsIds = entries.map((e) => e.itemId);
+
+    // Retrieve entries inventory items.
+    const inventoryItems = await Item.query()
+      .whereIn('id', entriesItemsIds)
+      .where('type', 'inventory');
+
+    const inventoryEntries = entries.filter((entry) =>
+      inventoryItems.some((item) => item.id === entry.itemId)
+    );
+    return inventoryEntries;
+  }
+
+  /**
+   * Validates the entries items ids.
+   * @async
+   * @param {number} tenantId -
+   * @param {IItemEntryDTO} itemEntries -
+   */
+  public async validateItemsIdsExistance(
+    tenantId: number,
+    itemEntries: IItemEntryDTO[]
+  ) {
+    const { Item } = this.tenancy.models(tenantId);
+    const itemsIds = itemEntries.map((e) => e.itemId);
+
+    const foundItems = await Item.query().whereIn('id', itemsIds);
+
+    const foundItemsIds = foundItems.map((item: IItem) => item.id);
+    const notFoundItemsIds = difference(itemsIds, foundItemsIds);
+
+    if (notFoundItemsIds.length > 0) {
+      throw new ServiceError(ERRORS.ITEMS_NOT_FOUND);
+    }
+    return foundItems;
+  }
+
+  /**
+   * Validates the entries ids existance on the storage.
+   * @param {number} tenantId -
+   * @param {number} billId -
+   * @param {IItemEntry[]} billEntries -
+   */
+  public async validateEntriesIdsExistance(
+    tenantId: number,
+    referenceId: number,
+    referenceType: string,
+    billEntries: IItemEntryDTO[]
+  ) {
+    const { ItemEntry } = this.tenancy.models(tenantId);
+    const entriesIds = billEntries
+      .filter((e: IItemEntry) => e.id)
+      .map((e: IItemEntry) => e.id);
+
+    const storedEntries = await ItemEntry.query()
+      .whereIn('reference_id', [referenceId])
+      .whereIn('reference_type', [referenceType]);
+
+    const storedEntriesIds = storedEntries.map((entry) => entry.id);
+    const notFoundEntriesIds = difference(entriesIds, storedEntriesIds);
+
+    if (notFoundEntriesIds.length > 0) {
+      throw new ServiceError(ERRORS.ENTRIES_IDS_NOT_FOUND);
+    }
+  }
+
+  /**
+   * Validate the entries items that not purchase-able.
+   */
+  public async validateNonPurchasableEntriesItems(
+    tenantId: number,
+    itemEntries: IItemEntryDTO[]
+  ) {
+    const { Item } = this.tenancy.models(tenantId);
+    const itemsIds = itemEntries.map((e: IItemEntryDTO) => e.itemId);
+
+    const purchasbleItems = await Item.query()
+      .where('purchasable', true)
+      .whereIn('id', itemsIds);
+
+    const purchasbleItemsIds = purchasbleItems.map((item: IItem) => item.id);
+    const notPurchasableItems = difference(itemsIds, purchasbleItemsIds);
+
+    if (notPurchasableItems.length > 0) {
+      throw new ServiceError(ERRORS.NOT_PURCHASE_ABLE_ITEMS);
+    }
+  }
+
+  /**
+   * Validate the entries items that not sell-able.
+   */
+  public async validateNonSellableEntriesItems(
+    tenantId: number,
+    itemEntries: IItemEntryDTO[]
+  ) {
+    const { Item } = this.tenancy.models(tenantId);
+    const itemsIds = itemEntries.map((e: IItemEntryDTO) => e.itemId);
+
+    const sellableItems = await Item.query()
+      .where('sellable', true)
+      .whereIn('id', itemsIds);
+
+    const sellableItemsIds = sellableItems.map((item: IItem) => item.id);
+    const nonSellableItems = difference(itemsIds, sellableItemsIds);
+
+    if (nonSellableItems.length > 0) {
+      throw new ServiceError(ERRORS.NOT_SELL_ABLE_ITEMS);
+    }
+  }
+
+  /**
+   * Changes items quantity from the given items entries the new and old onces.
+   * @param {number} tenantId
+   * @param {IItemEntry} entries - Items entries.
+   * @param {IItemEntry} oldEntries - Old items entries.
+   */
+  public async changeItemsQuantity(
+    tenantId: number,
+    entries: IItemEntry[],
+    oldEntries?: IItemEntry[]
+  ): Promise<void> {
+    const { itemRepository } = this.tenancy.repositories(tenantId);
+    const opers = [];
+
+    const diffEntries = entriesAmountDiff(
+      entries,
+      oldEntries,
+      'quantity',
+      'itemId'
+    );
+    diffEntries.forEach((entry: IItemEntry) => {
+      const changeQuantityOper = itemRepository.changeNumber(
+        { id: entry.itemId, type: 'inventory' },
+        'quantityOnHand',
+        entry.quantity
+      );
+      opers.push(changeQuantityOper);
+    });
+    await Promise.all(opers);
+  }
+
+  /**
+   * Increment items quantity from the given items entries.
+   * @param {number} tenantId - Tenant id.
+   * @param {IItemEntry} entries - Items entries.
+   */
+  public async incrementItemsEntries(
+    tenantId: number,
+    entries: IItemEntry[]
+  ): Promise<void> {
+    return this.changeItemsQuantity(tenantId, entries);
+  }
+
+  /**
+   * Decrement items quantity from the given items entries.
+   * @param {number} tenantId - Tenant id.
+   * @param {IItemEntry} entries - Items entries.
+   */
+  public async decrementItemsQuantity(
+    tenantId: number,
+    entries: IItemEntry[]
+  ): Promise<void> {
+    return this.changeItemsQuantity(
+      tenantId,
+      entries.map((entry) => ({
+        ...entry,
+        quantity: entry.quantity * -1,
+      }))
+    );
+  }
+
+  /**
+   * Sets the cost/sell accounts to the invoice entries.
+   */
+  setItemsEntriesDefaultAccounts(tenantId: number) {
+    return async (entries: IItemEntry[]) => {
+      const { Item } = this.tenancy.models(tenantId);
+
+      const entriesItemsIds = entries.map((e) => e.itemId);
+      const items = await Item.query().whereIn('id', entriesItemsIds);
+
+      return entries.map((entry) => {
+        const item = items.find((i) => i.id === entry.itemId);
+
+        return {
+          ...entry,
+          sellAccountId: entry.sellAccountId || item.sellAccountId,
+          ...(item.type === 'inventory' && {
+            costAccountId: entry.costAccountId || item.costAccountId,
+          }),
+        };
+      });
+    };
+  }
+
+  /**
+   * Retrieve the total items entries.
+   * @param entries 
+   * @returns 
+   */
+  getTotalItemsEntries(entries: ItemEntry[]): number {
+    return sumBy(entries, (e) => ItemEntry.calcAmount(e));
+  }
+}
diff --git a/packages/server/src/services/Items/constants.ts b/packages/server/src/services/Items/constants.ts
new file mode 100644
index 000000000..e3dd283a7
--- /dev/null
+++ b/packages/server/src/services/Items/constants.ts
@@ -0,0 +1,57 @@
+
+export const ERRORS = {
+  NOT_FOUND: 'NOT_FOUND',
+  ITEMS_NOT_FOUND: 'ITEMS_NOT_FOUND',
+
+  ITEM_NAME_EXISTS: 'ITEM_NAME_EXISTS',
+  ITEM_CATEOGRY_NOT_FOUND: 'ITEM_CATEOGRY_NOT_FOUND',
+  COST_ACCOUNT_NOT_COGS: 'COST_ACCOUNT_NOT_COGS',
+  COST_ACCOUNT_NOT_FOUMD: 'COST_ACCOUNT_NOT_FOUMD',
+  SELL_ACCOUNT_NOT_FOUND: 'SELL_ACCOUNT_NOT_FOUND',
+  SELL_ACCOUNT_NOT_INCOME: 'SELL_ACCOUNT_NOT_INCOME',
+
+  INVENTORY_ACCOUNT_NOT_FOUND: 'INVENTORY_ACCOUNT_NOT_FOUND',
+  INVENTORY_ACCOUNT_NOT_INVENTORY: 'INVENTORY_ACCOUNT_NOT_INVENTORY',
+
+  ITEMS_HAVE_ASSOCIATED_TRANSACTIONS: 'ITEMS_HAVE_ASSOCIATED_TRANSACTIONS',
+  ITEM_HAS_ASSOCIATED_TRANSACTINS: 'ITEM_HAS_ASSOCIATED_TRANSACTINS',
+
+  ITEM_HAS_ASSOCIATED_INVENTORY_ADJUSTMENT:
+    'ITEM_HAS_ASSOCIATED_INVENTORY_ADJUSTMENT',
+  ITEM_CANNOT_CHANGE_INVENTORY_TYPE: 'ITEM_CANNOT_CHANGE_INVENTORY_TYPE',
+  TYPE_CANNOT_CHANGE_WITH_ITEM_HAS_TRANSACTIONS: 'TYPE_CANNOT_CHANGE_WITH_ITEM_HAS_TRANSACTIONS',
+  INVENTORY_ACCOUNT_CANNOT_MODIFIED: 'INVENTORY_ACCOUNT_CANNOT_MODIFIED',
+
+  ITEM_HAS_ASSOCIATED_TRANSACTIONS: 'ITEM_HAS_ASSOCIATED_TRANSACTIONS'
+};
+
+export const DEFAULT_VIEW_COLUMNS = [];
+export const DEFAULT_VIEWS = [
+  {
+    name: 'Services',
+    slug: 'services',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'type', comparator: 'equals', value: 'service' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Inventory',
+    slug: 'inventory',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'type', comparator: 'equals', value: 'inventory' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Non Inventory',
+    slug: 'non-inventory',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'type', comparator: 'equals', value: 'non-inventory' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+]
\ No newline at end of file
diff --git a/packages/server/src/services/Jobs/JobTransformer.ts b/packages/server/src/services/Jobs/JobTransformer.ts
new file mode 100644
index 000000000..1def63923
--- /dev/null
+++ b/packages/server/src/services/Jobs/JobTransformer.ts
@@ -0,0 +1,45 @@
+import { Service } from 'typedi';
+import moment from 'moment';
+import { Transformer } from '@/lib/Transformer/Transformer';
+
+@Service()
+export class JobTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return ['queued', 'completed', 'failed'];
+  };
+
+  /**
+   * Detarmines the queued state.
+   * @param {IJob} job
+   * @returns {String}
+   */
+  protected queued = (job): boolean => {
+    return !!job.nextRunAt && moment().isSameOrAfter(job.nextRunAt, 'seconds');
+  };
+
+  /**
+   * Detarmines the completed state.
+   * @param job
+   * @returns
+   */
+  protected completed = (job): boolean => {
+    return !!job.lastFinishedAt;
+  };
+
+  /**
+   * Detarmines the failed state.
+   * @param job
+   * @returns
+   */
+  protected failed = (job): boolean => {
+    return (
+      job.lastFinishedAt &&
+      job.failedAt &&
+      moment(job.failedAt).isSame(job.lastFinishedAt)
+    );
+  };
+}
diff --git a/packages/server/src/services/Jobs/JobsService.ts b/packages/server/src/services/Jobs/JobsService.ts
new file mode 100644
index 000000000..6f1cc69cb
--- /dev/null
+++ b/packages/server/src/services/Jobs/JobsService.ts
@@ -0,0 +1,52 @@
+import { pick, first } from 'lodash';
+import { ObjectId } from 'mongodb';
+import { Service, Inject } from 'typedi';
+import { JobTransformer } from './JobTransformer';
+import { IJobMeta } from '@/interfaces';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export default class JobsService {
+  @Inject('agenda')
+  agenda: any;
+
+  @Inject()
+  transformer: TransformerInjectable;
+
+  /**
+   * Retrieve job details of the given job id.
+   * @param {number} tenantId - 
+   * @param {string} jobId -
+   * @returns {Promise<IJobMeta>}
+   */
+  async getJob(jobId: string): Promise<IJobMeta> {
+    const jobs = await this.agenda.jobs({ _id: new ObjectId(jobId) });
+
+    // Transformes job to json.
+    const jobJson = this.transformJobToJson(first(jobs));
+
+    return this.transformer.transform(null, jobJson, new JobTransformer());
+  }
+
+  /**
+   * Transformes the job to json.
+   * @param job
+   * @returns
+   */
+  private transformJobToJson(job) {
+    return {
+      id: job.attrs._id,
+      ...pick(job.attrs, [
+        'nextRunAt',
+        'lastModifiedBy',
+        'lockedAt',
+        'lastRunAt',
+        'failCount',
+        'failReason',
+        'failedAt',
+        'lastFinishedAt',
+      ]),
+      running: job.isRunning(),
+    };
+  }
+}
diff --git a/packages/server/src/services/Ledger/LedgerRepository.ts b/packages/server/src/services/Ledger/LedgerRepository.ts
new file mode 100644
index 000000000..e8e7866e9
--- /dev/null
+++ b/packages/server/src/services/Ledger/LedgerRepository.ts
@@ -0,0 +1,56 @@
+import { Service } from 'typedi';
+import { omit } from 'lodash';
+import JournalPoster from '@/services/Accounting/JournalPoster';
+import JournalEntry from '@/services/Accounting/JournalEntry';
+import Knex from 'knex';
+import { ILedgerEntry } from '@/interfaces';
+
+@Service()
+export default class LedgerRepository {
+  /**
+   * 
+   * @param {number} tenantId 
+   * @param {ILedgerEntry[]} ledgerEntries 
+   * @param {Knex.Transaction} trx 
+   */
+  public saveLedgerEntries = async (
+    tenantId: number,
+    ledgerEntries: ILedgerEntry[],
+    trx?: Knex.Transaction
+  ) => {
+    const journal = new JournalPoster(tenantId, null, trx);
+
+    ledgerEntries.forEach((ledgerEntry) => {
+      const entry = new JournalEntry({
+        ...omit(ledgerEntry, [
+          'accountNormal',
+          'referenceNo',
+          'transactionId',
+          'transactionType',
+        ]),
+        contactId: ledgerEntry.contactId,
+        account: ledgerEntry.accountId,
+        referenceId: ledgerEntry.transactionId,
+        referenceType: ledgerEntry.transactionType,
+        referenceNumber: ledgerEntry.referenceNo,
+        transactionNumber: ledgerEntry.transactionNumber,
+        index: ledgerEntry.index,
+        indexGroup: ledgerEntry.indexGroup,
+      });
+
+      if (ledgerEntry.credit) {
+        journal.credit(entry);
+      }
+      if (ledgerEntry.debit) {
+        journal.debit(entry);
+      }
+    });
+
+    await Promise.all([
+      journal.deleteEntries(),
+      journal.saveBalance(),
+      journal.saveContactsBalance(),
+      journal.saveEntries(),
+    ]);
+  }
+}
diff --git a/packages/server/src/services/ManualJournals/AutoIncrementManualJournal.ts b/packages/server/src/services/ManualJournals/AutoIncrementManualJournal.ts
new file mode 100644
index 000000000..d8d9b3665
--- /dev/null
+++ b/packages/server/src/services/ManualJournals/AutoIncrementManualJournal.ts
@@ -0,0 +1,36 @@
+import { Inject, Service } from 'typedi';
+import AutoIncrementOrdersService from '@/services/Sales/AutoIncrementOrdersService';
+
+@Service()
+export class AutoIncrementManualJournal {
+  @Inject()
+  private autoIncrementOrdersService: AutoIncrementOrdersService;
+
+  public autoIncrementEnabled = (tenantId: number) => {
+    return this.autoIncrementOrdersService.autoIncrementEnabled(
+      tenantId,
+      'manual_journals'
+    );
+  };
+
+  /**
+   * Retrieve the next journal number.
+   */
+  public getNextJournalNumber = (tenantId: number): string => {
+    return this.autoIncrementOrdersService.getNextTransactionNumber(
+      tenantId,
+      'manual_journals'
+    );
+  };
+
+  /**
+   * Increment the manual journal number.
+   * @param {number} tenantId
+   */
+  public incrementNextJournalNumber = (tenantId: number) => {
+    return this.autoIncrementOrdersService.incrementSettingsNextNumber(
+      tenantId,
+      'manual_journals'
+    );
+  };
+}
diff --git a/packages/server/src/services/ManualJournals/CommandManualJournalValidators.ts b/packages/server/src/services/ManualJournals/CommandManualJournalValidators.ts
new file mode 100644
index 000000000..01db91ca8
--- /dev/null
+++ b/packages/server/src/services/ManualJournals/CommandManualJournalValidators.ts
@@ -0,0 +1,312 @@
+import { difference, sumBy, omit, map } from 'lodash';
+import { Service, Inject } from 'typedi';
+import { ServiceError } from '@/exceptions';
+import {
+  IManualJournalDTO,
+  IManualJournalEntry,
+  IManualJournal,
+  IManualJournalEntryDTO,
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import { ERRORS } from './constants';
+import { AutoIncrementManualJournal } from './AutoIncrementManualJournal';
+
+@Service()
+export class CommandManualJournalValidators {
+  @Inject()
+  private tenancy: TenancyService;
+
+  @Inject()
+  private autoIncrement: AutoIncrementManualJournal;
+
+  /**
+   * Validate manual journal credit and debit should be equal.
+   * @param {IManualJournalDTO} manualJournalDTO
+   */
+  public valdiateCreditDebitTotalEquals(manualJournalDTO: IManualJournalDTO) {
+    let totalCredit = 0;
+    let totalDebit = 0;
+
+    manualJournalDTO.entries.forEach((entry) => {
+      if (entry.credit > 0) {
+        totalCredit += entry.credit;
+      }
+      if (entry.debit > 0) {
+        totalDebit += entry.debit;
+      }
+    });
+    if (totalCredit <= 0 || totalDebit <= 0) {
+      throw new ServiceError(ERRORS.CREDIT_DEBIT_NOT_EQUAL_ZERO);
+    }
+    if (totalCredit !== totalDebit) {
+      throw new ServiceError(ERRORS.CREDIT_DEBIT_NOT_EQUAL);
+    }
+  }
+
+  /**
+   * Validate manual entries accounts existance on the storage.
+   * @param {number} tenantId -
+   * @param {IManualJournalDTO} manualJournalDTO -
+   */
+  public async validateAccountsExistance(
+    tenantId: number,
+    manualJournalDTO: IManualJournalDTO
+  ) {
+    const { Account } = this.tenancy.models(tenantId);
+    const manualAccountsIds = manualJournalDTO.entries.map((e) => e.accountId);
+
+    const accounts = await Account.query().whereIn('id', manualAccountsIds);
+
+    const storedAccountsIds = accounts.map((account) => account.id);
+
+    if (difference(manualAccountsIds, storedAccountsIds).length > 0) {
+      throw new ServiceError(ERRORS.ACCCOUNTS_IDS_NOT_FOUND);
+    }
+  }
+
+  /**
+   * Validate manual journal number unique.
+   * @param {number} tenantId
+   * @param {IManualJournalDTO} manualJournalDTO
+   */
+  public async validateManualJournalNoUnique(
+    tenantId: number,
+    journalNumber: string,
+    notId?: number
+  ) {
+    const { ManualJournal } = this.tenancy.models(tenantId);
+    const journals = await ManualJournal.query()
+      .where('journal_number', journalNumber)
+      .onBuild((builder) => {
+        if (notId) {
+          builder.whereNot('id', notId);
+        }
+      });
+    if (journals.length > 0) {
+      throw new ServiceError(ERRORS.JOURNAL_NUMBER_EXISTS);
+    }
+  }
+
+  /**
+   * Validate accounts with contact type.
+   * @param {number} tenantId
+   * @param {IManualJournalDTO} manualJournalDTO
+   * @param {string} accountBySlug
+   * @param {string} contactType
+   */
+  public async validateAccountWithContactType(
+    tenantId: number,
+    entriesDTO: IManualJournalEntry[],
+    accountBySlug: string,
+    contactType: string
+  ): Promise<void | ServiceError> {
+    const { Account } = this.tenancy.models(tenantId);
+    const { contactRepository } = this.tenancy.repositories(tenantId);
+
+    // Retrieve account meta by the given account slug.
+    const account = await Account.query().findOne('slug', accountBySlug);
+
+    // Retrieve all stored contacts on the storage from contacts entries.
+    const storedContacts = await contactRepository.findWhereIn(
+      'id',
+      entriesDTO
+        .filter((entry) => entry.contactId)
+        .map((entry) => entry.contactId)
+    );
+    // Converts the stored contacts to map with id as key and entry as value.
+    const storedContactsMap = new Map(
+      storedContacts.map((contact) => [contact.id, contact])
+    );
+
+    // Filter all entries of the given account.
+    const accountEntries = entriesDTO.filter(
+      (entry) => entry.accountId === account.id
+    );
+    // Can't continue if there is no entry that associate to the given account.
+    if (accountEntries.length === 0) {
+      return;
+    }
+    // Filter entries that have no contact type or not equal the valid type.
+    const entriesNoContact = accountEntries.filter((entry) => {
+      const contact = storedContactsMap.get(entry.contactId);
+      return !contact || contact.contactService !== contactType;
+    });
+    // Throw error in case one of entries that has invalid contact type.
+    if (entriesNoContact.length > 0) {
+      const indexes = entriesNoContact.map((e) => e.index);
+
+      return new ServiceError(ERRORS.ENTRIES_SHOULD_ASSIGN_WITH_CONTACT, '', {
+        accountSlug: accountBySlug,
+        contactType,
+        indexes,
+      });
+    }
+  }
+
+  /**
+   * Dynamic validates accounts with contacts.
+   * @param {number} tenantId
+   * @param {IManualJournalDTO} manualJournalDTO
+   */
+  public async dynamicValidateAccountsWithContactType(
+    tenantId: number,
+    entriesDTO: IManualJournalEntry[]
+  ): Promise<any> {
+    return Promise.all([
+      this.validateAccountWithContactType(
+        tenantId,
+        entriesDTO,
+        'accounts-receivable',
+        'customer'
+      ),
+      this.validateAccountWithContactType(
+        tenantId,
+        entriesDTO,
+        'accounts-payable',
+        'vendor'
+      ),
+    ]).then((results) => {
+      const metadataErrors = results
+        .filter((result) => result instanceof ServiceError)
+        .map((result: ServiceError) => result.payload);
+
+      if (metadataErrors.length > 0) {
+        throw new ServiceError(
+          ERRORS.ENTRIES_SHOULD_ASSIGN_WITH_CONTACT,
+          '',
+          metadataErrors
+        );
+      }
+
+      return results;
+    });
+  }
+
+  /**
+   * Validate entries contacts existance.
+   * @param {number} tenantId -
+   * @param {IManualJournalDTO} manualJournalDTO
+   */
+  public async validateContactsExistance(
+    tenantId: number,
+    manualJournalDTO: IManualJournalDTO
+  ) {
+    const { contactRepository } = this.tenancy.repositories(tenantId);
+
+    // Filters the entries that have contact only.
+    const entriesContactPairs = manualJournalDTO.entries.filter(
+      (entry) => entry.contactId
+    );
+
+    if (entriesContactPairs.length > 0) {
+      const entriesContactsIds = entriesContactPairs.map(
+        (entry) => entry.contactId
+      );
+      // Retrieve all stored contacts on the storage from contacts entries.
+      const storedContacts = await contactRepository.findWhereIn(
+        'id',
+        entriesContactsIds
+      );
+      // Converts the stored contacts to map with id as key and entry as value.
+      const storedContactsMap = new Map(
+        storedContacts.map((contact) => [contact.id, contact])
+      );
+      const notFoundContactsIds = [];
+
+      entriesContactPairs.forEach((contactEntry) => {
+        const storedContact = storedContactsMap.get(contactEntry.contactId);
+
+        // in case the contact id not found.
+        if (!storedContact) {
+          notFoundContactsIds.push(storedContact);
+        }
+      });
+      if (notFoundContactsIds.length > 0) {
+        throw new ServiceError(ERRORS.CONTACTS_NOT_FOUND, '', {
+          contactsIds: notFoundContactsIds,
+        });
+      }
+    }
+  }
+
+  /**
+   * Validates expenses is not already published before.
+   * @param {IManualJournal} manualJournal
+   */
+  public validateManualJournalIsNotPublished(manualJournal: IManualJournal) {
+    if (manualJournal.publishedAt) {
+      throw new ServiceError(ERRORS.MANUAL_JOURNAL_ALREADY_PUBLISHED);
+    }
+  }
+
+  /**
+   * Validates the manual journal number require.
+   * @param {string} journalNumber
+   */
+  public validateJournalNoRequireWhenAutoNotEnabled = (
+    tenantId: number,
+    journalNumber: string
+  ) => {
+    // Retrieve the next manual journal number.
+    const autoIncrmenetEnabled =
+      this.autoIncrement.autoIncrementEnabled(tenantId);
+
+    if (!journalNumber || !autoIncrmenetEnabled) {
+      throw new ServiceError(ERRORS.MANUAL_JOURNAL_NO_REQUIRED);
+    }
+  };
+
+  /**
+   * Filters the not published manual jorunals.
+   * @param {IManualJournal[]} manualJournal - Manual journal.
+   * @return {IManualJournal[]}
+   */
+  public getNonePublishedManualJournals(
+    manualJournals: IManualJournal[]
+  ): IManualJournal[] {
+    return manualJournals.filter((manualJournal) => !manualJournal.publishedAt);
+  }
+
+  /**
+   * Filters the published manual journals.
+   * @param {IManualJournal[]} manualJournal - Manual journal.
+   * @return {IManualJournal[]}
+   */
+  public getPublishedManualJournals(
+    manualJournals: IManualJournal[]
+  ): IManualJournal[] {
+    return manualJournals.filter((expense) => expense.publishedAt);
+  }
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {IManualJournalDTO} manualJournalDTO
+   */
+  public validateJournalCurrencyWithAccountsCurrency = async (
+    tenantId: number,
+    manualJournalDTO: IManualJournalDTO,
+    baseCurrency: string,
+  ) => {
+    const { Account } = this.tenancy.models(tenantId);
+
+    const accountsIds = manualJournalDTO.entries.map((e) => e.accountId);
+    const accounts = await Account.query().whereIn('id', accountsIds);
+
+    // Filters the accounts that has no base currency or DTO currency.
+    const notSupportedCurrency = accounts.filter((account) => {
+      if (
+        account.currencyCode === baseCurrency ||
+        account.currencyCode === manualJournalDTO.currencyCode
+      ) {
+        return false;
+      }
+      return true;
+    });
+    if (notSupportedCurrency.length > 0) {
+      throw new ServiceError(
+        ERRORS.COULD_NOT_ASSIGN_DIFFERENT_CURRENCY_TO_ACCOUNTS
+      );
+    }
+  };
+}
diff --git a/packages/server/src/services/ManualJournals/CreateManualJournal.ts b/packages/server/src/services/ManualJournals/CreateManualJournal.ts
new file mode 100644
index 000000000..4cd213947
--- /dev/null
+++ b/packages/server/src/services/ManualJournals/CreateManualJournal.ts
@@ -0,0 +1,182 @@
+import { sumBy, omit } from 'lodash';
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import * as R from 'ramda';
+import { Knex } from 'knex';
+import {
+  IManualJournalDTO,
+  ISystemUser,
+  IManualJournal,
+  IManualJournalEventCreatedPayload,
+  IManualJournalCreatingPayload,
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import { Tenant, TenantMetadata } from '@/system/models';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import { CommandManualJournalValidators } from './CommandManualJournalValidators';
+import { AutoIncrementManualJournal } from './AutoIncrementManualJournal';
+import { ManualJournalBranchesDTOTransformer } from '@/services/Branches/Integrations/ManualJournals/ManualJournalDTOTransformer';
+@Service()
+export class CreateManualJournalService {
+  @Inject()
+  private tenancy: TenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private validator: CommandManualJournalValidators;
+
+  @Inject()
+  private autoIncrement: AutoIncrementManualJournal;
+
+  @Inject()
+  private branchesDTOTransformer: ManualJournalBranchesDTOTransformer;
+
+  /**
+   * Transform the new manual journal DTO to upsert graph operation.
+   * @param {IManualJournalDTO} manualJournalDTO - Manual jorunal DTO.
+   * @param {ISystemUser} authorizedUser
+   */
+  private transformNewDTOToModel(
+    tenantId,
+    manualJournalDTO: IManualJournalDTO,
+    authorizedUser: ISystemUser,
+    baseCurrency: string
+  ) {
+    const amount = sumBy(manualJournalDTO.entries, 'credit') || 0;
+    const date = moment(manualJournalDTO.date).format('YYYY-MM-DD');
+
+    // Retrieve the next manual journal number.
+    const autoNextNumber = this.autoIncrement.getNextJournalNumber(tenantId);
+
+    // The manual or auto-increment journal number.
+    const journalNumber = manualJournalDTO.journalNumber || autoNextNumber;
+
+    const initialDTO = {
+      ...omit(manualJournalDTO, ['publish']),
+      ...(manualJournalDTO.publish
+        ? { publishedAt: moment().toMySqlDateTime() }
+        : {}),
+      amount,
+      currencyCode: manualJournalDTO.currencyCode || baseCurrency,
+      exchangeRate: manualJournalDTO.exchangeRate || 1,
+      date,
+      journalNumber,
+      userId: authorizedUser.id,
+    };
+    return R.compose(
+      // Omits the `branchId` from entries if multiply branches feature not active.
+      this.branchesDTOTransformer.transformDTO(tenantId)
+    )(
+      initialDTO
+    );
+  }
+
+  /**
+   * Authorize the manual journal creating.
+   * @param {number} tenantId
+   * @param {IManualJournalDTO} manualJournalDTO
+   * @param {ISystemUser} authorizedUser
+   */
+  private authorize = async (
+    tenantId: number,
+    manualJournalDTO: IManualJournalDTO,
+    authorizedUser: ISystemUser,
+    baseCurrency: string
+  ) => {
+    // Validate the total credit should equals debit.
+    this.validator.valdiateCreditDebitTotalEquals(manualJournalDTO);
+
+    // Validate the contacts existance.
+    await this.validator.validateContactsExistance(tenantId, manualJournalDTO);
+
+    // Validate entries accounts existance.
+    await this.validator.validateAccountsExistance(tenantId, manualJournalDTO);
+
+    // Validate manual journal number require when auto-increment not enabled.
+    this.validator.validateJournalNoRequireWhenAutoNotEnabled(
+      tenantId,
+      manualJournalDTO.journalNumber
+    );
+    // Validate manual journal uniquiness on the storage.
+    if (manualJournalDTO.journalNumber) {
+      await this.validator.validateManualJournalNoUnique(
+        tenantId,
+        manualJournalDTO.journalNumber
+      );
+    }
+    // Validate accounts with contact type from the given config.
+    await this.validator.dynamicValidateAccountsWithContactType(
+      tenantId,
+      manualJournalDTO.entries
+    );
+    // Validates the accounts currency with journal currency.
+    await this.validator.validateJournalCurrencyWithAccountsCurrency(
+      tenantId,
+      manualJournalDTO,
+      baseCurrency
+    );
+  };
+
+  /**
+   * Make journal entries.
+   * @param {number} tenantId
+   * @param {IManualJournalDTO} manualJournalDTO
+   * @param {ISystemUser} authorizedUser
+   */
+  public makeJournalEntries = async (
+    tenantId: number,
+    manualJournalDTO: IManualJournalDTO,
+    authorizedUser: ISystemUser
+  ): Promise<{ manualJournal: IManualJournal }> => {
+    const { ManualJournal } = this.tenancy.models(tenantId);
+
+    // Retrieves the tenant metadata.
+    const tenantMeta = await TenantMetadata.query().findOne({ tenantId });
+
+    // Authorize manual journal creating.
+    await this.authorize(
+      tenantId,
+      manualJournalDTO,
+      authorizedUser,
+      tenantMeta.baseCurrency
+    );
+    // Transformes the next DTO to model.
+    const manualJournalObj = this.transformNewDTOToModel(
+      tenantId,
+      manualJournalDTO,
+      authorizedUser,
+      tenantMeta.baseCurrency
+    );
+    // Creates a manual journal transactions with associated transactions
+    // under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onManualJournalCreating` event.
+      await this.eventPublisher.emitAsync(events.manualJournals.onCreating, {
+        tenantId,
+        manualJournalDTO,
+        trx,
+      } as IManualJournalCreatingPayload);
+
+      // Upsert the manual journal object.
+      const manualJournal = await ManualJournal.query(trx).upsertGraph({
+        ...manualJournalObj,
+      });
+      // Triggers `onManualJournalCreated` event.
+      await this.eventPublisher.emitAsync(events.manualJournals.onCreated, {
+        tenantId,
+        manualJournal,
+        manualJournalId: manualJournal.id,
+        trx,
+      } as IManualJournalEventCreatedPayload);
+
+      return { manualJournal };
+    });
+  };
+}
diff --git a/packages/server/src/services/ManualJournals/DeleteManualJournal.ts b/packages/server/src/services/ManualJournals/DeleteManualJournal.ts
new file mode 100644
index 000000000..1635972b7
--- /dev/null
+++ b/packages/server/src/services/ManualJournals/DeleteManualJournal.ts
@@ -0,0 +1,71 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import {
+  IManualJournal,
+  IManualJournalEventDeletedPayload,
+  IManualJournalDeletingPayload,
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+@Service()
+export class DeleteManualJournal {
+  @Inject()
+  private tenancy: TenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  /**
+   * Deletes the given manual journal
+   * @param {number} tenantId
+   * @param {number} manualJournalId
+   * @return {Promise<void>}
+   */
+  public deleteManualJournal = async (
+    tenantId: number,
+    manualJournalId: number
+  ): Promise<{
+    oldManualJournal: IManualJournal;
+  }> => {
+    const { ManualJournal, ManualJournalEntry } = this.tenancy.models(tenantId);
+
+    // Validate the manual journal exists on the storage.
+    const oldManualJournal = await ManualJournal.query()
+      .findById(manualJournalId)
+      .throwIfNotFound();
+
+    // Deletes the manual journal with associated transactions under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onManualJournalDeleting` event.
+      await this.eventPublisher.emitAsync(events.manualJournals.onDeleting, {
+        tenantId,
+        oldManualJournal,
+        trx,
+      } as IManualJournalDeletingPayload);
+
+      // Deletes the manual journal entries.
+      await ManualJournalEntry.query(trx)
+        .where('manualJournalId', manualJournalId)
+        .delete();
+
+      // Deletes the manual journal transaction.
+      await ManualJournal.query(trx).findById(manualJournalId).delete();
+
+      // Triggers `onManualJournalDeleted` event.
+      await this.eventPublisher.emitAsync(events.manualJournals.onDeleted, {
+        tenantId,
+        manualJournalId,
+        oldManualJournal,
+        trx,
+      } as IManualJournalEventDeletedPayload);
+
+      return { oldManualJournal };
+    });
+  };
+}
diff --git a/packages/server/src/services/ManualJournals/EditManualJournal.ts b/packages/server/src/services/ManualJournals/EditManualJournal.ts
new file mode 100644
index 000000000..39ff8cb8e
--- /dev/null
+++ b/packages/server/src/services/ManualJournals/EditManualJournal.ts
@@ -0,0 +1,152 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import { omit, sumBy } from 'lodash';
+import moment from 'moment';
+import {
+  IManualJournalDTO,
+  ISystemUser,
+  IManualJournal,
+  IManualJournalEventEditedPayload,
+  IManualJournalEditingPayload,
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import { CommandManualJournalValidators } from './CommandManualJournalValidators';
+
+@Service()
+export class EditManualJournal {
+  @Inject()
+  private tenancy: TenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private validator: CommandManualJournalValidators;
+
+  /**
+   * Authorize the manual journal editing.
+   * @param {number} tenantId
+   * @param {number} manualJournalId
+   * @param {IManualJournalDTO} manualJournalDTO
+   */
+  private authorize = async (
+    tenantId: number,
+    manualJournalId: number,
+    manualJournalDTO: IManualJournalDTO
+  ) => {
+    // Validates the total credit and debit to be equals.
+    this.validator.valdiateCreditDebitTotalEquals(manualJournalDTO);
+
+    // Validate the contacts existance.
+    await this.validator.validateContactsExistance(tenantId, manualJournalDTO);
+
+    // Validates entries accounts existance.
+    await this.validator.validateAccountsExistance(tenantId, manualJournalDTO);
+
+    // Validates the manual journal number uniquiness.
+    if (manualJournalDTO.journalNumber) {
+      await this.validator.validateManualJournalNoUnique(
+        tenantId,
+        manualJournalDTO.journalNumber,
+        manualJournalId
+      );
+    }
+    // Validate accounts with contact type from the given config.
+    await this.validator.dynamicValidateAccountsWithContactType(
+      tenantId,
+      manualJournalDTO.entries
+    );
+  };
+
+  /**
+   * Transform the edit manual journal DTO to upsert graph operation.
+   * @param {IManualJournalDTO} manualJournalDTO - Manual jorunal DTO.
+   * @param {IManualJournal} oldManualJournal
+   */
+  private transformEditDTOToModel = (
+    manualJournalDTO: IManualJournalDTO,
+    oldManualJournal: IManualJournal
+  ) => {
+    const amount = sumBy(manualJournalDTO.entries, 'credit') || 0;
+    const date = moment(manualJournalDTO.date).format('YYYY-MM-DD');
+
+    return {
+      id: oldManualJournal.id,
+      ...omit(manualJournalDTO, ['publish']),
+      ...(manualJournalDTO.publish && !oldManualJournal.publishedAt
+        ? { publishedAt: moment().toMySqlDateTime() }
+        : {}),
+      amount,
+      date,
+    };
+  };
+
+  /**
+   * Edits jouranl entries.
+   * @param {number} tenantId
+   * @param {number} manualJournalId
+   * @param {IMakeJournalDTO} manualJournalDTO
+   * @param {ISystemUser} authorizedUser
+   */
+  public async editJournalEntries(
+    tenantId: number,
+    manualJournalId: number,
+    manualJournalDTO: IManualJournalDTO,
+    authorizedUser: ISystemUser
+  ): Promise<{
+    manualJournal: IManualJournal;
+    oldManualJournal: IManualJournal;
+  }> {
+    const { ManualJournal } = this.tenancy.models(tenantId);
+
+    // Validates the manual journal existance on the storage.
+    const oldManualJournal = await ManualJournal.query()
+      .findById(manualJournalId)
+      .throwIfNotFound();
+
+    // Authorize manual journal editing.
+    await this.authorize(tenantId, manualJournalId, manualJournalDTO);
+
+    // Transform manual journal DTO to model.
+    const manualJournalObj = this.transformEditDTOToModel(
+      manualJournalDTO,
+      oldManualJournal
+    );
+    // Edits the manual journal transactions with associated transactions
+    // under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onManualJournalEditing` event.
+      await this.eventPublisher.emitAsync(events.manualJournals.onEditing, {
+        tenantId,
+        manualJournalDTO,
+        oldManualJournal,
+        trx,
+      } as IManualJournalEditingPayload);
+
+      // Upserts the manual journal graph to the storage.
+      await ManualJournal.query(trx).upsertGraph({
+        ...manualJournalObj,
+      });
+      // Retrieve the given manual journal with associated entries after modifications.
+      const manualJournal = await ManualJournal.query(trx)
+        .findById(manualJournalId)
+        .withGraphFetched('entries');
+
+      // Triggers `onManualJournalEdited` event.
+      await this.eventPublisher.emitAsync(events.manualJournals.onEdited, {
+        tenantId,
+        manualJournal,
+        oldManualJournal,
+        trx,
+      } as IManualJournalEventEditedPayload);
+
+      return { manualJournal, oldManualJournal };
+    });
+  }
+}
diff --git a/packages/server/src/services/ManualJournals/GetManualJournal.ts b/packages/server/src/services/ManualJournals/GetManualJournal.ts
new file mode 100644
index 000000000..9f4f5c530
--- /dev/null
+++ b/packages/server/src/services/ManualJournals/GetManualJournal.ts
@@ -0,0 +1,40 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ManualJournalTransfromer } from './ManualJournalTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export class GetManualJournal {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve manual journal details with assocaited journal transactions.
+   * @param {number} tenantId
+   * @param {number} manualJournalId
+   */
+  public getManualJournal = async (
+    tenantId: number,
+    manualJournalId: number
+  ) => {
+    const { ManualJournal } = this.tenancy.models(tenantId);
+
+    const manualJournal = await ManualJournal.query()
+      .findById(manualJournalId)
+      .withGraphFetched('entries.account')
+      .withGraphFetched('entries.contact')
+      .withGraphFetched('entries.branch')
+      .withGraphFetched('transactions')
+      .withGraphFetched('media')
+      .throwIfNotFound();
+
+    return this.transformer.transform(
+      tenantId,
+      manualJournal,
+      new ManualJournalTransfromer()
+    );
+  };
+}
diff --git a/packages/server/src/services/ManualJournals/GetManualJournals.ts b/packages/server/src/services/ManualJournals/GetManualJournals.ts
new file mode 100644
index 000000000..b6bca8848
--- /dev/null
+++ b/packages/server/src/services/ManualJournals/GetManualJournals.ts
@@ -0,0 +1,77 @@
+import { Service, Inject } from 'typedi';
+import * as R from 'ramda';
+import {
+  IManualJournalsFilter,
+  IManualJournal,
+  IPaginationMeta,
+  IFilterMeta,
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { ManualJournalTransfromer } from './ManualJournalTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export class GetManualJournals {
+  @Inject()
+  private tenancy: TenancyService;
+
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Parses filter DTO of the manual journals list.
+   * @param filterDTO
+   */
+  private parseListFilterDTO = (filterDTO) => {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  };
+
+  /**
+   * Retrieve manual journals datatable list.
+   * @param {number} tenantId -
+   * @param {IManualJournalsFilter} filter -
+   */
+  public getManualJournals = async (
+    tenantId: number,
+    filterDTO: IManualJournalsFilter
+  ): Promise<{
+    manualJournals: IManualJournal;
+    pagination: IPaginationMeta;
+    filterMeta: IFilterMeta;
+  }> => {
+    const { ManualJournal } = this.tenancy.models(tenantId);
+
+    // Parses filter DTO.
+    const filter = this.parseListFilterDTO(filterDTO);
+
+    // Dynamic service.
+    const dynamicService = await this.dynamicListService.dynamicList(
+      tenantId,
+      ManualJournal,
+      filter
+    );
+    const { results, pagination } = await ManualJournal.query()
+      .onBuild((builder) => {
+        dynamicService.buildQuery()(builder);
+        builder.withGraphFetched('entries.account');
+      })
+      .pagination(filter.page - 1, filter.pageSize);
+
+    // Transformes the manual journals models to POJO.
+    const manualJournals = await this.transformer.transform(
+      tenantId,
+      results,
+      new ManualJournalTransfromer()
+    );
+
+    return {
+      manualJournals,
+      pagination,
+      filterMeta: dynamicService.getResponseMeta(),
+    };
+  };
+}
diff --git a/packages/server/src/services/ManualJournals/ManualJournalGLEntries.ts b/packages/server/src/services/ManualJournals/ManualJournalGLEntries.ts
new file mode 100644
index 000000000..dc3c4052f
--- /dev/null
+++ b/packages/server/src/services/ManualJournals/ManualJournalGLEntries.ts
@@ -0,0 +1,163 @@
+import { Service, Inject } from 'typedi';
+import * as R from 'ramda';
+import {
+  IManualJournal,
+  IManualJournalEntry,
+  IAccount,
+  ILedgerEntry,
+} from '@/interfaces';
+import { Knex } from 'knex';
+import Ledger from '@/services/Accounting/Ledger';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { LedgerRevert } from '@/services/Accounting/LedgerStorageRevert';
+
+@Service()
+export class ManualJournalGLEntries {
+  @Inject()
+  ledgerStorage: LedgerStorageService;
+
+  @Inject()
+  ledgerRevert: LedgerRevert;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Create manual journal GL entries.
+   * @param {number} tenantId
+   * @param {number} manualJournalId
+   * @param {Knex.Transaction} trx
+   */
+  public createManualJournalGLEntries = async (
+    tenantId: number,
+    manualJournalId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { ManualJournal } = this.tenancy.models(tenantId);
+
+    // Retrieves the given manual journal with associated entries.
+    const manualJournal = await ManualJournal.query(trx)
+      .findById(manualJournalId)
+      .withGraphFetched('entries.account');
+
+    // Retrieves the ledger entries of the given manual journal.
+    const ledger = this.getManualJournalGLedger(manualJournal);
+
+    // Commits the given ledger on the storage.
+    await this.ledgerStorage.commit(tenantId, ledger, trx);
+  };
+
+  /**
+   * Edits manual journal GL entries.
+   * @param {number} tenantId
+   * @param {number} manualJournalId
+   * @param {Knex.Transaction} trx
+   */
+  public editManualJournalGLEntries = async (
+    tenantId: number,
+    manualJournalId: number,
+    trx?: Knex.Transaction
+  ) => {
+    // Reverts the manual journal GL entries.
+    await this.revertManualJournalGLEntries(tenantId, manualJournalId, trx);
+
+    // Write the manual journal GL entries.
+    await this.createManualJournalGLEntries(tenantId, manualJournalId, trx);
+  };
+
+  /**
+   * Deletes the manual journal GL entries.
+   * @param {number} tenantId
+   * @param {number} manualJournalId
+   * @param {Knex.Transaction} trx
+   */
+  public revertManualJournalGLEntries = async (
+    tenantId: number,
+    manualJournalId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    return this.ledgerRevert.revertGLEntries(
+      tenantId,
+      manualJournalId,
+      'Journal',
+      trx
+    );
+  };
+
+  /**
+   *
+   * @param   {IManualJournal} manualJournal
+   * @returns {Ledger}
+   */
+  private getManualJournalGLedger = (manualJournal: IManualJournal) => {
+    const entries = this.getManualJournalGLEntries(manualJournal);
+
+    return new Ledger(entries);
+  };
+
+  /**
+   *
+   * @param   {IManualJournal} manualJournal
+   * @returns {}
+   */
+  private getManualJournalCommonEntry = (manualJournal: IManualJournal) => {
+    return {
+      transactionNumber: manualJournal.journalNumber,
+      referenceNumber: manualJournal.reference,
+      createdAt: manualJournal.createdAt,
+      date: manualJournal.date,
+      currencyCode: manualJournal.currencyCode,
+      exchangeRate: manualJournal.exchangeRate,
+
+      transactionType: 'Journal',
+      transactionId: manualJournal.id,
+
+      userId: manualJournal.userId,
+    };
+  };
+
+  /**
+   *
+   * @param   {IManualJournal} manualJournal -
+   * @param   {IManualJournalEntry} entry -
+   * @returns {ILedgerEntry}
+   */
+  private getManualJournalEntry = R.curry(
+    (
+      manualJournal: IManualJournal,
+      entry: IManualJournalEntry
+    ): ILedgerEntry => {
+      const commonEntry = this.getManualJournalCommonEntry(manualJournal);
+
+      return {
+        ...commonEntry,
+        debit: entry.debit,
+        credit: entry.credit,
+        accountId: entry.accountId,
+
+        contactId: entry.contactId,
+        note: entry.note,
+
+        index: entry.index,
+        accountNormal: entry.account.accountNormal,
+
+        branchId: entry.branchId,
+        projectId: entry.projectId,
+      };
+    }
+  );
+
+  /**
+   *
+   * @param   {IManualJournal} manualJournal
+   * @returns {ILedgerEntry[]}
+   */
+  private getManualJournalGLEntries = (
+    manualJournal: IManualJournal
+  ): ILedgerEntry[] => {
+    const transformEntry = this.getManualJournalEntry(manualJournal);
+
+    return manualJournal.entries.map(transformEntry).flat();
+  };
+}
diff --git a/packages/server/src/services/ManualJournals/ManualJournalGLEntriesSubscriber.ts b/packages/server/src/services/ManualJournals/ManualJournalGLEntriesSubscriber.ts
new file mode 100644
index 000000000..c5efa8f12
--- /dev/null
+++ b/packages/server/src/services/ManualJournals/ManualJournalGLEntriesSubscriber.ts
@@ -0,0 +1,127 @@
+import { Inject } from 'typedi';
+import { EventSubscriber } from 'event-dispatch';
+import {
+  IManualJournalEventCreatedPayload,
+  IManualJournalEventEditedPayload,
+  IManualJournalEventPublishedPayload,
+  IManualJournalEventDeletedPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import { ManualJournalGLEntries } from './ManualJournalGLEntries';
+import { AutoIncrementManualJournal } from './AutoIncrementManualJournal';
+
+@EventSubscriber()
+export class ManualJournalWriteGLSubscriber {
+  @Inject()
+  private manualJournalGLEntries: ManualJournalGLEntries;
+
+  @Inject()
+  private manualJournalAutoIncrement: AutoIncrementManualJournal;
+
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.manualJournals.onCreated,
+      this.handleWriteJournalEntriesOnCreated
+    );
+    bus.subscribe(
+      events.manualJournals.onCreated,
+      this.handleJournalNumberIncrement
+    );
+    bus.subscribe(
+      events.manualJournals.onEdited,
+      this.handleRewriteJournalEntriesOnEdited
+    );
+    bus.subscribe(
+      events.manualJournals.onPublished,
+      this.handleWriteJournalEntriesOnPublished
+    );
+    bus.subscribe(
+      events.manualJournals.onDeleted,
+      this.handleRevertJournalEntries
+    );
+  }
+
+  /**
+   * Handle manual journal created event.
+   * @param {IManualJournalEventCreatedPayload} payload -
+   */
+  private handleWriteJournalEntriesOnCreated = async ({
+    tenantId,
+    manualJournal,
+    trx,
+  }: IManualJournalEventCreatedPayload) => {
+    // Ingore writing manual journal journal entries in case was not published.
+    if (manualJournal.publishedAt) {
+      await this.manualJournalGLEntries.createManualJournalGLEntries(
+        tenantId,
+        manualJournal.id,
+        trx
+      );
+    }
+  };
+
+  /**
+   * Handles the manual journal next number increment once the journal be created.
+   * @param {IManualJournalEventCreatedPayload} payload -
+   */
+  private handleJournalNumberIncrement = async ({
+    tenantId,
+  }: IManualJournalEventCreatedPayload) => {
+    await this.manualJournalAutoIncrement.incrementNextJournalNumber(tenantId);
+  };
+
+  /**
+   * Handle manual journal edited event.
+   * @param {IManualJournalEventEditedPayload}
+   */
+  private handleRewriteJournalEntriesOnEdited = async ({
+    tenantId,
+    manualJournal,
+    oldManualJournal,
+    trx,
+  }: IManualJournalEventEditedPayload) => {
+    if (manualJournal.publishedAt) {
+      await this.manualJournalGLEntries.editManualJournalGLEntries(
+        tenantId,
+        manualJournal.id,
+        trx
+      );
+    }
+  };
+
+  /**
+   * Handles writing journal entries once the manula journal publish.
+   * @param {IManualJournalEventPublishedPayload} payload -
+   */
+  private handleWriteJournalEntriesOnPublished = async ({
+    tenantId,
+    manualJournal,
+    trx,
+  }: IManualJournalEventPublishedPayload) => {
+    await this.manualJournalGLEntries.createManualJournalGLEntries(
+      tenantId,
+      manualJournal.id,
+      trx
+    );
+  };
+
+  /**
+   * Handle manual journal deleted event.
+   * @param {IManualJournalEventDeletedPayload} payload -
+   */
+  private handleRevertJournalEntries = async ({
+    tenantId,
+    manualJournalId,
+    trx,
+  }: IManualJournalEventDeletedPayload) => {
+    await this.manualJournalGLEntries.revertManualJournalGLEntries(
+      tenantId,
+      manualJournalId,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/ManualJournals/ManualJournalTransformer.ts b/packages/server/src/services/ManualJournals/ManualJournalTransformer.ts
new file mode 100644
index 000000000..7df4f71ae
--- /dev/null
+++ b/packages/server/src/services/ManualJournals/ManualJournalTransformer.ts
@@ -0,0 +1,42 @@
+import { IManualJournal } from '@/interfaces';
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class ManualJournalTransfromer extends Transformer {
+  /**
+   * Include these attributes to expense object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return ['formattedAmount', 'formattedDate', 'formattedPublishedAt'];
+  };
+
+  /**
+   * Retrieve formatted journal amount.
+   * @param {IManualJournal} manualJournal
+   * @returns {string}
+   */
+  protected formattedAmount = (manualJorunal: IManualJournal): string => {
+    return formatNumber(manualJorunal.amount, {
+      currencyCode: manualJorunal.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve formatted date.
+   * @param {IManualJournal} manualJournal
+   * @returns {string}
+   */
+  protected formattedDate = (manualJorunal: IManualJournal): string => {
+    return this.formatDate(manualJorunal.date);
+  };
+
+  /**
+   * Retrieve formatted published at date.
+   * @param {IManualJournal} manualJournal
+   * @returns {string}
+   */
+  protected formattedPublishedAt = (manualJorunal: IManualJournal): string => {
+    return this.formatDate(manualJorunal.publishedAt);
+  };
+}
diff --git a/packages/server/src/services/ManualJournals/ManualJournalsApplication.ts b/packages/server/src/services/ManualJournals/ManualJournalsApplication.ts
new file mode 100644
index 000000000..78167c803
--- /dev/null
+++ b/packages/server/src/services/ManualJournals/ManualJournalsApplication.ts
@@ -0,0 +1,124 @@
+import { Service, Inject } from 'typedi';
+import {
+  IManualJournalDTO,
+  IManualJournalsFilter,
+  ISystemUser,
+} from '@/interfaces';
+import { CreateManualJournalService } from './CreateManualJournal';
+import { DeleteManualJournal } from './DeleteManualJournal';
+import { EditManualJournal } from './EditManualJournal';
+import { PublishManualJournal } from './PublishManualJournal';
+import { GetManualJournals } from './GetManualJournals';
+import { GetManualJournal } from './GetManualJournal';
+
+@Service()
+export class ManualJournalsApplication {
+  @Inject()
+  private createManualJournalService: CreateManualJournalService;
+
+  @Inject()
+  private editManualJournalService: EditManualJournal;
+
+  @Inject()
+  private deleteManualJournalService: DeleteManualJournal;
+
+  @Inject()
+  private publishManualJournalService: PublishManualJournal;
+
+  @Inject()
+  private getManualJournalsService: GetManualJournals;
+
+  @Inject()
+  private getManualJournalService: GetManualJournal;
+
+  /**
+   * Make journal entries.
+   * @param   {number} tenantId
+   * @param   {IManualJournalDTO} manualJournalDTO
+   * @param   {ISystemUser} authorizedUser
+   * @returns {Promise<IManualJournal>}
+   */
+  public createManualJournal = (
+    tenantId: number,
+    manualJournalDTO: IManualJournalDTO,
+    authorizedUser: ISystemUser
+  ) => {
+    return this.createManualJournalService.makeJournalEntries(
+      tenantId,
+      manualJournalDTO,
+      authorizedUser
+    );
+  };
+
+  /**
+   * Edits jouranl entries.
+   * @param {number} tenantId
+   * @param {number} manualJournalId
+   * @param {IMakeJournalDTO} manualJournalDTO
+   * @param {ISystemUser} authorizedUser
+   */
+  public editManualJournal = (
+    tenantId: number,
+    manualJournalId: number,
+    manualJournalDTO: IManualJournalDTO,
+    authorizedUser: ISystemUser
+  ) => {
+    return this.editManualJournalService.editJournalEntries(
+      tenantId,
+      manualJournalId,
+      manualJournalDTO,
+      authorizedUser
+    );
+  };
+
+  /**
+   * Deletes the given manual journal
+   * @param  {number} tenantId
+   * @param  {number} manualJournalId
+   * @return {Promise<void>}
+   */
+  public deleteManualJournal = (tenantId: number, manualJournalId: number) => {
+    return this.deleteManualJournalService.deleteManualJournal(
+      tenantId,
+      manualJournalId
+    );
+  };
+
+  /**
+   * Publish the given manual journal.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} manualJournalId - Manual journal id.
+   */
+  public publishManualJournal = (tenantId: number, manualJournalId: number) => {
+    return this.publishManualJournalService.publishManualJournal(
+      tenantId,
+      manualJournalId
+    );
+  };
+
+  /**
+   * Retrieves the specific manual journal.
+   * @param   {number} tenantId
+   * @param   {number} manualJournalId
+   * @returns
+   */
+  public getManualJournal = (tenantId: number, manualJournalId: number) => {
+    return this.getManualJournalService.getManualJournal(
+      tenantId,
+      manualJournalId
+    );
+  };
+
+  /**
+   * Retrieves the paginated manual journals.
+   * @param {number} tenantId
+   * @param {IManualJournalsFilter} filterDTO
+   * @returns
+   */
+  public getManualJournals = (
+    tenantId: number,
+    filterDTO: IManualJournalsFilter
+  ) => {
+    return this.getManualJournalsService.getManualJournals(tenantId, filterDTO);
+  };
+}
diff --git a/packages/server/src/services/ManualJournals/PublishManualJournal.ts b/packages/server/src/services/ManualJournals/PublishManualJournal.ts
new file mode 100644
index 000000000..d2d2de702
--- /dev/null
+++ b/packages/server/src/services/ManualJournals/PublishManualJournal.ts
@@ -0,0 +1,87 @@
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import { Knex } from 'knex';
+import {
+  IManualJournal,
+  IManualJournalEventPublishedPayload,
+  IManualJournalPublishingPayload,
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import { CommandManualJournalValidators } from './CommandManualJournalValidators';
+
+@Service()
+export class PublishManualJournal {
+  @Inject()
+  private tenancy: TenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private validator: CommandManualJournalValidators;
+
+  /**
+   * Authorize the manual journal publishing.
+   * @param {number} tenantId
+   * @param {number} manualJournalId
+   */
+  private authorize = (tenantId: number, oldManualJournal: IManualJournal) => {
+    // Validate the manual journal is not published.
+    this.validator.validateManualJournalIsNotPublished(oldManualJournal);
+  };
+
+  /**
+   * Publish the given manual journal.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} manualJournalId - Manual journal id.
+   */
+  public async publishManualJournal(
+    tenantId: number,
+    manualJournalId: number
+  ): Promise<void> {
+    const { ManualJournal } = this.tenancy.models(tenantId);
+
+    // Find the old manual journal or throw not found error.
+    const oldManualJournal = await ManualJournal.query()
+      .findById(manualJournalId)
+      .throwIfNotFound();
+
+    // Authorize the manual journal publishing.
+    await this.authorize(tenantId, oldManualJournal);
+
+    // Publishes the manual journal with associated transactions.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onManualJournalPublishing` event.
+      await this.eventPublisher.emitAsync(events.manualJournals.onPublishing, {
+        oldManualJournal,
+        trx,
+        tenantId,
+      } as IManualJournalPublishingPayload);
+
+      // Mark the given manual journal as published.
+      await ManualJournal.query(trx).findById(manualJournalId).patch({
+        publishedAt: moment().toMySqlDateTime(),
+      });
+      // Retrieve the manual journal with enrties after modification.
+      const manualJournal = await ManualJournal.query()
+        .findById(manualJournalId)
+        .withGraphFetched('entries');
+
+      // Triggers `onManualJournalPublishedBulk` event.
+      await this.eventPublisher.emitAsync(events.manualJournals.onPublished, {
+        tenantId,
+        manualJournal,
+        manualJournalId,
+        oldManualJournal,
+        trx,
+      } as IManualJournalEventPublishedPayload);
+    });
+  }
+}
diff --git a/packages/server/src/services/ManualJournals/constants.ts b/packages/server/src/services/ManualJournals/constants.ts
new file mode 100644
index 000000000..ed085f2fc
--- /dev/null
+++ b/packages/server/src/services/ManualJournals/constants.ts
@@ -0,0 +1,31 @@
+export const ERRORS = {
+  NOT_FOUND: 'manual_journal_not_found',
+  CREDIT_DEBIT_NOT_EQUAL_ZERO: 'credit_debit_not_equal_zero',
+  CREDIT_DEBIT_NOT_EQUAL: 'credit_debit_not_equal',
+  ACCCOUNTS_IDS_NOT_FOUND: 'acccounts_ids_not_found',
+  JOURNAL_NUMBER_EXISTS: 'journal_number_exists',
+  ENTRIES_SHOULD_ASSIGN_WITH_CONTACT: 'ENTRIES_SHOULD_ASSIGN_WITH_CONTACT',
+  CONTACTS_NOT_FOUND: 'contacts_not_found',
+  ENTRIES_CONTACTS_NOT_FOUND: 'ENTRIES_CONTACTS_NOT_FOUND',
+  MANUAL_JOURNAL_ALREADY_PUBLISHED: 'MANUAL_JOURNAL_ALREADY_PUBLISHED',
+  MANUAL_JOURNAL_NO_REQUIRED: 'MANUAL_JOURNAL_NO_REQUIRED',
+  COULD_NOT_ASSIGN_DIFFERENT_CURRENCY_TO_ACCOUNTS:
+    'COULD_NOT_ASSIGN_DIFFERENT_CURRENCY_TO_ACCOUNTS',
+  MANUAL_JOURNAL_ENTRIES_HAVE_NO_BRANCH_ID:
+    'MANUAL_JOURNAL_ENTRIES_HAVE_NO_BRANCH_ID',
+};
+
+export const CONTACTS_CONFIG = [
+  {
+    accountBySlug: 'accounts-receivable',
+    contactService: 'customer',
+    assignRequired: true,
+  },
+  {
+    accountBySlug: 'accounts-payable',
+    contactService: 'vendor',
+    assignRequired: true,
+  },
+];
+
+export const DEFAULT_VIEWS = [];
diff --git a/packages/server/src/services/Media/MediaService.ts b/packages/server/src/services/Media/MediaService.ts
new file mode 100644
index 000000000..8f13cbddd
--- /dev/null
+++ b/packages/server/src/services/Media/MediaService.ts
@@ -0,0 +1,223 @@
+import fs from 'fs';
+import { Service, Inject } from 'typedi';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import { ServiceError } from "exceptions";
+import { IMedia, IMediaService } from '@/interfaces';
+import { difference } from 'lodash';
+
+const fsPromises = fs.promises;
+
+const ERRORS = {
+  MINETYPE_NOT_SUPPORTED: 'MINETYPE_NOT_SUPPORTED',
+  MEDIA_NOT_FOUND: 'MEDIA_NOT_FOUND',
+  MODEL_NAME_HAS_NO_MEDIA: 'MODEL_NAME_HAS_NO_MEDIA',
+  MODEL_ID_NOT_FOUND: 'MODEL_ID_NOT_FOUND',
+  MEDIA_IDS_NOT_FOUND: 'MEDIA_IDS_NOT_FOUND',
+  MEDIA_LINK_EXISTS: 'MEDIA_LINK_EXISTS'
+}
+const publicPath = 'storage/app/public/';
+const attachmentsMimes = ['image/png', 'image/jpeg'];
+
+@Service()
+export default class MediaService implements IMediaService {
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('repositories')
+  sysRepositories: any;
+
+  /**
+   * Retrieve media model or throw not found error
+   * @param tenantId 
+   * @param mediaId 
+   */
+  async getMediaOrThrowError(tenantId: number, mediaId: number) {
+    const { Media } = this.tenancy.models(tenantId);
+    const foundMedia = await Media.query().findById(mediaId);
+
+    if (!foundMedia) {
+      throw new ServiceError(ERRORS.MEDIA_NOT_FOUND);
+    }
+    return foundMedia;
+  }
+
+  /**
+   * Retreive media models by the given ids or throw not found error.
+   * @param {number} tenantId 
+   * @param {number[]} mediaIds 
+   */
+  async getMediaByIdsOrThrowError(tenantId: number, mediaIds: number[]) {
+    const { Media } = this.tenancy.models(tenantId);
+    const foundMedia = await Media.query().whereIn('id', mediaIds);
+
+    const storedMediaIds = foundMedia.map((m) => m.id);
+    const notFoundMedia = difference(mediaIds, storedMediaIds);
+
+    if (notFoundMedia.length > 0) {
+      throw new ServiceError(ERRORS.MEDIA_IDS_NOT_FOUND);
+    }
+    return foundMedia;
+  }
+
+  /**
+   * Validates the model name and id.
+   * @param {number} tenantId 
+   * @param {string} modelName 
+   * @param {number} modelId 
+   */
+  async validateModelNameAndIdExistance(tenantId: number, modelName: string, modelId: number) {
+    const models = this.tenancy.models(tenantId);
+    this.logger.info('[media] trying to validate model name and id.', { tenantId, modelName, modelId });
+
+    if (!models[modelName]) {
+      this.logger.info('[media] model name not found.', { tenantId, modelName, modelId });
+      throw new ServiceError(ERRORS.MODEL_NAME_HAS_NO_MEDIA);
+    }
+    if (!models[modelName].media) {
+      this.logger.info('[media] model is not media-able.', { tenantId, modelName, modelId });
+      throw new ServiceError(ERRORS.MODEL_NAME_HAS_NO_MEDIA);
+    }
+
+    const foundModel = await models[modelName].query().findById(modelId);
+
+    if (!foundModel) {
+      this.logger.info('[media] model is not found.', { tenantId, modelName, modelId });
+      throw new ServiceError(ERRORS.MODEL_ID_NOT_FOUND);
+    }
+  }
+
+  /**
+   * Validates the media existance.
+   * @param {number} tenantId 
+   * @param {number} mediaId 
+   * @param {number} modelId 
+   * @param {string} modelName 
+   */
+  async validateMediaLinkExistance(
+    tenantId: number,
+    mediaId: number,
+    modelId: number,
+    modelName: string
+  ) {
+    const { MediaLink } = this.tenancy.models(tenantId);
+
+    const foundMediaLinks = await MediaLink.query()
+      .where('media_id', mediaId)
+      .where('model_id', modelId)
+      .where('model_name', modelName);
+    
+    if (foundMediaLinks.length > 0) {
+      throw new ServiceError(ERRORS.MEDIA_LINK_EXISTS);
+    }
+  }
+
+  /**
+   * Links the given media to the specific media-able model resource.
+   * @param {number} tenantId 
+   * @param {number} mediaId 
+   * @param {number} modelId 
+   * @param {string} modelType 
+   */
+  async linkMedia(tenantId: number, mediaId: number, modelId: number, modelName: string) {
+    this.logger.info('[media] trying to link media.', { tenantId, mediaId, modelId, modelName });
+    const { MediaLink } = this.tenancy.models(tenantId);
+    await this.validateMediaLinkExistance(tenantId, mediaId, modelId, modelName);
+
+    const media = await this.getMediaOrThrowError(tenantId, mediaId);
+    await this.validateModelNameAndIdExistance(tenantId, modelName, modelId);
+
+    await MediaLink.query().insert({ mediaId, modelId, modelName });
+  }
+
+  /**
+   * Retrieve media metadata.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} mediaId - Media id.
+   * @return {Promise<IMedia>}
+   */
+  public async getMedia(tenantId: number, mediaId: number): Promise<IMedia> {
+    this.logger.info('[media] try to get media.', { tenantId, mediaId });
+    return this.getMediaOrThrowError(tenantId, mediaId);
+  }
+
+  /**
+   * Deletes the given media.
+   * @param {number} tenantId 
+   * @param {number} mediaId 
+   * @return {Promise<void>}
+   */
+  public async deleteMedia(tenantId: number, mediaId: number|number[]): Promise<void> {
+    const { Media, MediaLink } = this.tenancy.models(tenantId);
+    const { tenantRepository } = this.sysRepositories;
+
+    this.logger.info('[media] trying to delete media.', { tenantId, mediaId });
+
+    const mediaIds = Array.isArray(mediaId) ? mediaId : [mediaId];
+
+    const tenant = await tenantRepository.findOneById(tenantId);
+    const media = await this.getMediaByIdsOrThrowError(tenantId, mediaIds);
+
+    const tenantPath = `${publicPath}${tenant.organizationId}`;
+    const unlinkOpers = [];
+
+    media.forEach((mediaModel) => {
+      const oper = fsPromises.unlink(`${tenantPath}/${mediaModel.attachmentFile}`);
+      unlinkOpers.push(oper);
+    });
+    await Promise.all(unlinkOpers)
+      .then((resolved) => {
+        resolved.forEach(() => {
+          this.logger.info('[attachment] file has been deleted.');
+        }); 
+      })
+      .catch((errors) => {  
+        this.logger.info('[attachment] Delete item attachment file delete failed.', { errors });
+      });
+    await MediaLink.query().whereIn('media_id', mediaIds).delete();
+    await Media.query().whereIn('id', mediaIds).delete();
+  }
+
+  /**
+   * Uploads the given attachment.
+   * @param {number} tenantId - 
+   * @param {any} attachment - 
+   * @return {Promise<IMedia>}
+   */
+  public async upload(tenantId: number, attachment: any, modelName?: string, modelId?: number): Promise<IMedia> {
+    const { tenantRepository } = this.sysRepositories;
+    const { Media } = this.tenancy.models(tenantId);
+
+    this.logger.info('[media] trying to upload media.', { tenantId });
+
+    const tenant = await tenantRepository.findOneById(tenantId);
+    const fileName = `${attachment.md5}.png`;
+
+    // Validate the attachment.
+    if (attachment && attachmentsMimes.indexOf(attachment.mimetype) === -1) {
+      throw new ServiceError(ERRORS.MINETYPE_NOT_SUPPORTED);
+    }
+    if (modelName && modelId) {
+      await this.validateModelNameAndIdExistance(tenantId, modelName, modelId);
+    }
+    try {
+      await attachment.mv(`${publicPath}${tenant.organizationId}/${fileName}`);
+      this.logger.info('[attachment] uploaded successfully');
+    } catch (error) {
+      this.logger.info('[attachment] uploading failed.', { error });
+    }
+    const media = await Media.query().insertGraph({
+      attachmentFile: `${fileName}`,
+      ...(modelName && modelId) ? {
+        links: [{
+          modelName,
+          modelId,  
+        }]
+      } : {},
+    });
+    this.logger.info('[media] uploaded successfully.', { tenantId, fileName, modelName, modelId });
+    return media;
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Miscellaneous/DateFormats/constants.ts b/packages/server/src/services/Miscellaneous/DateFormats/constants.ts
new file mode 100644
index 000000000..5ae4630c9
--- /dev/null
+++ b/packages/server/src/services/Miscellaneous/DateFormats/constants.ts
@@ -0,0 +1,11 @@
+export const DATE_FORMATS = [
+  'MM/DD/YY',
+  'DD/MM/YY',
+  'YY/MM/DD',
+  'MM/DD/yyyy',
+  'DD/MM/yyyy',
+  'yyyy/MM/DD',
+  'DD MMM YYYY',
+  'DD MMMM YYYY',
+  'MMMM DD, YYYY',
+];
diff --git a/packages/server/src/services/Miscellaneous/DateFormats/index.ts b/packages/server/src/services/Miscellaneous/DateFormats/index.ts
new file mode 100644
index 000000000..2a5bef6d3
--- /dev/null
+++ b/packages/server/src/services/Miscellaneous/DateFormats/index.ts
@@ -0,0 +1,15 @@
+import moment from 'moment-timezone';
+import { Service } from 'typedi';
+import { DATE_FORMATS } from './constants';
+
+@Service()
+export default class DateFormatsService {
+  getDateFormats() {
+    return DATE_FORMATS.map((dateFormat) => {
+      return {
+        label: `${moment().format(dateFormat)} [${dateFormat}]`,
+        key: dateFormat,
+      };
+    });
+  }
+}
diff --git a/packages/server/src/services/Miscellaneous/MiscService.ts b/packages/server/src/services/Miscellaneous/MiscService.ts
new file mode 100644
index 000000000..e24a3b3d3
--- /dev/null
+++ b/packages/server/src/services/Miscellaneous/MiscService.ts
@@ -0,0 +1,8 @@
+import { Service } from 'typedi';
+
+@Service()
+export default class MiscService {
+  getDateFormats() {
+    return [];
+  }
+}
diff --git a/packages/server/src/services/Organization/OrganizationBaseCurrencyLocking.ts b/packages/server/src/services/Organization/OrganizationBaseCurrencyLocking.ts
new file mode 100644
index 000000000..ad3fd2783
--- /dev/null
+++ b/packages/server/src/services/Organization/OrganizationBaseCurrencyLocking.ts
@@ -0,0 +1,84 @@
+import { isEmpty } from 'lodash';
+import { Inject, Service } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { TimeoutSettings } from 'puppeteer';
+
+interface MutateBaseCurrencyLockMeta {
+  modelName: string;
+  pluralName?: string;
+}
+
+@Service()
+export default class OrganizationBaseCurrencyLocking {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieves the tenant models that have prevented mutation base currency.
+   */
+  private getModelsPreventsMutate = (tenantId: number) => {
+    const Models = this.tenancy.models(tenantId);
+
+    const filteredEntries = Object.entries(Models).filter(
+      ([key, Model]) => !!Model.preventMutateBaseCurrency
+    );
+    return Object.fromEntries(filteredEntries);
+  };
+
+  /**
+   * Detarmines the mutation base currency model is locked.
+   * @param   {Model} Model
+   * @returns {Promise<MutateBaseCurrencyLockMeta | false>}
+   */
+  private isModelMutateLocked = async (
+    Model
+  ): Promise<MutateBaseCurrencyLockMeta | false> => {
+    const validateQuery = Model.query();
+
+    if (typeof Model?.modifiers?.preventMutateBaseCurrency !== 'undefined') {
+      validateQuery.modify('preventMutateBaseCurrency');
+    } else {
+      validateQuery.select(['id']).first();
+    }
+    const validateResult = await validateQuery;
+    const isValid = !isEmpty(validateResult);
+
+    return isValid
+      ? {
+          modelName: Model.name,
+          pluralName: Model.pluralName,
+        }
+      : false;
+  };
+
+  /**
+   * Retrieves the base currency mutation locks of the tenant models.
+   * @param   {number} tenantId
+   * @returns {Promise<MutateBaseCurrencyLockMeta[]>}
+   */
+  public async baseCurrencyMutateLocks(
+    tenantId: number
+  ): Promise<MutateBaseCurrencyLockMeta[]> {
+    const PreventedModels = this.getModelsPreventsMutate(tenantId);
+
+    const opers = Object.entries(PreventedModels).map(([ModelName, Model]) =>
+      this.isModelMutateLocked(Model)
+    );
+    const results = await Promise.all(opers);
+
+    return results.filter(
+      (result) => result !== false
+    ) as MutateBaseCurrencyLockMeta[];
+  }
+
+  /**
+   * Detarmines the base currency mutation locked.
+   * @param   {number} tenantId
+   * @returns {Promise<boolean>}
+   */
+  public isBaseCurrencyMutateLocked = async (tenantId: number) => {
+    const locks = await this.baseCurrencyMutateLocks(tenantId);
+
+    return !isEmpty(locks);
+  };
+}
diff --git a/packages/server/src/services/Organization/OrganizationService.ts b/packages/server/src/services/Organization/OrganizationService.ts
new file mode 100644
index 000000000..b4886b4af
--- /dev/null
+++ b/packages/server/src/services/Organization/OrganizationService.ts
@@ -0,0 +1,330 @@
+import { Service, Inject } from 'typedi';
+import { ObjectId } from 'mongodb';
+import { defaultTo, pick } from 'lodash';
+import { ServiceError } from '@/exceptions';
+import {
+  IOrganizationBuildDTO,
+  IOrganizationBuildEventPayload,
+  IOrganizationUpdateDTO,
+  ISystemUser,
+  ITenant,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+import config from '../../config';
+import TenantsManager from '@/services/Tenancy/TenantsManager';
+import { Tenant } from '@/system/models';
+import OrganizationBaseCurrencyLocking from './OrganizationBaseCurrencyLocking';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ERRORS } from './constants';
+
+@Service()
+export default class OrganizationService {
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject('repositories')
+  sysRepositories: any;
+
+  @Inject()
+  tenantsManager: TenantsManager;
+
+  @Inject('agenda')
+  agenda: any;
+
+  @Inject()
+  baseCurrencyMutateLocking: OrganizationBaseCurrencyLocking;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Builds the database schema and seed data of the given organization id.
+   * @param  {srting} organizationId
+   * @return {Promise<void>}
+   */
+  public async build(
+    tenantId: number,
+    buildDTO: IOrganizationBuildDTO,
+    systemUser: ISystemUser
+  ): Promise<void> {
+    const tenant = await this.getTenantOrThrowError(tenantId);
+
+    // Throw error if the tenant is already initialized.
+    this.throwIfTenantInitizalized(tenant);
+
+    // Drop the database if is already exists.
+    await this.tenantsManager.dropDatabaseIfExists(tenant);
+
+    // Creates a new database.
+    await this.tenantsManager.createDatabase(tenant);
+
+    // Migrate the tenant.
+    await this.tenantsManager.migrateTenant(tenant);
+
+    // Migrated tenant.
+    const migratedTenant = await tenant.$query().withGraphFetched('metadata');
+
+    // Creates a tenancy object from given tenant model.
+    const tenancyContext =
+      this.tenantsManager.getSeedMigrationContext(migratedTenant);
+
+    // Seed tenant.
+    await this.tenantsManager.seedTenant(migratedTenant, tenancyContext);
+
+    // Throws `onOrganizationBuild` event.
+    await this.eventPublisher.emitAsync(events.organization.build, {
+      tenantId: tenant.id,
+      buildDTO,
+      systemUser,
+    } as IOrganizationBuildEventPayload);
+
+    // Markes the tenant as completed builing.
+    await Tenant.markAsBuilt(tenantId);
+    await Tenant.markAsBuildCompleted(tenantId);
+
+    //
+    await this.flagTenantDBBatch(tenantId);
+  }
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {IOrganizationBuildDTO} buildDTO
+   * @returns
+   */
+  async buildRunJob(
+    tenantId: number,
+    buildDTO: IOrganizationBuildDTO,
+    authorizedUser: ISystemUser
+  ) {
+    const tenant = await this.getTenantOrThrowError(tenantId);
+
+    // Throw error if the tenant is already initialized.
+    this.throwIfTenantInitizalized(tenant);
+
+    // Throw error if tenant is currently building.
+    this.throwIfTenantIsBuilding(tenant);
+
+    // Transformes build DTO object.
+    const transformedBuildDTO = this.transformBuildDTO(buildDTO);
+
+    // Saves the tenant metadata.
+    await tenant.saveMetadata(transformedBuildDTO);
+
+    // Send welcome mail to the user.
+    const jobMeta = await this.agenda.now('organization-setup', {
+      tenantId,
+      buildDTO,
+      authorizedUser,
+    });
+    // Transformes the mangodb id to string.
+    const jobId = new ObjectId(jobMeta.attrs._id).toString();
+
+    // Markes the tenant as currently building.
+    await Tenant.markAsBuilding(tenantId, jobId);
+
+    return {
+      nextRunAt: jobMeta.attrs.nextRunAt,
+      jobId: jobMeta.attrs._id,
+    };
+  }
+
+  /**
+   * Unlocks tenant build run job.
+   * @param {number} tenantId
+   * @param {number} jobId
+   */
+  public async revertBuildRunJob(tenantId: number, jobId: string) {
+    await Tenant.markAsBuildCompleted(tenantId, jobId);
+  }
+
+  /**
+   * Retrieve the current organization metadata.
+   * @param {number} tenantId
+   * @returns {Promise<ITenant[]>}
+   */
+  public async currentOrganization(tenantId: number): Promise<ITenant> {
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('subscriptions')
+      .withGraphFetched('metadata');
+
+    this.throwIfTenantNotExists(tenant);
+
+    return tenant;
+  }
+
+  /**
+   * Retrieve organization ability of mutate base currency
+   * @param {number} tenantId
+   * @returns
+   */
+  public mutateBaseCurrencyAbility(tenantId: number) {
+    return this.baseCurrencyMutateLocking.baseCurrencyMutateLocks(tenantId);
+  }
+
+  /**
+   * Updates organization information.
+   * @param {ITenant} tenantId
+   * @param {IOrganizationUpdateDTO} organizationDTO
+   */
+  public async updateOrganization(
+    tenantId: number,
+    organizationDTO: IOrganizationUpdateDTO
+  ): Promise<void> {
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    // Throw error if the tenant not exists.
+    this.throwIfTenantNotExists(tenant);
+
+    // Validate organization transactions before mutate base currency.
+    await this.validateMutateBaseCurrency(
+      tenant,
+      organizationDTO.baseCurrency,
+      tenant.metadata?.baseCurrency
+    );
+    await tenant.saveMetadata(organizationDTO);
+
+    if (organizationDTO.baseCurrency !== tenant.metadata?.baseCurrency) {
+      // Triggers `onOrganizationBaseCurrencyUpdated` event.
+      await this.eventPublisher.emitAsync(
+        events.organization.baseCurrencyUpdated,
+        {
+          tenantId,
+          organizationDTO,
+        }
+      );
+    }
+  }
+
+  /**
+   * Transformes build DTO object.
+   * @param {IOrganizationBuildDTO} buildDTO
+   * @returns {IOrganizationBuildDTO}
+   */
+  private transformBuildDTO(
+    buildDTO: IOrganizationBuildDTO
+  ): IOrganizationBuildDTO {
+    return {
+      ...buildDTO,
+      dateFormat: defaultTo(buildDTO.dateFormat, 'DD/MM/yyyy'),
+    };
+  }
+
+  /**
+   * Throw base currency mutate locked error.
+   */
+  private throwBaseCurrencyMutateLocked() {
+    throw new ServiceError(ERRORS.BASE_CURRENCY_MUTATE_LOCKED);
+  }
+
+  /**
+   * Validate mutate base currency ability.
+   * @param {Tenant} tenant -
+   * @param {string} newBaseCurrency -
+   * @param {string} oldBaseCurrency -
+   */
+  private async validateMutateBaseCurrency(
+    tenant: Tenant,
+    newBaseCurrency: string,
+    oldBaseCurrency: string
+  ) {
+    if (tenant.isReady && newBaseCurrency !== oldBaseCurrency) {
+      const isLocked =
+        await this.baseCurrencyMutateLocking.isBaseCurrencyMutateLocked(
+          tenant.id
+        );
+
+      if (isLocked) {
+        this.throwBaseCurrencyMutateLocked();
+      }
+    }
+  }
+
+  /**
+   * Throws error in case the given tenant is undefined.
+   * @param {ITenant} tenant
+   */
+  private throwIfTenantNotExists(tenant: ITenant) {
+    if (!tenant) {
+      throw new ServiceError(ERRORS.TENANT_NOT_FOUND);
+    }
+  }
+
+  /**
+   * Throws error in case the given tenant is already initialized.
+   * @param {ITenant} tenant
+   */
+  private throwIfTenantInitizalized(tenant: ITenant) {
+    if (tenant.builtAt) {
+      throw new ServiceError(ERRORS.TENANT_ALREADY_BUILT);
+    }
+  }
+
+  /**
+   * Throw error if the tenant is building.
+   * @param {ITenant} tenant
+   */
+  private throwIfTenantIsBuilding(tenant) {
+    if (tenant.buildJobId) {
+      throw new ServiceError(ERRORS.TENANT_IS_BUILDING);
+    }
+  }
+
+  /**
+   * Retrieve tenant of throw not found error.
+   * @param {number} tenantId -
+   */
+  async getTenantOrThrowError(tenantId: number): Promise<ITenant> {
+    const tenant = await Tenant.query().findById(tenantId);
+
+    if (!tenant) {
+      throw new ServiceError(ERRORS.TENANT_NOT_FOUND);
+    }
+    return tenant;
+  }
+
+  /**
+   * Adds organization database latest batch number.
+   * @param {number} tenantId
+   * @param {number} version
+   */
+  public async flagTenantDBBatch(tenantId: number) {
+    await Tenant.query()
+      .update({
+        databaseBatch: config.databaseBatch,
+      })
+      .where({ id: tenantId });
+  }
+
+  /**
+   * Syncs system user to tenant user.
+   */
+  public async syncSystemUserToTenant(
+    tenantId: number,
+    systemUser: ISystemUser
+  ) {
+    const { User, Role } = this.tenancy.models(tenantId);
+
+    const adminRole = await Role.query().findOne('slug', 'admin');
+
+    await User.query().insert({
+      ...pick(systemUser, [
+        'firstName',
+        'lastName',
+        'phoneNumber',
+        'email',
+        'active',
+        'inviteAcceptedAt',
+      ]),
+      systemUserId: systemUser.id,
+      roleId: adminRole.id,
+    });
+  }
+}
diff --git a/packages/server/src/services/Organization/OrganizationUpgrade.ts b/packages/server/src/services/Organization/OrganizationUpgrade.ts
new file mode 100644
index 000000000..f8b6f7b57
--- /dev/null
+++ b/packages/server/src/services/Organization/OrganizationUpgrade.ts
@@ -0,0 +1,105 @@
+import { Inject, Service } from 'typedi';
+import { ObjectId } from 'mongodb';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { SeedMigration } from '@/lib/Seeder/SeedMigration';
+import { Tenant } from '@/system/models';
+import { ServiceError } from '@/exceptions';
+import TenantDBManager from '@/services/Tenancy/TenantDBManager';
+import config from '../../config';
+import { ERRORS } from './constants';
+import OrganizationService from './OrganizationService';
+import TenantsManagerService from '@/services/Tenancy/TenantsManager';
+
+@Service()
+export default class OrganizationUpgrade {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  organizationService: OrganizationService;
+
+  @Inject()
+  tenantsManager: TenantsManagerService;
+
+  @Inject('agenda')
+  agenda: any;
+
+  /**
+   * Upgrades the given organization database.
+   * @param {number} tenantId - Tenant id.
+   * @returns {Promise<void>}
+   */
+  public upgradeJob = async (tenantId: number): Promise<void> => {
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    // Validate tenant version.
+    this.validateTenantVersion(tenant);
+
+    // Initialize the tenant.
+    const seedContext = this.tenantsManager.getSeedMigrationContext(tenant);
+
+    // Database manager.
+    const dbManager = new TenantDBManager();
+
+    // Migrate the organization database schema.
+    await dbManager.migrate(tenant);
+
+    // Seeds the organization database data.
+    await new SeedMigration(seedContext.knex, seedContext).latest();
+
+    // Update the organization database version.
+    await this.organizationService.flagTenantDBBatch(tenantId);
+
+    // Remove the tenant job id.
+    await Tenant.markAsUpgraded(tenantId);
+  };
+
+  /**
+   * Running organization upgrade job.
+   * @param {number} tenantId - Tenant id.
+   * @return {Promise<void>}
+   */
+  public upgrade = async (tenantId: number): Promise<{ jobId: string }> => {
+    const tenant = await Tenant.query().findById(tenantId);
+
+    // Validate tenant version.
+    this.validateTenantVersion(tenant);
+
+    // Validate tenant upgrade is not running.
+    this.validateTenantUpgradeNotRunning(tenant);
+
+    // Send welcome mail to the user.
+    const jobMeta = await this.agenda.now('organization-upgrade', {
+      tenantId,
+    });
+    // Transformes the mangodb id to string.
+    const jobId = new ObjectId(jobMeta.attrs._id).toString();
+
+    // Markes the tenant as currently building.
+    await Tenant.markAsUpgrading(tenantId, jobId);
+
+    return { jobId };
+  };
+
+  /**
+   * Validates the given tenant version.
+   * @param {ITenant} tenant
+   */
+  private validateTenantVersion(tenant) {
+    if (tenant.databaseBatch >= config.databaseBatch) {
+      throw new ServiceError(ERRORS.TENANT_DATABASE_UPGRADED);
+    }
+  }
+
+  /**
+   * Validates the given tenant upgrade is not running.
+   * @param tenant
+   */
+  private validateTenantUpgradeNotRunning(tenant) {
+    if (tenant.isUpgradeRunning) {
+      throw new ServiceError(ERRORS.TENANT_UPGRADE_IS_RUNNING);
+    }
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Organization/constants.ts b/packages/server/src/services/Organization/constants.ts
new file mode 100644
index 000000000..46380409c
--- /dev/null
+++ b/packages/server/src/services/Organization/constants.ts
@@ -0,0 +1,45 @@
+import currencies from 'js-money/lib/currency';
+
+export const DATE_FORMATS = [
+  'MM.dd.yy',
+  'dd.MM.yy',
+  'yy.MM.dd',
+  'MM.dd.yyyy',
+  'dd.MM.yyyy',
+  'yyyy.MM.dd',
+  'MM/DD/YYYY',
+  'M/D/YYYY',
+  'dd MMM YYYY',
+  'dd MMMM YYYY',
+  'MMMM dd, YYYY',
+  'EEE, MMMM dd, YYYY',
+];
+export const ACCEPTED_CURRENCIES = Object.keys(currencies);
+
+export const MONTHS = [
+  'january',
+  'february',
+  'march',
+  'april',
+  'may',
+  'june',
+  'july',
+  'august',
+  'september',
+  'october',
+  'november',
+  'december',
+];
+
+export const ACCEPTED_LOCALES = ['en', 'ar'];
+
+export const ERRORS = {
+  TENANT_DATABASE_UPGRADED: 'TENANT_DATABASE_UPGRADED',
+  TENANT_NOT_FOUND: 'tenant_not_found',
+  TENANT_ALREADY_BUILT: 'TENANT_ALREADY_BUILT',
+  TENANT_ALREADY_SEEDED: 'tenant_already_seeded',
+  TENANT_DB_NOT_BUILT: 'tenant_db_not_built',
+  TENANT_IS_BUILDING: 'TENANT_IS_BUILDING',
+  BASE_CURRENCY_MUTATE_LOCKED: 'BASE_CURRENCY_MUTATE_LOCKED',
+  TENANT_UPGRADE_IS_RUNNING: 'TENANT_UPGRADE_IS_RUNNING'
+};
diff --git a/packages/server/src/services/PDF/PdfService.ts b/packages/server/src/services/PDF/PdfService.ts
new file mode 100644
index 000000000..10eb5e8b1
--- /dev/null
+++ b/packages/server/src/services/PDF/PdfService.ts
@@ -0,0 +1,26 @@
+import { Service } from 'typedi';
+import puppeteer from 'puppeteer';
+import config from '@/config';
+
+@Service()
+export default class PdfService {
+
+  /**
+   * Pdf document.
+   * @param content 
+   * @returns 
+   */
+  async pdfDocument(content: string) {
+    const browser = await puppeteer.connect({
+      browserWSEndpoint: config.puppeteer.browserWSEndpoint,
+    });
+    const page = await browser.newPage();
+    await page.setContent(content);
+
+    const pdf = await page.pdf({ format: 'a4' });
+
+    await browser.close();
+
+    return pdf;
+  }
+}
diff --git a/packages/server/src/services/Payment/License.ts b/packages/server/src/services/Payment/License.ts
new file mode 100644
index 000000000..8e0fbc675
--- /dev/null
+++ b/packages/server/src/services/Payment/License.ts
@@ -0,0 +1,185 @@
+import { Service, Container, Inject } from 'typedi';
+import cryptoRandomString from 'crypto-random-string';
+import { times } from 'lodash';
+import { License, Plan } from '@/system/models';
+import { ILicense, ISendLicenseDTO } from '@/interfaces';
+import LicenseMailMessages from '@/services/Payment/LicenseMailMessages';
+import LicenseSMSMessages from '@/services/Payment/LicenseSMSMessages';
+import { ServiceError } from '@/exceptions';
+
+const ERRORS = {
+  PLAN_NOT_FOUND: 'PLAN_NOT_FOUND',
+  LICENSE_NOT_FOUND: 'LICENSE_NOT_FOUND',
+  LICENSE_ALREADY_DISABLED: 'LICENSE_ALREADY_DISABLED',
+  NO_AVALIABLE_LICENSE_CODE: 'NO_AVALIABLE_LICENSE_CODE',
+};
+
+@Service()
+export default class LicenseService {
+  @Inject()
+  smsMessages: LicenseSMSMessages;
+
+  @Inject()
+  mailMessages: LicenseMailMessages;
+
+  /**
+   * Validate the plan existance on the storage.
+   * @param {number} tenantId -
+   * @param {string} planSlug - Plan slug.
+   */
+  private async getPlanOrThrowError(planSlug: string) {
+    const foundPlan = await Plan.query().where('slug', planSlug).first();
+
+    if (!foundPlan) {
+      throw new ServiceError(ERRORS.PLAN_NOT_FOUND);
+    }
+    return foundPlan;
+  }
+
+  /**
+   * Valdiate the license existance on the storage.
+   * @param {number} licenseId - License id.
+   */
+  private async getLicenseOrThrowError(licenseId: number) {
+    const foundLicense = await License.query().findById(licenseId);
+
+    if (!foundLicense) {
+      throw new ServiceError(ERRORS.LICENSE_NOT_FOUND);
+    }
+    return foundLicense;
+  }
+
+  /**
+   * Validates whether the license id is disabled.
+   * @param {ILicense} license
+   */
+  private validateNotDisabledLicense(license: ILicense) {
+    if (license.disabledAt) {
+      throw new ServiceError(ERRORS.LICENSE_ALREADY_DISABLED);
+    }
+  }
+
+  /**
+   * Generates the license code in the given period.
+   * @param  {number} licensePeriod
+   * @return {Promise<ILicense>}
+   */
+  public async generateLicense(
+    licensePeriod: number,
+    periodInterval: string = 'days',
+    planSlug: string
+  ): ILicense {
+    let licenseCode: string;
+    let repeat: boolean = true;
+
+    // Retrieve plan or throw not found error.
+    const plan = await this.getPlanOrThrowError(planSlug);
+
+    while (repeat) {
+      licenseCode = cryptoRandomString({ length: 10, type: 'numeric' });
+      const foundLicenses = await License.query().where(
+        'license_code',
+        licenseCode
+      );
+
+      if (foundLicenses.length === 0) {
+        repeat = false;
+      }
+    }
+    return License.query().insert({
+      licenseCode,
+      licensePeriod,
+      periodInterval,
+      planId: plan.id,
+    });
+  }
+
+  /**
+   * Generates licenses.
+   * @param {number} loop
+   * @param {number} licensePeriod
+   * @param {string} periodInterval
+   * @param {number} planId
+   */
+  public async generateLicenses(
+    loop = 1,
+    licensePeriod: number,
+    periodInterval: string = 'days',
+    planSlug: string
+  ) {
+    const asyncOpers: Promise<any>[] = [];
+
+    times(loop, () => {
+      const generateOper = this.generateLicense(
+        licensePeriod,
+        periodInterval,
+        planSlug
+      );
+      asyncOpers.push(generateOper);
+    });
+    return Promise.all(asyncOpers);
+  }
+
+  /**
+   * Disables the given license id on the storage.
+   * @param  {string} licenseSlug - License slug.
+   * @return {Promise}
+   */
+  public async disableLicense(licenseId: number) {
+    const license = await this.getLicenseOrThrowError(licenseId);
+
+    this.validateNotDisabledLicense(license);
+
+    return License.markLicenseAsDisabled(license.id, 'id');
+  }
+
+  /**
+   * Deletes the given license id from the storage.
+   * @param licenseSlug {string} - License slug.
+   */
+  public async deleteLicense(licenseSlug: string) {
+    const license = await this.getPlanOrThrowError(licenseSlug);
+
+    return License.query().where('id', license.id).delete();
+  }
+
+  /**
+   * Sends license code to the given customer via SMS or mail message.
+   * @param {string} licenseCode - License code.
+   * @param {string} phoneNumber - Phone number.
+   * @param {string} email - Email address.
+   */
+  public async sendLicenseToCustomer(sendLicense: ISendLicenseDTO) {
+    const agenda = Container.get('agenda');
+    const { phoneNumber, email, period, periodInterval } = sendLicense;
+
+    // Retreive plan details byt the given plan slug.
+    const plan = await this.getPlanOrThrowError(sendLicense.planSlug);
+
+    const license = await License.query()
+      .modify('filterActiveLicense')
+      .where('license_period', period)
+      .where('period_interval', periodInterval)
+      .where('plan_id', plan.id)
+      .first();
+
+    if (!license) {
+      throw new ServiceError(ERRORS.NO_AVALIABLE_LICENSE_CODE)
+    }
+    // Mark the license as used.
+    await License.markLicenseAsSent(license.licenseCode);
+
+    if (sendLicense.email) {
+      await agenda.schedule('1 second', 'send-license-via-email', {
+        licenseCode: license.licenseCode,
+        email,
+      });
+    }
+    if (phoneNumber) {
+      await agenda.schedule('1 second', 'send-license-via-phone', {
+        licenseCode: license.licenseCode,
+        phoneNumber,
+      });
+    }
+  }
+}
diff --git a/packages/server/src/services/Payment/LicenseMailMessages.ts b/packages/server/src/services/Payment/LicenseMailMessages.ts
new file mode 100644
index 000000000..a9b144629
--- /dev/null
+++ b/packages/server/src/services/Payment/LicenseMailMessages.ts
@@ -0,0 +1,26 @@
+import { Container } from 'typedi';
+import Mail from '@/lib/Mail';
+import config from '@/config';
+export default class SubscriptionMailMessages {
+  /**
+   * Send license code to the given mail address.
+   * @param {string} licenseCode 
+   * @param {email} email 
+   */
+  public async sendMailLicense(licenseCode: string, email: string) {
+    const Logger = Container.get('logger');
+    
+    const mail = new Mail()
+      .setView('mail/LicenseReceive.html')
+      .setSubject('Bigcapital - License code')
+      .setTo(email)
+      .setData({
+        licenseCode,
+        successEmail: config.customerSuccess.email,
+        successPhoneNumber: config.customerSuccess.phoneNumber,
+      });
+    
+    await mail.send();
+    Logger.info('[license_mail] sent successfully.');
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Payment/LicensePaymentMethod.ts b/packages/server/src/services/Payment/LicensePaymentMethod.ts
new file mode 100644
index 000000000..a8dbdf4ec
--- /dev/null
+++ b/packages/server/src/services/Payment/LicensePaymentMethod.ts
@@ -0,0 +1,67 @@
+import { License } from '@/system/models';
+import PaymentMethod from '@/services/Payment/PaymentMethod';
+import { Plan } from '@/system/models';
+import { IPaymentMethod, ILicensePaymentModel } from '@/interfaces';
+import {
+  PaymentInputInvalid,
+  PaymentAmountInvalidWithPlan,
+  VoucherCodeRequired,
+} from '@/exceptions';
+
+export default class LicensePaymentMethod
+  extends PaymentMethod
+  implements IPaymentMethod
+{
+  /**
+   * Payment subscription of organization via license code.
+   * @param {ILicensePaymentModel} licensePaymentModel -
+   */
+  public async payment(licensePaymentModel: ILicensePaymentModel, plan: Plan) {
+    this.validateLicensePaymentModel(licensePaymentModel);
+
+    const license = await this.getLicenseOrThrowInvalid(licensePaymentModel);
+    this.validatePaymentAmountWithPlan(license, plan);
+
+    // Mark the license code as used.
+    return License.markLicenseAsUsed(licensePaymentModel.licenseCode);
+  }
+
+  /**
+   * Validates the license code activation on the storage.
+   * @param {ILicensePaymentModel} licensePaymentModel -
+   */
+  private async getLicenseOrThrowInvalid(
+    licensePaymentModel: ILicensePaymentModel
+  ) {
+    const foundLicense = await License.query()
+      .modify('filterActiveLicense')
+      .where('license_code', licensePaymentModel.licenseCode)
+      .first();
+
+    if (!foundLicense) {
+      throw new PaymentInputInvalid();
+    }
+    return foundLicense;
+  }
+
+  /**
+   * Validates the payment amount with given plan price.
+   * @param {License} license
+   * @param {Plan} plan
+   */
+  private validatePaymentAmountWithPlan(license: License, plan: Plan) {
+    if (license.planId !== plan.id) {
+      throw new PaymentAmountInvalidWithPlan();
+    }
+  }
+
+  /**
+   * Validate voucher payload.
+   * @param {ILicensePaymentModel} licenseModel -
+   */
+  private validateLicensePaymentModel(licenseModel: ILicensePaymentModel) {
+    if (!licenseModel || !licenseModel.licenseCode) {
+      throw new VoucherCodeRequired();
+    }
+  }
+}
diff --git a/packages/server/src/services/Payment/LicenseSMSMessages.ts b/packages/server/src/services/Payment/LicenseSMSMessages.ts
new file mode 100644
index 000000000..aa884ccdf
--- /dev/null
+++ b/packages/server/src/services/Payment/LicenseSMSMessages.ts
@@ -0,0 +1,17 @@
+import { Container, Inject } from 'typedi';
+import SMSClient from '@/services/SMSClient';
+
+export default class SubscriptionSMSMessages {
+  @Inject('SMSClient')
+  smsClient: SMSClient;
+
+  /**
+   * Sends license code to the given phone number via SMS message.
+   * @param {string} phoneNumber 
+   * @param {string} licenseCode 
+   */
+  public async sendLicenseSMSMessage(phoneNumber: string, licenseCode: string) {
+    const message: string = `Your license card number: ${licenseCode}. If you need any help please contact us. Bigcapital.`;
+    return this.smsClient.sendMessage(phoneNumber, message);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Payment/PaymentMethod.ts b/packages/server/src/services/Payment/PaymentMethod.ts
new file mode 100644
index 000000000..a0c1072f0
--- /dev/null
+++ b/packages/server/src/services/Payment/PaymentMethod.ts
@@ -0,0 +1,6 @@
+import moment from 'moment';
+import { IPaymentModel } from '@/interfaces';
+
+export default class PaymentMethod implements IPaymentModel {
+
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Payment/index.ts b/packages/server/src/services/Payment/index.ts
new file mode 100644
index 000000000..bec52feaf
--- /dev/null
+++ b/packages/server/src/services/Payment/index.ts
@@ -0,0 +1,22 @@
+import { IPaymentMethod, IPaymentContext } from "interfaces";
+import { Plan } from '@/system/models';
+
+export default class PaymentContext<PaymentModel> implements IPaymentContext{
+  paymentMethod: IPaymentMethod;
+
+  /**
+   * Constructor method. 
+   * @param {IPaymentMethod} paymentMethod 
+   */
+  constructor(paymentMethod: IPaymentMethod) {
+    this.paymentMethod = paymentMethod;
+  }
+
+  /**
+   * 
+   * @param {<PaymentModel>} paymentModel 
+   */
+  makePayment(paymentModel: PaymentModel, plan: Plan) {
+    return this.paymentMethod.payment(paymentModel, plan);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Projects/Projects/CreateProject.ts b/packages/server/src/services/Projects/Projects/CreateProject.ts
new file mode 100644
index 000000000..5199524cf
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/CreateProject.ts
@@ -0,0 +1,74 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import {
+  IProjectCreatedEventPayload,
+  IProjectCreateDTO,
+  IProjectCreatePOJO,
+  IProjectCreatingEventPayload,
+  IProjectStatus,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import { ProjectsValidator } from './ProjectsValidator';
+import events from '@/subscribers/events';
+
+@Service()
+export default class CreateProject {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private validator: ProjectsValidator;
+
+  /**
+   * Creates a new credit note.
+   * @param {IProjectCreateDTO} creditNoteDTO
+   */
+  public createProject = async (
+    tenantId: number,
+    projectDTO: IProjectCreateDTO
+  ): Promise<IProjectCreatePOJO> => {
+    const { Project } = this.tenancy.models(tenantId);
+
+    // Validate customer existance.
+    await this.validator.validateContactExists(tenantId, projectDTO.contactId);
+
+    // Triggers `onProjectCreate` event.
+    await this.eventPublisher.emitAsync(events.project.onCreate, {
+      tenantId,
+      projectDTO,
+    } as IProjectCreatedEventPayload);
+
+    // Creates a new project under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onProjectCreating` event.
+      await this.eventPublisher.emitAsync(events.project.onCreating, {
+        tenantId,
+        projectDTO,
+        trx,
+      } as IProjectCreatingEventPayload);
+
+      // Upsert the project object.
+      const project = await Project.query(trx).upsertGraph({
+        ...projectDTO,
+        status: IProjectStatus.InProgress,
+      });
+      // Triggers `onProjectCreated` event.
+      await this.eventPublisher.emitAsync(events.project.onCreated, {
+        tenantId,
+        projectDTO,
+        project,
+        trx,
+      } as IProjectCreatedEventPayload);
+
+      return project;
+    });
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/DeleteProject.ts b/packages/server/src/services/Projects/Projects/DeleteProject.ts
new file mode 100644
index 000000000..193866fcf
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/DeleteProject.ts
@@ -0,0 +1,61 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import {
+  IProjectDeletedEventPayload,
+  IProjectDeleteEventPayload,
+  IProjectDeletingEventPayload,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+
+@Service()
+export default class DeleteProject {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Deletes the give project.
+   * @param {number} projectId -
+   * @returns {Promise<void>}
+   */
+  public deleteProject = async (tenantId: number, projectId: number) => {
+    const { Project } = this.tenancy.models(tenantId);
+
+    // Triggers `onProjectDelete` event.
+    await this.eventPublisher.emitAsync(events.project.onDelete, {
+      tenantId,
+      projectId,
+    } as IProjectDeleteEventPayload);
+
+    // Validate customer existance.
+    const oldProject = await Project.query().findById(projectId).throwIfNotFound();
+
+    // Deletes the given project under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onProjectDeleting` event.
+      await this.eventPublisher.emitAsync(events.project.onDeleting, {
+        tenantId,
+        oldProject,
+        trx,
+      } as IProjectDeletingEventPayload);
+
+      // Deletes the project from the storage.
+      await Project.query(trx).findById(projectId).delete();
+
+      // Triggers `onProjectDeleted` event.
+      await this.eventPublisher.emitAsync(events.project.onDeleted, {
+        tenantId,
+        oldProject,
+        trx,
+      } as IProjectDeletedEventPayload);
+    });
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/EditProject.ts b/packages/server/src/services/Projects/Projects/EditProject.ts
new file mode 100644
index 000000000..0e64f9016
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/EditProject.ts
@@ -0,0 +1,87 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import {
+  IProjectEditDTO,
+  IProjectEditedEventPayload,
+  IProjectEditEventPayload,
+  IProjectEditingEventPayload,
+  IProjectEditPOJO,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+import { ProjectsValidator } from './ProjectsValidator';
+
+@Service()
+export default class EditProjectService {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private projectsValidator: ProjectsValidator;
+
+  /**
+   * Edits a new credit note.
+   * @param {number} tenantId -
+   * @param {number} projectId -
+   * @param {IProjectEditDTO} projectDTO -
+   */
+  public editProject = async (
+    tenantId: number,
+    projectId: number,
+    projectDTO: IProjectEditDTO
+  ): Promise<IProjectEditPOJO> => {
+    const { Project } = this.tenancy.models(tenantId);
+
+    // Validate customer existance.
+    const oldProject = await Project.query().findById(projectId).throwIfNotFound();
+
+    // Validate the project's contact id existance.
+    if (oldProject.contactId !== projectDTO.contactId) {
+      await this.projectsValidator.validateContactExists(
+        tenantId,
+        projectDTO.contactId
+      );
+    }
+    // Triggers `onProjectEdit` event.
+    await this.eventPublisher.emitAsync(events.project.onEdit, {
+      tenantId,
+      oldProject,
+      projectDTO,
+    } as IProjectEditEventPayload);
+
+    // Edits the given project under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onProjectEditing` event.
+      await this.eventPublisher.emitAsync(events.project.onEditing, {
+        tenantId,
+        projectDTO,
+        oldProject,
+        trx,
+      } as IProjectEditingEventPayload);
+
+      // Upsert the project object.
+      const project = await Project.query(trx).upsertGraph({
+        id: projectId,
+        ...projectDTO,
+      });
+      // Triggers `onProjectEdited` event.
+      await this.eventPublisher.emitAsync(events.project.onEdited, {
+        tenantId,
+        oldProject,
+        project,
+        projectDTO,
+        trx,
+      } as IProjectEditedEventPayload);
+
+      return project;
+    });
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/EditProjectStatus.ts b/packages/server/src/services/Projects/Projects/EditProjectStatus.ts
new file mode 100644
index 000000000..3d2826c16
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/EditProjectStatus.ts
@@ -0,0 +1,46 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import { IProjectStatus } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+@Service()
+export default class EditProjectStatusService {
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  /**
+   * Edits a new credit note.
+   * @param {number} projectId -
+   * @param {IProjectStatus} status -
+   */
+  public editProjectStatus = async (
+    tenantId: number,
+    projectId: number,
+    status: IProjectStatus
+  ) => {
+    const { Project } = this.tenancy.models(tenantId);
+
+    // Validate customer existance.
+    const oldProject = await Project.query()
+      .findById(projectId)
+      .throwIfNotFound();
+
+    // Edits the given project under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Upsert the project object.
+      const project = await Project.query(trx).upsertGraph({
+        id: projectId,
+        status,
+      });
+      return project;
+    });
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/GetProject.ts b/packages/server/src/services/Projects/Projects/GetProject.ts
new file mode 100644
index 000000000..b7770b03c
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/GetProject.ts
@@ -0,0 +1,43 @@
+import { IProjectGetPOJO } from '@/interfaces';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+import { ProjectDetailedTransformer } from './ProjectDetailedTransformer';
+
+@Service()
+export default class GetProject {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the project.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @returns {Promise<IProjectGetPOJO>}
+   */
+  public getProject = async (
+    tenantId: number,
+    projectId: number
+  ): Promise<IProjectGetPOJO> => {
+    const { Project } = this.tenancy.models(tenantId);
+
+    // Retrieve the project.
+    const project = await Project.query()
+      .findById(projectId)
+      .withGraphFetched('contact')
+      .modify('totalExpensesDetails')
+      .modify('totalBillsDetails')
+      .modify('totalTasksDetails')
+      .throwIfNotFound();
+
+    // Transformes and returns object.
+    return this.transformer.transform(
+      tenantId,
+      project,
+      new ProjectDetailedTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/GetProjectBillableEntries.ts b/packages/server/src/services/Projects/Projects/GetProjectBillableEntries.ts
new file mode 100644
index 000000000..443b82909
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/GetProjectBillableEntries.ts
@@ -0,0 +1,139 @@
+import { Inject, Service } from 'typedi';
+import { flatten, includes, isEmpty } from 'lodash';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ProjectBillableBillTransformer } from './ProjectBillableBillTransformer';
+import { ProjectBillableExpenseTransformer } from './ProjectBillableExpenseTransformer';
+import { ProjectBillableTaskTransformer } from './ProjectBillableTaskTransformer';
+import {
+  ProjectBillableEntriesQuery,
+  ProjectBillableEntry,
+  ProjectBillableType,
+} from '@/interfaces';
+import { ProjectBillableGetter } from './_types';
+
+@Service()
+export default class GetProjectBillableEntries {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Billable getter with type.
+   * @get
+   * @returns {ProjectBillableGetter[]}
+   */
+  get billableGetters(): ProjectBillableGetter[] {
+    return [
+      { type: ProjectBillableType.Task, getter: this.getProjectBillableTasks },
+      {
+        type: ProjectBillableType.Expense,
+        getter: this.getProjectBillableExpenses,
+      },
+      { type: ProjectBillableType.Bill, getter: this.getProjectBillableBills },
+    ];
+  }
+
+  /**
+   * Retrieve the billable entries of the given project.
+   * @param {number} tenantId
+   * @param {number} projectId
+   * @param {ProjectBillableEntriesQuery} query -
+   * @returns {}
+   */
+  public getProjectBillableEntries = async (
+    tenantId: number,
+    projectId: number,
+    query: ProjectBillableEntriesQuery = {
+      billableType: [],
+    }
+  ): Promise<ProjectBillableEntry[]> => {
+    const gettersOpers = this.billableGetters
+      .filter(
+        (billableGetter) =>
+          includes(query.billableType, billableGetter.type) ||
+          isEmpty(query.billableType)
+      )
+      .map((billableGetter) =>
+        billableGetter.getter(tenantId, projectId, query)
+      );
+    const gettersResults = await Promise.all(gettersOpers);
+
+    return flatten(gettersResults);
+  };
+
+  /**
+   * Retrieves the billable tasks of the given project.
+   * @param {number} tenantId
+   * @param {number} projectId
+   * @param {ProjectBillableEntriesQuery} query
+   * @returns {ProjectBillableEntry[]}
+   */
+  private getProjectBillableTasks = async (
+    tenantId: number,
+    projectId: number,
+    query: ProjectBillableEntriesQuery
+  ): Promise<ProjectBillableEntry[]> => {
+    const { Task } = this.tenancy.models(tenantId);
+
+    const billableTasks = await Task.query().where('projectId', projectId);
+
+    return this.transformer.transform(
+      tenantId,
+      billableTasks,
+      new ProjectBillableTaskTransformer()
+    );
+  };
+
+  /**
+   * Retrieves the billable expenses of the given project.
+   * @param {number} tenantId
+   * @param {number} projectId
+   * @param {ProjectBillableEntriesQuery} query
+   * @returns
+   */
+  private getProjectBillableExpenses = async (
+    tenantId: number,
+    projectId: number,
+    query: ProjectBillableEntriesQuery
+  ) => {
+    const { Expense } = this.tenancy.models(tenantId);
+
+    const billableExpenses = await Expense.query()
+      .where('projectId', projectId)
+      .modify('filterByDateRange', null, query.toDate)
+      .modify('filterByPublished');
+
+    return this.transformer.transform(
+      tenantId,
+      billableExpenses,
+      new ProjectBillableExpenseTransformer()
+    );
+  };
+
+  /**
+   * Retrieves billable bills of the given project.
+   * @param {number} tenantId
+   * @param {number} projectId
+   * @param {ProjectBillableEntriesQuery} query
+   */
+  private getProjectBillableBills = async (
+    tenantId: number,
+    projectId: number,
+    query: ProjectBillableEntriesQuery
+  ) => {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    const billableBills = await Bill.query()
+      .where('projectId', projectId)
+      .modify('published');
+
+    return this.transformer.transform(
+      tenantId,
+      billableBills,
+      new ProjectBillableBillTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/GetProjects.ts b/packages/server/src/services/Projects/Projects/GetProjects.ts
new file mode 100644
index 000000000..196b62462
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/GetProjects.ts
@@ -0,0 +1,38 @@
+import { IProjectGetPOJO } from '@/interfaces';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+import { ProjectDetailedTransformer } from './ProjectDetailedTransformer';
+
+@Service()
+export default class GetProjects {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the projects list.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @returns {Promise<IProjectGetPOJO[]>}
+   */
+  public getProjects = async (tenantId: number): Promise<IProjectGetPOJO[]> => {
+    const { Project } = this.tenancy.models(tenantId);
+
+    // Retrieve projects.
+    const projects = await Project.query()
+      .withGraphFetched('contact')
+      .modify('totalExpensesDetails')
+      .modify('totalBillsDetails')
+      .modify('totalTasksDetails');
+
+    // Transformes and returns object.
+    return this.transformer.transform(
+      tenantId,
+      projects,
+      new ProjectDetailedTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectBillableBill.ts b/packages/server/src/services/Projects/Projects/ProjectBillableBill.ts
new file mode 100644
index 000000000..d97dc6156
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectBillableBill.ts
@@ -0,0 +1,45 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class ProjectBillableBill {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Increase the invoiced amount of the given bill.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} billId - Bill id.
+   * @param {number} invoicedAmount - Invoiced amount.
+   */
+  public increaseInvoicedBill = async (
+    tenantId: number,
+    billId: number,
+    invoicedAmount: number
+  ) => {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    await Bill.query()
+      .findById(billId)
+      .increment('projectInvoicedAmount', invoicedAmount);
+  };
+
+  /**
+   * Decrease the invoiced amount of the given bill.
+   * @param {number} tenantId
+   * @param {number} billId - Bill id.
+   * @param {number} invoiceHours - Invoiced amount.
+   * @returns {}
+   */
+  public decreaseInvoicedBill = async (
+    tenantId: number,
+    billId: number,
+    invoiceHours: number
+  ) => {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    await Bill.query()
+      .findById(billId)
+      .decrement('projectInvoicedAmount', invoiceHours);
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectBillableBillInvoiced.ts b/packages/server/src/services/Projects/Projects/ProjectBillableBillInvoiced.ts
new file mode 100644
index 000000000..c32228755
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectBillableBillInvoiced.ts
@@ -0,0 +1,116 @@
+import async from 'async';
+import { Knex } from 'knex';
+import { Service } from 'typedi';
+import { ISaleInvoice, ISaleInvoiceDTO, ProjectLinkRefType } from '@/interfaces';
+import { ProjectBillableExpense } from './ProjectBillableExpense';
+import { filterEntriesByRefType } from './_utils';
+
+@Service()
+export class ProjectBillableBill {
+  @Inject()
+  private projectBillableExpense: ProjectBillableExpense;
+
+  /**
+   * Increases the invoiced amount of the given bills that associated
+   * to the invoice entries.
+   * @param {number} tenantId
+   * @param {ISaleInvoice | ISaleInvoiceDTO} saleInvoiceDTO
+   * @param {Knex.Transaction} trx
+   */
+  public increaseInvoicedBill = async (
+    tenantId: number,
+    saleInvoiceDTO: ISaleInvoice | ISaleInvoiceDTO,
+    trx?: Knex.Transaction
+  ) => {
+    // Initiates a new queue for accounts balance mutation.
+    const saveAccountsBalanceQueue = async.queue(
+      this.increaseInvoicedExpenseQueue,
+      10
+    );
+    const filteredEntries = filterEntriesByRefType(
+      saleInvoiceDTO.entries,
+      ProjectLinkRefType.Task
+    );
+    filteredEntries.forEach((entry) => {
+      saveAccountsBalanceQueue.push({
+        tenantId,
+        projectRefId: entry.projectRefId,
+        projectRefInvoicedAmount: entry.projectRefInvoicedAmount,
+        trx,
+      });
+    });
+    if (filteredEntries.length > 0) {
+      await saveAccountsBalanceQueue.drain();
+    }
+  };
+
+  /**
+   * Decreases the invoiced amount of the given bills that associated
+   * to the invoice entries.
+   * @param {number} tenantId
+   * @param {ISaleInvoice | ISaleInvoiceDTO} saleInvoiceDTO
+   * @param {Knex.Transaction} trx
+   */
+  public decreaseInvoicedBill = async (
+    tenantId: number,
+    saleInvoiceDTO: ISaleInvoice | ISaleInvoiceDTO,
+    trx?: Knex.Transaction
+  ) => {
+    // Initiates a new queue for accounts balance mutation.
+    const saveAccountsBalanceQueue = async.queue(
+      this.decreaseInvoicedExpenseQueue,
+      10
+    );
+    const filteredEntries = filterEntriesByRefType(
+      saleInvoiceDTO.entries,
+      ProjectLinkRefType.Task
+    );
+    filteredEntries.forEach((entry) => {
+      saveAccountsBalanceQueue.push({
+        tenantId,
+        projectRefId: entry.projectRefId,
+        projectRefInvoicedAmount: entry.projectRefInvoicedAmount,
+        trx,
+      });
+    });
+    if (filteredEntries.length > 0) {
+      await saveAccountsBalanceQueue.drain();
+    }
+  };
+
+  /**
+   * Queue job increases the invoiced amount of the given bill.
+   * @param {IncreaseInvoicedTaskQueuePayload} - payload
+   */
+  private increaseInvoicedExpenseQueue = async ({
+    tenantId,
+    projectRefId,
+    projectRefInvoicedAmount,
+    trx,
+  }) => {
+    await this.projectBillableExpense.increaseInvoicedExpense(
+      tenantId,
+      projectRefId,
+      projectRefInvoicedAmount,
+      trx
+    );
+  };
+
+  /**
+   * Queue job decreases the invoiced amount of the given bill.
+   * @param {IncreaseInvoicedTaskQueuePayload} - payload
+   */
+  private decreaseInvoicedExpenseQueue = async ({
+    tenantId,
+    projectRefId,
+    projectRefInvoicedAmount,
+    trx,
+  }) => {
+    await this.projectBillableExpense.decreaseInvoicedExpense(
+      tenantId,
+      projectRefId,
+      projectRefInvoicedAmount,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectBillableBillSubscriber.ts b/packages/server/src/services/Projects/Projects/ProjectBillableBillSubscriber.ts
new file mode 100644
index 000000000..d4c552b5a
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectBillableBillSubscriber.ts
@@ -0,0 +1,84 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  ISaleInvoiceCreatedPayload,
+  ISaleInvoiceDeletedPayload,
+  ISaleInvoiceEditedPayload,
+} from '@/interfaces';
+import { ProjectBillableTask } from './ProjectBillableTasks';
+import { ProjectBillableExpense } from './ProjectBillableExpense';
+import { ProjectBillableExpenseInvoiced } from './ProjectBillableExpenseInvoiced';
+
+@Service()
+export class ProjectBillableBillSubscriber {
+  @Inject()
+  private projectBillableExpenseInvoiced: ProjectBillableExpenseInvoiced;
+
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.saleInvoice.onCreated,
+      this.handleIncreaseBillableBill
+    );
+    bus.subscribe(events.saleInvoice.onEdited, this.handleDecreaseBillableBill);
+    bus.subscribe(events.saleInvoice.onDeleted, this.handleEditBillableBill);
+  }
+
+  /**
+   * Increases the billable amount of expense.
+   * @param {ISaleInvoiceCreatedPayload} payload -
+   */
+  public handleIncreaseBillableBill = async ({
+    tenantId,
+    saleInvoice,
+    saleInvoiceDTO,
+    trx,
+  }: ISaleInvoiceCreatedPayload) => {
+    await this.projectBillableExpenseInvoiced.increaseInvoicedExpense(
+      tenantId,
+      saleInvoiceDTO,
+      trx
+    );
+  };
+
+  /**
+   * Decreases the billable amount of expense.
+   * @param {ISaleInvoiceDeletedPayload} payload -
+   */
+  public handleDecreaseBillableBill = async ({
+    tenantId,
+    oldSaleInvoice,
+    trx,
+  }: ISaleInvoiceDeletedPayload) => {
+    await this.projectBillableExpenseInvoiced.decreaseInvoicedExpense(
+      tenantId,
+      oldSaleInvoice,
+      trx
+    );
+  };
+
+  /**
+   *
+   * @param {ISaleInvoiceEditedPayload} payload -
+   */
+  public handleEditBillableBill = async ({
+    tenantId,
+    oldSaleInvoice,
+    saleInvoiceDTO,
+    trx,
+  }: ISaleInvoiceEditedPayload) => {
+    await this.projectBillableExpenseInvoiced.decreaseInvoicedExpense(
+      tenantId,
+      oldSaleInvoice,
+      trx
+    );
+    await this.projectBillableExpenseInvoiced.increaseInvoicedExpense(
+      tenantId,
+      saleInvoiceDTO,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectBillableBillTransformer.ts b/packages/server/src/services/Projects/Projects/ProjectBillableBillTransformer.ts
new file mode 100644
index 000000000..5d26fb5ef
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectBillableBillTransformer.ts
@@ -0,0 +1,101 @@
+import { IBill } from '@/interfaces';
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class ProjectBillableBillTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'billableType',
+      'billableId',
+      'billableAmount',
+      'billableAmountFormatted',
+      'billableCurrency',
+      'billableTransactionNo',
+      'billableDate',
+      'billableDateFormatted',
+    ];
+  };
+
+  /**
+   * Exclude attributes.
+   * @returns {string[]}
+   */
+  public excludeAttributes = (): string[] => {
+    return ['*'];
+  };
+
+  /**
+   * Billable type.
+   * @returns {string}
+   */
+  public billableType = () => {
+    return 'Bill';
+  };
+
+  /**
+   * Billable id.
+   * @param {IBill} bill
+   * @returns {string}
+   */
+  public billableId = (bill: IBill) => {
+    return bill.id;
+  };
+
+  /**
+   * Billable amount.
+   * @param {IBill} bill
+   * @returns {string}
+   */
+  public billableAmount = (bill: IBill) => {
+    return bill.billableAmount;
+  };
+
+  /**
+   * Billable amount formatted.
+   * @param {IBill} bill
+   * @returns {string}
+   */
+  public billableAmountFormatted = (bill: IBill) => {
+    return formatNumber(bill.billableAmount, {
+      currencyCode: bill.currencyCode,
+    });
+  };
+
+  /**
+   * Billable currency.
+   * @param {IBill} bill
+   * @returns {string}
+   */
+  public billableCurrency = (bill: IBill) => {
+    return bill.currencyCode;
+  };
+
+  /**
+   *
+   * @param {IBill} bill
+   * @returns {string}
+   */
+  public billableTransactionNo = (bill: IBill) => {
+    return bill.billNumber;
+  };
+
+  /**
+   * Billable date.
+   * @returns {Date}
+   */
+  public billableDate = (bill: IBill) => {
+    return bill.createdAt;
+  };
+
+  /**
+   * Billable date formatted.
+   * @returns {string}
+   */
+  public billableDateFormatted = (bill: IBill) => {
+    return this.formatDate(bill.createdAt);
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectBillableExpense.ts b/packages/server/src/services/Projects/Projects/ProjectBillableExpense.ts
new file mode 100644
index 000000000..cdedfa8ee
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectBillableExpense.ts
@@ -0,0 +1,49 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Knex } from 'knex';
+
+@Service()
+export class ProjectBillableExpense {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Increase the invoiced amount of the given expense.
+   * @param {number} tenantId
+   * @param {number} expenseId
+   * @param {number} invoicedAmount
+   * @param {Knex.Transaction} trx
+   */
+  public increaseInvoicedExpense = async (
+    tenantId: number,
+    expenseId: number,
+    invoicedAmount: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { Expense } = this.tenancy.models(tenantId);
+
+    await Expense.query(trx)
+      .findById(expenseId)
+      .increment('invoicedAmount', invoicedAmount);
+  };
+
+  /**
+   * Decrease the invoiced amount of the given expense.
+   * @param {number} tenantId
+   * @param {number} taskId
+   * @param {number} invoiceHours
+   * @param {Knex.Transaction} knex
+   */
+  public decreaseInvoicedExpense = async (
+    tenantId: number,
+    expenseId: number,
+    invoiceHours: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { Expense } = this.tenancy.models(tenantId);
+
+    await Expense.query(trx)
+      .findById(expenseId)
+      .decrement('invoicedAmount', invoiceHours);
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectBillableExpenseInvoiced.ts b/packages/server/src/services/Projects/Projects/ProjectBillableExpenseInvoiced.ts
new file mode 100644
index 000000000..827886a30
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectBillableExpenseInvoiced.ts
@@ -0,0 +1,116 @@
+import { Knex } from 'knex';
+import { Inject, Service } from 'typedi';
+import async from 'async';
+import { ISaleInvoice, ISaleInvoiceDTO, ProjectLinkRefType } from '@/interfaces';
+import { ProjectBillableExpense } from './ProjectBillableExpense';
+import { filterEntriesByRefType } from './_utils';
+
+@Service()
+export class ProjectBillableExpenseInvoiced {
+  @Inject()
+  private projectBillableExpense: ProjectBillableExpense;
+
+  /**
+   * Increases the invoiced amount of invoice entries that reference to
+   * expense entries.
+   * @param {number} tenantId
+   * @param {ISaleInvoice | ISaleInvoiceDTO} saleInvoiceDTO
+   * @param {Knex.Transaction} trx
+   */
+  public increaseInvoicedExpense = async (
+    tenantId: number,
+    saleInvoiceDTO: ISaleInvoice | ISaleInvoiceDTO,
+    trx?: Knex.Transaction
+  ) => {
+    // Initiates a new queue for accounts balance mutation.
+    const saveAccountsBalanceQueue = async.queue(
+      this.increaseInvoicedExpenseQueue,
+      10
+    );
+    const filteredEntries = filterEntriesByRefType(
+      saleInvoiceDTO.entries,
+      ProjectLinkRefType.Expense
+    );
+    filteredEntries.forEach((entry) => {
+      saveAccountsBalanceQueue.push({
+        tenantId,
+        projectRefId: entry.projectRefId,
+        projectRefInvoicedAmount: entry.projectRefInvoicedAmount,
+        trx,
+      });
+    });
+    if (filteredEntries.length > 0) {
+      await saveAccountsBalanceQueue.drain();
+    }
+  };
+
+  /**
+   * Decreases the invoiced amount of the given expenses from
+   * the invoice entries.
+   * @param {number} tenantId
+   * @param {ISaleInvoice | ISaleInvoiceDTO} saleInvoiceDTO
+   * @param {Knex.Transaction} trx
+   */
+  public decreaseInvoicedExpense = async (
+    tenantId: number,
+    saleInvoiceDTO: ISaleInvoice | ISaleInvoiceDTO,
+    trx?: Knex.Transaction
+  ) => {
+    // Initiates a new queue for accounts balance mutation.
+    const saveAccountsBalanceQueue = async.queue(
+      this.decreaseInvoicedExpenseQueue,
+      10
+    );
+    const filteredEntries = filterEntriesByRefType(
+      saleInvoiceDTO.entries,
+      ProjectLinkRefType.Expense
+    );
+    filteredEntries.forEach((entry) => {
+      saveAccountsBalanceQueue.push({
+        tenantId,
+        projectRefId: entry.projectRefId,
+        projectRefInvoicedAmount: entry.projectRefInvoicedAmount,
+        trx,
+      });
+    });
+    if (filteredEntries.length > 0) {
+      await saveAccountsBalanceQueue.drain();
+    }
+  };
+
+  /**
+   * Queue job increases the invoiced amount of the given expense.
+   * @param {IncreaseInvoicedTaskQueuePayload} - payload
+   */
+  private increaseInvoicedExpenseQueue = async ({
+    tenantId,
+    projectRefId,
+    projectRefInvoicedAmount,
+    trx,
+  }) => {
+    await this.projectBillableExpense.increaseInvoicedExpense(
+      tenantId,
+      projectRefId,
+      projectRefInvoicedAmount,
+      trx
+    );
+  };
+
+  /**
+   * Queue job decreases the invoiced amount of the given expense.
+   * @param {IncreaseInvoicedTaskQueuePayload} - payload
+   */
+  private decreaseInvoicedExpenseQueue = async ({
+    tenantId,
+    projectRefId,
+    projectRefInvoicedAmount,
+    trx,
+  }) => {
+    await this.projectBillableExpense.decreaseInvoicedExpense(
+      tenantId,
+      projectRefId,
+      projectRefInvoicedAmount,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectBillableExpenseSubscriber.ts b/packages/server/src/services/Projects/Projects/ProjectBillableExpenseSubscriber.ts
new file mode 100644
index 000000000..d5823ef12
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectBillableExpenseSubscriber.ts
@@ -0,0 +1,87 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  ISaleInvoiceCreatedPayload,
+  ISaleInvoiceDeletedPayload,
+  ISaleInvoiceEditedPayload,
+} from '@/interfaces';
+import { ProjectBillableExpenseInvoiced } from './ProjectBillableExpenseInvoiced';
+
+@Service()
+export class ProjectBillableExpensesSubscriber {
+  @Inject()
+  private projectBillableExpenseInvoiced: ProjectBillableExpenseInvoiced;
+
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleInvoice.onCreated,
+      this.handleIncreaseBillableExpenses
+    );
+    bus.subscribe(
+      events.saleInvoice.onEdited,
+      this.handleDecreaseBillableExpenses
+    );
+    bus.subscribe(
+      events.saleInvoice.onDeleted,
+      this.handleEditBillableExpenses
+    );
+  }
+
+  /**
+   * Increases the billable amount of expense.
+   * @param {ISaleInvoiceCreatedPayload} payload -
+   */
+  public handleIncreaseBillableExpenses = async ({
+    tenantId,
+    saleInvoiceDTO,
+    trx,
+  }: ISaleInvoiceCreatedPayload) => {
+    await this.projectBillableExpenseInvoiced.increaseInvoicedExpense(
+      tenantId,
+      saleInvoiceDTO,
+      trx
+    );
+  };
+
+  /**
+   * Decreases the billable amount of expense.
+   * @param {ISaleInvoiceDeletedPayload} payload -
+   */
+  public handleDecreaseBillableExpenses = async ({
+    tenantId,
+    oldSaleInvoice,
+    trx,
+  }: ISaleInvoiceDeletedPayload) => {
+    await this.projectBillableExpenseInvoiced.increaseInvoicedExpense(
+      tenantId,
+      oldSaleInvoice,
+      trx
+    );
+  };
+
+  /**
+   * Decreases the old invoice and increases the new invoice DTO.
+   * @param {ISaleInvoiceEditedPayload} payload -
+   */
+  public handleEditBillableExpenses = async ({
+    tenantId,
+    saleInvoice,
+    oldSaleInvoice,
+    trx,
+  }: ISaleInvoiceEditedPayload) => {
+    await this.projectBillableExpenseInvoiced.decreaseInvoicedExpense(
+      tenantId,
+      oldSaleInvoice,
+      trx
+    );
+    await this.projectBillableExpenseInvoiced.increaseInvoicedExpense(
+      tenantId,
+      saleInvoice,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectBillableExpenseTransformer.ts b/packages/server/src/services/Projects/Projects/ProjectBillableExpenseTransformer.ts
new file mode 100644
index 000000000..b827c520f
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectBillableExpenseTransformer.ts
@@ -0,0 +1,100 @@
+import { IExpense } from '@/interfaces';
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class ProjectBillableExpenseTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'billableType',
+      'billableId',
+      'billableAmount',
+      'billableAmountFormatted',
+      'billableCurrency',
+      'billableTransactionNo',
+      'billableDate',
+      'billableDateFormatted',
+    ];
+  };
+
+  /**
+   * Exclude attributes.
+   * @returns {string[]}
+   */
+  public excludeAttributes = (): string[] => {
+    return ['*'];
+  };
+
+  /**
+   * Retrieves the billable type.
+   * @returns {string}
+   */
+  public billableType = () => {
+    return 'Expense';
+  };
+
+  /**
+   * Retrieves the billable id.
+   * @param {IExpense} expense
+   * @returns {string}
+   */
+  public billableId = (expense: IExpense) => {
+    return expense.id;
+  };
+
+  /**
+   * Retrieves the billable amount of expense.
+   * @param {IExpense} expense  -
+   * @returns {number}
+   */
+  public billableAmount = (expense: IExpense) => {
+    return expense.billableAmount;
+  };
+
+  /**
+   * Retrieves the billable formatted amount of expense.
+   * @param {IExpense} expense
+   * @returns {string}
+   */
+  public billableAmountFormatted = (expense: IExpense) => {
+    return formatNumber(expense.billableAmount, {
+      currencyCode: expense.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieves the currency of billable expense.
+   * @param {IExpense} expense
+   * @returns {string}
+   */
+  public billableCurrency = (expense: IExpense) => {
+    return expense.currencyCode;
+  };
+
+  /**
+   * Billable transaction number.
+   * @returns {string}
+   */
+  public billableTransactionNo = () => {
+    return '';
+  };
+
+  /**
+   * Billable date.
+   * @returns {Date}
+   */
+  public billableDate = (expense: IExpense) => {
+    return expense.createdAt;
+  };
+
+  /**
+   * Billable date formatted.
+   * @returns {string}
+   */
+  public billableDateFormatted = (expense: IExpense) => {
+    return this.formatDate(expense.createdAt);
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectBillableTaskTransformer.ts b/packages/server/src/services/Projects/Projects/ProjectBillableTaskTransformer.ts
new file mode 100644
index 000000000..71aff5c4a
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectBillableTaskTransformer.ts
@@ -0,0 +1,108 @@
+import { IProjectTask } from '@/interfaces';
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class ProjectBillableTaskTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'billableType',
+      'billableId',
+      'billableAmount',
+      'billableAmountFormatted',
+      'billableHours',
+      'billableCurrency',
+      'billableTransactionNo',
+      'billableDate',
+      'billableDateFormatted',
+    ];
+  };
+
+  /**
+   * Exclude attributes.
+   * @returns {string[]}
+   */
+  public excludeAttributes = (): string[] => {
+    return ['*'];
+  };
+
+  /**
+   * Billable type.
+   * @returns {string}
+   */
+  public billableType = () => {
+    return 'Task';
+  };
+
+  /**
+   * Billable id.
+   * @param {IProjectTask} task
+   * @returns {string}
+   */
+  public billableId = (task: IProjectTask) => {
+    return task.id;
+  };
+
+  /**
+   * Billable amount.
+   * @param {IProjectTask} task
+   * @returns {number}
+   */
+  public billableAmount = (task: IProjectTask) => {
+    return task.billableAmount;
+  };
+
+  /**
+   * Billable amount formatted.
+   * @returns {string}
+   */
+  public billableAmountFormatted = (task: IProjectTask) => {
+    return formatNumber(task.billableAmount, {
+      currencyCode: this.context.baseCurrency,
+    });
+  };
+
+  /**
+   * Billable hours of the task.
+   * @param {IProjectTask} task
+   * @returns {number}
+   */
+  public billableHours = (task: IProjectTask) => {
+    return task.billableHours;
+  };
+
+  /**
+   * Retrieves the currency of billable entry.
+   * @returns {string}
+   */
+  public billableCurrency = () => {
+    return this.context.baseCurrency;
+  };
+
+  /**
+   * Billable transaction number.
+   * @returns {string}
+   */
+  public billableTransactionNo = () => {
+    return '';
+  };
+
+  /**
+   * Billable date.
+   * @returns {Date}
+   */
+  public billableDate = (task: IProjectTask) => {
+    return task.createdAt;
+  };
+
+  /**
+   * Billable date formatted.
+   * @returns {string}
+   */
+  public billableDateFormatted = (task: IProjectTask) => {
+    return this.formatDate(task.createdAt);
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectBillableTasks.ts b/packages/server/src/services/Projects/Projects/ProjectBillableTasks.ts
new file mode 100644
index 000000000..511a751c3
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectBillableTasks.ts
@@ -0,0 +1,48 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Knex } from 'knex';
+
+@Service()
+export class ProjectBillableTask {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Increase the invoiced hours of the given task.
+   * @param {number} tenantId
+   * @param {number} taskId
+   * @param {number} invoiceHours
+   */
+  public increaseInvoicedTask = async (
+    tenantId: number,
+    taskId: number,
+    invoiceHours: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { Task } = this.tenancy.models(tenantId);
+
+    await Task.query(trx)
+      .findById(taskId)
+      .increment('invoicedHours', invoiceHours);
+  };
+
+  /**
+   * Decrease the invoiced hours of the given task.
+   * @param {number} tenantId
+   * @param {number} taskId
+   * @param {number} invoiceHours -
+   * @returns {}
+   */
+  public decreaseInvoicedTask = async (
+    tenantId: number,
+    taskId: number,
+    invoiceHours: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { Task } = this.tenancy.models(tenantId);
+
+    await Task.query(trx)
+      .findById(taskId)
+      .decrement('invoicedHours', invoiceHours);
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectBillableTasksInvoiced.ts b/packages/server/src/services/Projects/Projects/ProjectBillableTasksInvoiced.ts
new file mode 100644
index 000000000..d54958de9
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectBillableTasksInvoiced.ts
@@ -0,0 +1,116 @@
+import async from 'async';
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import { ISaleInvoice, ISaleInvoiceDTO, ProjectLinkRefType } from '@/interfaces';
+import { ProjectBillableTask } from './ProjectBillableTasks';
+import { filterEntriesByRefType } from './_utils';
+import { IncreaseInvoicedTaskQueuePayload } from './_types';
+
+@Service()
+export class ProjectBillableTasksInvoiced {
+  @Inject()
+  private projectBillableTasks: ProjectBillableTask;
+
+  /**
+   * Increases the invoiced amount of the given tasks that associated
+   * to the invoice entries.
+   * @param {number} tenantId
+   * @param {ISaleInvoiceDTO} saleInvoiceDTO
+   */
+  public increaseInvoicedTasks = async (
+    tenantId: number,
+    saleInvoiceDTO: ISaleInvoiceDTO | ISaleInvoice,
+    trx?: Knex.Transaction
+  ) => {
+    // Initiate a new queue for accounts balance mutation.
+    const saveAccountsBalanceQueue = async.queue(
+      this.increaseInvoicedTaskQueue,
+      10
+    );
+    const filteredEntries = filterEntriesByRefType(
+      saleInvoiceDTO.entries,
+      ProjectLinkRefType.Task
+    );
+    filteredEntries.forEach((entry) => {
+      saveAccountsBalanceQueue.push({
+        tenantId,
+        projectRefId: entry.projectRefId,
+        projectRefInvoicedAmount: entry.projectRefInvoicedAmount,
+        trx,
+      });
+    });
+    if (filteredEntries.length > 0) {
+      await saveAccountsBalanceQueue.drain();
+    }
+  };
+
+  /**
+   * Decreases the invoiced amount of the given tasks that associated
+   * to the invoice entries.
+   * @param {number} tenantId
+   * @param {ISaleInvoiceDTO | ISaleInvoice} saleInvoiceDTO
+   * @param {Knex.Transaction} trx
+   */
+  public decreaseInvoicedTasks = async (
+    tenantId: number,
+    saleInvoiceDTO: ISaleInvoiceDTO | ISaleInvoice,
+    trx?: Knex.Transaction
+  ) => {
+    // Initiate a new queue for accounts balance mutation.
+    const saveAccountsBalanceQueue = async.queue(
+      this.decreaseInvoicedTaskQueue,
+      10
+    );
+    const filteredEntries = filterEntriesByRefType(
+      saleInvoiceDTO.entries,
+      ProjectLinkRefType.Task
+    );
+    filteredEntries.forEach((entry) => {
+      saveAccountsBalanceQueue.push({
+        tenantId,
+        projectRefId: entry.projectRefId,
+        projectRefInvoicedAmount: entry.projectRefInvoicedAmount,
+        trx,
+      });
+    });
+    if (filteredEntries.length > 0) {
+      await saveAccountsBalanceQueue.drain();
+    }
+  };
+
+  /**
+   * Queue job increases the invoiced amount of the given task.
+   * @param {IncreaseInvoicedTaskQueuePayload} - payload
+   */
+  private increaseInvoicedTaskQueue = async ({
+    tenantId,
+    projectRefId,
+    projectRefInvoicedAmount,
+    trx,
+  }: IncreaseInvoicedTaskQueuePayload) => {
+    await this.projectBillableTasks.increaseInvoicedTask(
+      tenantId,
+      projectRefId,
+      projectRefInvoicedAmount,
+      trx
+    );
+  };
+
+  /**
+   * Queue jobs decreases the invoiced amount of the given task.
+   * @param {IncreaseInvoicedTaskQueuePayload} - payload
+   */
+  private decreaseInvoicedTaskQueue = async ({
+    tenantId,
+    projectRefId,
+    projectRefInvoicedAmount,
+    trx,
+  }) => {
+    await this.projectBillableTasks.decreaseInvoicedTask(
+      tenantId,
+      projectRefId,
+      projectRefInvoicedAmount,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectBillableTasksSubscriber.ts b/packages/server/src/services/Projects/Projects/ProjectBillableTasksSubscriber.ts
new file mode 100644
index 000000000..3cc53215d
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectBillableTasksSubscriber.ts
@@ -0,0 +1,104 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  ISaleInvoiceCreatedPayload,
+  ISaleInvoiceDeletedPayload,
+  ISaleInvoiceEditedPayload,
+} from '@/interfaces';
+import { ProjectInvoiceValidator } from './ProjectInvoiceValidator';
+import { ProjectBillableTasksInvoiced } from './ProjectBillableTasksInvoiced';
+
+@Service()
+export class ProjectBillableTasksSubscriber {
+  @Inject()
+  private projectBillableTasks: ProjectBillableTasksInvoiced;
+
+  @Inject()
+  private projectBillableTasksValidator: ProjectInvoiceValidator;
+
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleInvoice.onCreating,
+      this.handleValidateInvoiceTasksRefs
+    );
+    bus.subscribe(
+      events.saleInvoice.onCreated,
+      this.handleIncreaseBillableTasks
+    );
+    bus.subscribe(events.saleInvoice.onEdited, this.handleEditBillableTasks);
+    bus.subscribe(
+      events.saleInvoice.onDeleted,
+      this.handleDecreaseBillableTasks
+    );
+  }
+
+  /**
+   * Validate the tasks refs ids existance.
+   * @param {ISaleInvoiceCreatedPayload} payload -
+   */
+  public handleValidateInvoiceTasksRefs = async ({
+    tenantId,
+    saleInvoiceDTO,
+  }: ISaleInvoiceCreatedPayload) => {
+    await this.projectBillableTasksValidator.validateTasksRefsExistance(
+      tenantId,
+      saleInvoiceDTO
+    );
+  };
+
+  /**
+   * Handle increase the invoiced tasks once the sale invoice be created.
+   * @param {ISaleInvoiceCreatedPayload} payload -
+   */
+  public handleIncreaseBillableTasks = async ({
+    tenantId,
+    saleInvoiceDTO,
+  }: ISaleInvoiceCreatedPayload) => {
+    await this.projectBillableTasks.increaseInvoicedTasks(
+      tenantId,
+      saleInvoiceDTO
+    );
+  };
+
+  /**
+   * Handle decrease the invoiced tasks once the sale invoice be deleted.
+   * @param {ISaleInvoiceDeletedPayload} payload -
+   */
+  public handleDecreaseBillableTasks = async ({
+    tenantId,
+    oldSaleInvoice,
+    trx,
+  }: ISaleInvoiceDeletedPayload) => {
+    await this.projectBillableTasks.decreaseInvoicedTasks(
+      tenantId,
+      oldSaleInvoice,
+      trx
+    );
+  };
+
+  /**
+   * Handle adjusting the invoiced tasks once the sale invoice be edited.
+   * @param {ISaleInvoiceEditedPayload} payload -
+   */
+  public handleEditBillableTasks = async ({
+    tenantId,
+    oldSaleInvoice,
+    saleInvoiceDTO,
+    trx,
+  }: ISaleInvoiceEditedPayload) => {
+    await this.projectBillableTasks.increaseInvoicedTasks(
+      tenantId,
+      saleInvoiceDTO,
+      trx
+    );
+    await this.projectBillableTasks.decreaseInvoicedTasks(
+      tenantId,
+      oldSaleInvoice,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectDetailedTransformer.ts b/packages/server/src/services/Projects/Projects/ProjectDetailedTransformer.ts
new file mode 100644
index 000000000..ff4c91dd4
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectDetailedTransformer.ts
@@ -0,0 +1,391 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { sumBy } from 'lodash';
+import Project from 'models/Project';
+import { formatNumber } from 'utils';
+import { formatMinutes } from 'utils/formatMinutes';
+
+export class ProjectDetailedTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'costEstimateFormatted',
+      'deadlineFormatted',
+      'contactDisplayName',
+      'statusFormatted',
+
+      'totalActualHours',
+      'totalActualHoursFormatted',
+      'totalEstimateHours',
+      'totalEstimateHoursFormatted',
+      'totalInvoicedHours',
+      'totalInvoicedHoursFormatted',
+      'totalBillableHours',
+      'totalBillableHoursFormatted',
+
+      'totalActualHoursAmount',
+      'totalActualHoursAmountFormatted',
+      'totalEstimateHoursAmount',
+      'totalEstimateHoursAmountFormatted',
+      'totalInvoicedHoursAmount',
+      'totalInvoicedHoursAmountFormatted',
+      'totalBillableHoursAmount',
+      'totalBillableHoursAmountFormatted',
+
+      'totalExpenses',
+      'totalExpensesFormatted',
+
+      'totalInvoicedExpenses',
+      'totalInvoicedExpensesFormatted',
+
+      'totalBillableExpenses',
+      'totalBillableExpensesFormatted',
+
+      'totalInvoiced',
+      'totalInvoicedFormatted',
+
+      'totalBillable',
+      'totalBillableFormatted',
+    ];
+  };
+
+  /**
+   * Exclude these attributes.
+   * @returns {string[]}
+   */
+  public excludeAttributes = (): string[] => {
+    return ['contact', 'tasks', 'expenses', 'bills'];
+  };
+
+  /**
+   * Retrieves the formatted value of cost estimate.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public costEstimateFormatted = (project: Project) => {
+    return formatNumber(project.costEstimate, {
+      currencyCode: this.context.organization.baseCurrency,
+    });
+  };
+
+  /**
+   * Retrieves the formatted value of the deadline date.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public deadlineFormatted = (project: Project) => {
+    return this.formatDate(project.deadline);
+  };
+
+  /**
+   * Retrieves the contact display name.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public contactDisplayName = (project: Project) => {
+    return project.contact.displayName;
+  };
+
+  /**
+   * Retrieves the formatted value of project's status.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public statusFormatted = (project: Project) => {
+    return project.status;
+  };
+
+  // --------------------------------------------------------------
+  // # Tasks Hours
+  // --------------------------------------------------------------
+  /**
+   * Total actual hours.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalActualHours = (project: Project) => {
+    return sumBy(project.tasks, 'totalActualHours');
+  };
+
+  /**
+   * Retrieves the formatted total actual hours.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public totalActualHoursFormatted = (project: Project) => {
+    const hours = this.totalActualHours(project);
+    return formatMinutes(hours);
+  };
+
+  /**
+   * Total Estimated hours.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalEstimateHours = (project: Project) => {
+    return sumBy(project.tasks, 'totalEstimateHours');
+  };
+
+  /**
+   * Total estimate hours formatted.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public totalEstimateHoursFormatted = (project: Project) => {
+    const hours = this.totalEstimateHours(project);
+    return formatMinutes(hours);
+  };
+
+  /**
+   * Total invoiced hours.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalInvoicedHours = (project: Project) => {
+    return sumBy(project.tasks, 'totalInvoicedHours');
+  };
+
+  /**
+   * Total invoiced hours formatted.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public totalInvoicedHoursFormatted = (project: Project) => {
+    const hours = this.totalInvoicedHours(project);
+    return formatMinutes(hours);
+  };
+
+  /**
+   * Total billable hours.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalBillableHours = (project: Project) => {
+    const totalActualHours = this.totalActualHours(project);
+    const totalInvoicedHours = this.totalInvoicedHours(project);
+
+    return Math.max(totalActualHours - totalInvoicedHours, 0);
+  };
+
+  /**
+   * Retrieves the billable hours formatted.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public totalBillableHoursFormatted = (project) => {
+    const hours = this.totalBillableHours(project);
+    return formatMinutes(hours);
+  };
+
+  // --------------------------------------------------------------
+  // # Tasks Hours Amount
+  // --------------------------------------------------------------
+  /**
+   * Total amount of invoiced hours.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalActualHoursAmount = (project: Project) => {
+    return sumBy(project.tasks, 'totalActualAmount');
+  };
+
+  /**
+   * Total amount of invoiced hours.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalActualHoursAmountFormatted = (project: Project) => {
+    return formatNumber(this.totalActualHoursAmount(project), {
+      currencyCode: this.context.baseCurrency,
+    });
+  };
+
+  /**
+   * Total amount of estimated hours.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalEstimateHoursAmount = (project: Project) => {
+    return sumBy(project.tasks, 'totalEstimateAmount');
+  };
+
+  /**
+   * Formatted amount of total estimate hours.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public totalEstimateHoursAmountFormatted = (project: Project) => {
+    return formatNumber(this.totalEstimateHoursAmount(project), {
+      currencyCode: this.context.baseCurrency,
+    });
+  };
+
+  /**
+   * Total amount of invoiced hours.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalInvoicedHoursAmount = (project) => {
+    return sumBy(project.tasks, 'totalInvoicedAmount');
+  };
+
+  /**
+   * Formatted total amount of invoiced hours.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalInvoicedHoursAmountFormatted = (project) => {
+    return formatNumber(this.totalInvoicedHoursAmount(project), {
+      currencyCode: this.context.baseCurrency,
+    });
+  };
+
+  /**
+   * Total amount of billable hours.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalBillableHoursAmount = (project) => {
+    const totalActualAmount = this.totalActualHoursAmount(project);
+    const totalBillableAmount = this.totalInvoicedHoursAmount(project);
+
+    return Math.max(totalActualAmount, totalBillableAmount);
+  };
+
+  /**
+   * Formatted total amount of billable hours.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public totalBillableHoursAmountFormatted = (project) => {
+    return formatNumber(this.totalBillableHoursAmount(project), {
+      currencyCode: this.context.baseCurrency,
+    });
+  };
+
+  // --------------------------------------------------------------
+  // # Expenses
+  // --------------------------------------------------------------
+  /**
+   * Total expenses amount.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalExpenses = (project) => {
+    const expensesTotal = sumBy(project.expenses, 'totalExpenses');
+    const billsTotal = sumBy(project.bills, 'totalBills');
+
+    return expensesTotal + billsTotal;
+  };
+
+  /**
+   * Formatted total amount of expenses.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public totalExpensesFormatted = (project) => {
+    return formatNumber(this.totalExpenses(project), {
+      currencyCode: this.context.baseCurrency,
+    });
+  };
+
+  /**
+   * Total amount of invoiced expenses.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalInvoicedExpenses = (project: Project) => {
+    const totalInvoicedExpenses = sumBy(
+      project.expenses,
+      'totalInvoicedExpenses'
+    );
+    const totalInvoicedBills = sumBy(project.bills, 'totalInvoicedBills');
+
+    return totalInvoicedExpenses + totalInvoicedBills;
+  };
+
+  /**
+   * Formatted total amount of invoiced expenses.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public totalInvoicedExpensesFormatted = (project: Project) => {
+    return formatNumber(this.totalInvoicedExpenses(project), {
+      currencyCode: this.context.baseCurrency,
+    });
+  };
+
+  /**
+   * Total amount of billable expenses.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalBillableExpenses = (project: Project) => {
+    const totalInvoiced = this.totalInvoicedExpenses(project);
+    const totalInvoice = this.totalExpenses(project);
+
+    return totalInvoice - totalInvoiced;
+  };
+
+  /**
+   * Formatted total amount of billable expenses.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public totalBillableExpensesFormatted = (project: Project) => {
+    return formatNumber(this.totalBillableExpenses(project), {
+      currencyCode: this.context.baseCurrency,
+    });
+  };
+
+  // --------------------------------------------------------------
+  // # Total
+  // --------------------------------------------------------------
+  /**
+   * Total invoiced amount.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalInvoiced = (project: Project) => {
+    const invoicedExpenses = this.totalInvoicedExpenses(project);
+    const invoicedTasks = this.totalInvoicedHoursAmount(project);
+
+    return invoicedExpenses + invoicedTasks;
+  };
+
+  /**
+   * Formatted amount of total invoiced.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalInvoicedFormatted = (project: Project) => {
+    return formatNumber(this.totalInvoiced(project), {
+      currencyCode: this.context.baseCurrency,
+    });
+  };
+
+  /**
+   * Total billable amount.
+   * @param {Project} project
+   * @returns {number}
+   */
+  public totalBillable = (project: Project) => {
+    const billableExpenses = this.totalBillableExpenses(project);
+    const billableTasks = this.totalBillableHoursAmount(project);
+
+    return billableExpenses + billableTasks;
+  };
+
+  /**
+   * Formatted amount of billable total.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public totalBillableFormatted = (project: Project) => {
+    return formatNumber(this.totalBillable(project), {
+      currencyCode: this.context.baseCurrency,
+    });
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectInvoiceValidator.ts b/packages/server/src/services/Projects/Projects/ProjectInvoiceValidator.ts
new file mode 100644
index 000000000..5e045623e
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectInvoiceValidator.ts
@@ -0,0 +1,48 @@
+import { ServiceError } from '@/exceptions';
+import { ISaleInvoiceCreateDTO, ProjectLinkRefType } from '@/interfaces';
+import { difference, isEmpty } from 'lodash';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+import { ERRORS } from './constants';
+
+@Service()
+export class ProjectInvoiceValidator {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Validate the tasks refs ids existance.
+   * @param {number} tenantId
+   * @param {ISaleInvoiceCreateDTO} saleInvoiceDTO
+   * @returns {Promise<void>}
+   */
+  async validateTasksRefsExistance(
+    tenantId: number,
+    saleInvoiceDTO: ISaleInvoiceCreateDTO
+  ) {
+    const { Task } = this.tenancy.models(tenantId);
+
+    // Filters the invoice entries that have `Task` type and not empty ref. id.
+    const tasksRefs = saleInvoiceDTO.entries.filter(
+      (entry) =>
+        entry?.projectRefType === ProjectLinkRefType.Task &&
+        !isEmpty(entry?.projectRefId)
+    );
+    //
+    if (!tasksRefs.length || (tasksRefs.length && !saleInvoiceDTO.projectId)) {
+      return;
+    }
+    const tasksRefsIds = tasksRefs.map((ref) => ref.projectRefId);
+
+    const tasks = await Task.query()
+      .whereIn('id', tasksRefsIds)
+      .where('projectId', saleInvoiceDTO.projectId);
+
+    const tasksIds = tasks.map((task) => task.id);
+    const notFoundTasksIds = difference(tasksIds, tasksRefsIds);
+
+    if (!notFoundTasksIds.length) {
+      throw new ServiceError(ERRORS.ITEM_ENTRIES_REF_IDS_NOT_FOUND);
+    }
+  }
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectTransformer.ts b/packages/server/src/services/Projects/Projects/ProjectTransformer.ts
new file mode 100644
index 000000000..ba13c33a3
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectTransformer.ts
@@ -0,0 +1,64 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import Project from 'models/Project';
+import { formatNumber } from 'utils';
+
+export class ProjectTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'costEstimateFormatted',
+      'deadlineFormatted',
+      'contactDisplayName',
+      'statusFormatted',
+    ];
+  };
+
+  /**
+   * Exclude these attributes.
+   * @returns {string[]}
+   */
+  public excludeAttributes = (): string[] => {
+    return ['contact'];
+  };
+
+  /**
+   * Retrieves the formatted value of cost estimate.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public costEstimateFormatted = (project: Project) => {
+    return formatNumber(project.costEstimate, {
+      currencyCode: this.context.organization.baseCurrency,
+    });
+  };
+
+  /**
+   * Retrieves the formatted value of the deadline date.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public deadlineFormatted = (project: Project) => {
+    return this.formatDate(project.deadline);
+  };
+
+  /**
+   * Retrieves the contact display name.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public contactDisplayName = (project: Project) => {
+    return project.contact.displayName;
+  };
+
+  /**
+   * Retrieves the formatted value of project's status.
+   * @param {Project} project
+   * @returns {string}
+   */
+  public statusFormatted = (project: Project) => {
+    return project.status;
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectsApplication.ts b/packages/server/src/services/Projects/Projects/ProjectsApplication.ts
new file mode 100644
index 000000000..645e28219
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectsApplication.ts
@@ -0,0 +1,147 @@
+import { Inject, Service } from 'typedi';
+import {
+  IProjectCreateDTO,
+  IProjectCreatePOJO,
+  IProjectEditPOJO,
+  IProjectGetPOJO,
+  IProjectStatus,
+  IVendorsFilter,
+  ProjectBillableEntriesQuery,
+  ProjectBillableEntry,
+} from '@/interfaces';
+import CreateProject from './CreateProject';
+import DeleteProject from './DeleteProject';
+import GetProject from './GetProject';
+import EditProjectService from './EditProject';
+import GetProjects from './GetProjects';
+import EditProjectStatusService from './EditProjectStatus';
+import GetProjectBillableEntries from './GetProjectBillableEntries';
+
+@Service()
+export class ProjectsApplication {
+  @Inject()
+  private createProjectService: CreateProject;
+
+  @Inject()
+  private editProjectService: EditProjectService;
+
+  @Inject()
+  private deleteProjectService: DeleteProject;
+
+  @Inject()
+  private getProjectService: GetProject;
+
+  @Inject()
+  private getProjectsService: GetProjects;
+
+  @Inject()
+  private editProjectStatusService: EditProjectStatusService;
+
+  @Inject()
+  private getProjectBillable: GetProjectBillableEntries;
+
+  /**
+   * Creates a new project.
+   * @param {number} tenantId - Tenant id.
+   * @param {IProjectCreateDTO} projectDTO - Create project DTO.
+   * @return {Promise<IProjectCreatePOJO>}
+   */
+  public createProject = (
+    tenantId: number,
+    projectDTO: IProjectCreateDTO
+  ): Promise<IProjectCreatePOJO> => {
+    return this.createProjectService.createProject(tenantId, projectDTO);
+  };
+
+  /**
+   * Edits details of the given vendor.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} vendorId - Vendor id.
+   * @param {IProjectCreateDTO} projectDTO - Create project DTO.
+   * @returns {Promise<IVendor>}
+   */
+  public editProject = (
+    tenantId: number,
+    projectId: number,
+    projectDTO: IProjectCreateDTO
+  ): Promise<IProjectEditPOJO> => {
+    return this.editProjectService.editProject(tenantId, projectId, projectDTO);
+  };
+
+  /**
+   * Deletes the given project.
+   * @param {number} tenantId
+   * @param {number} vendorId
+   * @return {Promise<void>}
+   */
+  public deleteProject = (
+    tenantId: number,
+    projectId: number
+  ): Promise<void> => {
+    return this.deleteProjectService.deleteProject(tenantId, projectId);
+  };
+
+  /**
+   * Retrieves the vendor details.
+   * @param {number} tenantId
+   * @param {number} projectId
+   * @returns {Promise<IProjectGetPOJO>}
+   */
+  public getProject = (
+    tenantId: number,
+    projectId: number
+  ): Promise<IProjectGetPOJO> => {
+    return this.getProjectService.getProject(tenantId, projectId);
+  };
+
+  /**
+   * Retrieves the vendors paginated list.
+   * @param {number} tenantId
+   * @param {IVendorsFilter} filterDTO
+   * @returns {Promise<IProjectGetPOJO[]>}
+   */
+  public getProjects = (
+    tenantId: number,
+    filterDTO: IVendorsFilter
+  ): Promise<IProjectGetPOJO[]> => {
+    return this.getProjectsService.getProjects(tenantId);
+  };
+
+  /**
+   * Edits the given project status.
+   * @param {number} tenantId
+   * @param {number} projectId
+   * @param {IProjectStatus} status
+   * @returns {Promise<IProject>}
+   */
+  public editProjectStatus = (
+    tenantId: number,
+    projectId: number,
+    status: IProjectStatus
+  ) => {
+    return this.editProjectStatusService.editProjectStatus(
+      tenantId,
+      projectId,
+      status
+    );
+  };
+
+  /**
+   * Retrieves the billable entries of the given project.
+   * @param {number} tenantId
+   * @param {number} projectId
+   * @param {ProjectBillableEntriesQuery} query
+   * @returns {Promise<ProjectBillableEntry[]>}
+   */
+  public getProjectBillableEntries = (
+    tenantId: number,
+    projectId: number,
+    query?: ProjectBillableEntriesQuery
+  ): Promise<ProjectBillableEntry[]> => {
+    return this.getProjectBillable.getProjectBillableEntries(
+      tenantId,
+      projectId,
+      query
+    );
+  };
+}
diff --git a/packages/server/src/services/Projects/Projects/ProjectsValidator.ts b/packages/server/src/services/Projects/Projects/ProjectsValidator.ts
new file mode 100644
index 000000000..d3ba9b283
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/ProjectsValidator.ts
@@ -0,0 +1,23 @@
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+
+@Service()
+export class ProjectsValidator {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Validate contact exists.
+   * @param {number} tenantId
+   * @param {number} contactId
+   */
+  public async validateContactExists(tenantId: number, contactId: number) {
+    const { Contact } = this.tenancy.models(tenantId);
+
+    // Validate customer existance.
+    await Contact.query()
+      .modify('customer')
+      .findById(contactId)
+      .throwIfNotFound();
+  }
+}
diff --git a/packages/server/src/services/Projects/Projects/_types.ts b/packages/server/src/services/Projects/Projects/_types.ts
new file mode 100644
index 000000000..b3ba925f7
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/_types.ts
@@ -0,0 +1,22 @@
+import {
+  ProjectBillableEntriesQuery,
+  ProjectBillableEntry,
+  ProjectBillableType,
+} from '@/interfaces';
+import { Knex } from 'knex';
+
+export interface IncreaseInvoicedTaskQueuePayload {
+  tenantId: number;
+  projectRefId: number;
+  projectRefInvoicedAmount: number;
+  trx?: Knex.Transaction;
+}
+
+export interface ProjectBillableGetter {
+  type: ProjectBillableType;
+  getter: (
+    tenantId: number,
+    projectId: number,
+    query: ProjectBillableEntriesQuery
+  ) => Promise<ProjectBillableEntry[]>;
+}
diff --git a/packages/server/src/services/Projects/Projects/_utils.ts b/packages/server/src/services/Projects/Projects/_utils.ts
new file mode 100644
index 000000000..91e08efba
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/_utils.ts
@@ -0,0 +1,8 @@
+import { IItemEntry, IItemEntryDTO } from '@/interfaces';
+
+export const filterEntriesByRefType = (
+  entries: (IItemEntry | IItemEntryDTO)[],
+  projectRefType: string
+) => {
+  return entries.filter((entry) => entry.projectRefType === projectRefType);
+};
diff --git a/packages/server/src/services/Projects/Projects/constants.ts b/packages/server/src/services/Projects/Projects/constants.ts
new file mode 100644
index 000000000..3d1147d9d
--- /dev/null
+++ b/packages/server/src/services/Projects/Projects/constants.ts
@@ -0,0 +1,3 @@
+export enum ERRORS {
+  ITEM_ENTRIES_REF_IDS_NOT_FOUND = 'ITEM_ENTRIES_REF_IDS_NOT_FOUND',
+}
diff --git a/packages/server/src/services/Projects/Tasks/CreateTask.ts b/packages/server/src/services/Projects/Tasks/CreateTask.ts
new file mode 100644
index 000000000..2d28ea646
--- /dev/null
+++ b/packages/server/src/services/Projects/Tasks/CreateTask.ts
@@ -0,0 +1,74 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import {
+  ICreateTaskDTO,
+  IProjectTaskCreatePOJO,
+  ITaskCreatedEventPayload,
+  ITaskCreateEventPayload,
+  ITaskCreatingEventPayload,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+
+@Service()
+export class CreateTaskService {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Creates a new task.
+   * @param {number} tenantId -
+   * @param {number} projectId - Project id.
+   * @param {ICreateTaskDTO} taskDTO - Project's task DTO.
+   * @returns {Promise<IProjectTaskCreatePOJO>}
+   */
+  public createTask = async (
+    tenantId: number,
+    projectId: number,
+    taskDTO: ICreateTaskDTO
+  ): Promise<IProjectTaskCreatePOJO> => {
+    const { Task, Project } = this.tenancy.models(tenantId);
+
+    // Validate project existance.
+    const project = await Project.query().findById(projectId).throwIfNotFound();
+
+    // Triggers `onProjectTaskCreate` event.
+    await this.eventPublisher.emitAsync(events.projectTask.onCreate, {
+      tenantId,
+      taskDTO,
+    } as ITaskCreateEventPayload);
+
+    // Creates a new project under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onProjectTaskCreating` event.
+      await this.eventPublisher.emitAsync(events.projectTask.onCreating, {
+        tenantId,
+        taskDTO,
+        trx,
+      } as ITaskCreatingEventPayload);
+
+      const task = await Task.query().insert({
+        ...taskDTO,
+        actualHours: 0,
+        projectId,
+      });
+      // Triggers `onProjectTaskCreated` event.
+      await this.eventPublisher.emitAsync(events.projectTask.onCreated, {
+        tenantId,
+        taskDTO,
+        task,
+        trx,
+      } as ITaskCreatedEventPayload);
+
+      return task;
+    });
+  };
+}
diff --git a/packages/server/src/services/Projects/Tasks/DeleteTask.ts b/packages/server/src/services/Projects/Tasks/DeleteTask.ts
new file mode 100644
index 000000000..44f665038
--- /dev/null
+++ b/packages/server/src/services/Projects/Tasks/DeleteTask.ts
@@ -0,0 +1,64 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import {
+  ITaskDeletedEventPayload,
+  ITaskDeleteEventPayload,
+  ITaskDeletingEventPayload,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+
+@Service()
+export class DeleteTaskService {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Deletes the give project.
+   * @param   {number} projectId -
+   * @returns {Promise<void>}
+   */
+  public deleteTask = async (
+    tenantId: number,
+    taskId: number
+  ): Promise<void> => {
+    const { Task } = this.tenancy.models(tenantId);
+
+    // Validate customer existance.
+    const oldTask = await Task.query().findById(taskId).throwIfNotFound();
+
+    // Triggers `onDeleteProjectTask` event.
+    await this.eventPublisher.emitAsync(events.projectTask.onDelete, {
+      tenantId,
+      taskId,
+    } as ITaskDeleteEventPayload);
+
+    // Deletes the given project under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onProjectDeleting` event.
+      await this.eventPublisher.emitAsync(events.projectTask.onDeleting, {
+        tenantId,
+        oldTask,
+        trx,
+      } as ITaskDeletingEventPayload);
+
+      // Deletes the project object from the storage.
+      await Task.query(trx).findById(taskId).delete();
+
+      // Triggers `onProjectDeleted` event.
+      await this.eventPublisher.emitAsync(events.projectTask.onDeleted, {
+        tenantId,
+        oldTask,
+        trx,
+      } as ITaskDeletedEventPayload);
+    });
+  };
+}
diff --git a/packages/server/src/services/Projects/Tasks/EditTask.ts b/packages/server/src/services/Projects/Tasks/EditTask.ts
new file mode 100644
index 000000000..3c1f0eba3
--- /dev/null
+++ b/packages/server/src/services/Projects/Tasks/EditTask.ts
@@ -0,0 +1,77 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import {
+  IEditTaskDTO,
+  IProjectTaskEditPOJO,
+  ITaskEditedEventPayload,
+  ITaskEditEventPayload,
+  ITaskEditingEventPayload,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+
+@Service()
+export class EditTaskService {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Edits a new credit note.
+   * @param {number} tenantId -
+   * @param {number} taskId -
+   * @param {IEditTaskDTO} taskDTO -
+   * @returns {IProjectTaskEditPOJO}
+   */
+  public editTask = async (
+    tenantId: number,
+    taskId: number,
+    taskDTO: IEditTaskDTO
+  ): Promise<IProjectTaskEditPOJO> => {
+    const { Task } = this.tenancy.models(tenantId);
+
+    // Validate task existance.
+    const oldTask = await Task.query().findById(taskId).throwIfNotFound();
+
+    // Triggers `onProjectTaskEdit` event.
+    await this.eventPublisher.emitAsync(events.projectTask.onEdit, {
+      tenantId,
+      taskId,
+      taskDTO,
+    } as ITaskEditEventPayload);
+
+    // Edits the given project under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onProjectTaskEditing` event.
+      await this.eventPublisher.emitAsync(events.projectTask.onEditing, {
+        tenantId,
+        oldTask,
+        taskDTO,
+        trx,
+      } as ITaskEditingEventPayload);
+
+      // Upsert the project's task object.
+      const task = await Task.query(trx).upsertGraph({
+        id: taskId,
+        ...taskDTO,
+      });
+      // Triggers `onProjectTaskEdited` event.
+      await this.eventPublisher.emitAsync(events.projectTask.onEdited, {
+        tenantId,
+        oldTask,
+        taskDTO,
+        task,
+        trx,
+      } as ITaskEditedEventPayload);
+
+      return task;
+    });
+  };
+}
diff --git a/packages/server/src/services/Projects/Tasks/GetTask.ts b/packages/server/src/services/Projects/Tasks/GetTask.ts
new file mode 100644
index 000000000..4fe4bb9cb
--- /dev/null
+++ b/packages/server/src/services/Projects/Tasks/GetTask.ts
@@ -0,0 +1,33 @@
+import { IProjectTaskGetPOJO } from '@/interfaces';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+import { TaskTransformer } from './TaskTransformer';
+
+@Service()
+export class GetTaskService {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the tasks list.
+   * @param {number} tenantId - Tenant Id.
+   * @param {number} taskId - Task Id.
+   * @returns {Promise<IProjectTaskGetPOJO>}
+   */
+  public getTask = async (
+    tenantId: number,
+    taskId: number
+  ): Promise<IProjectTaskGetPOJO> => {
+    const { Task } = this.tenancy.models(tenantId);
+
+    // Retrieve the project.
+    const task = await Task.query().findById(taskId).throwIfNotFound();
+
+    // Transformes and returns object.
+    return this.transformer.transform(tenantId, task, new TaskTransformer());
+  };
+}
diff --git a/packages/server/src/services/Projects/Tasks/GetTasks.ts b/packages/server/src/services/Projects/Tasks/GetTasks.ts
new file mode 100644
index 000000000..0bd46c78e
--- /dev/null
+++ b/packages/server/src/services/Projects/Tasks/GetTasks.ts
@@ -0,0 +1,33 @@
+import { IProjectTaskGetPOJO } from '@/interfaces';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+import { TaskTransformer } from './TaskTransformer';
+
+@Service()
+export class GetTasksService {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the tasks list.
+   * @param   {number} tenantId - Tenant Id.
+   * @param   {number} taskId - Task Id.
+   * @returns {}
+   */
+  public getTasks = async (
+    tenantId: number,
+    projectId: number
+  ): Promise<IProjectTaskGetPOJO[]> => {
+    const { Task } = this.tenancy.models(tenantId);
+
+    // Retrieve the project.
+    const tasks = await Task.query().where('projectId', projectId);
+
+    // Transformes and returns object.
+    return this.transformer.transform(tenantId, tasks, new TaskTransformer());
+  };
+}
diff --git a/packages/server/src/services/Projects/Tasks/TaskTransformer.ts b/packages/server/src/services/Projects/Tasks/TaskTransformer.ts
new file mode 100644
index 000000000..116be783a
--- /dev/null
+++ b/packages/server/src/services/Projects/Tasks/TaskTransformer.ts
@@ -0,0 +1,49 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatMinutes } from 'utils/formatMinutes';
+
+export class TaskTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'estimateHoursFormatted',
+      'actualHoursFormatted',
+      'invoicedHoursFormatted',
+      'billableHoursFormatted',
+    ];
+  };
+
+  /**
+   * Retrieves the formatted estimate hours.
+   * @returns {string}
+   */
+  public estimateHoursFormatted = (task): string => {
+    return formatMinutes(task.estimateHours);
+  };
+
+  /**
+   * Retrieves the formatted actual hours.
+   * @returns {string}
+   */
+  public actualHoursFormatted = (task): string => {
+    return formatMinutes(task.actualHours);
+  };
+
+  /**
+   * Retrieves the formatted billable hours.
+   * @returns {string}
+   */
+  public billableHoursFormatted = (task): string => {
+    return formatMinutes(task.billableHours);
+  };
+
+  /**
+   * Retreives the formatted invoiced hours.
+   * @returns {string}
+   */
+  public invoicedHoursFormatted = (task): string => {
+    return formatMinutes(task.invoicedHours);
+  };
+}
diff --git a/packages/server/src/services/Projects/Tasks/TasksApplication.ts b/packages/server/src/services/Projects/Tasks/TasksApplication.ts
new file mode 100644
index 000000000..3260d4054
--- /dev/null
+++ b/packages/server/src/services/Projects/Tasks/TasksApplication.ts
@@ -0,0 +1,97 @@
+import { Inject, Service } from 'typedi';
+import {
+  ICreateTaskDTO,
+  IEditTaskDTO,
+  IProjectTaskCreatePOJO,
+  IProjectTaskEditPOJO,
+  IProjectTaskGetPOJO,
+} from '@/interfaces';
+import { CreateTaskService } from './CreateTask';
+import { DeleteTaskService } from './DeleteTask';
+import { GetTaskService } from './GetTask';
+import { EditTaskService } from './EditTask';
+import { GetTasksService } from './GetTasks';
+
+@Service()
+export class TasksApplication {
+  @Inject()
+  private createTaskService: CreateTaskService;
+
+  @Inject()
+  private editTaskService: EditTaskService;
+
+  @Inject()
+  private deleteTaskService: DeleteTaskService;
+
+  @Inject()
+  private getTaskService: GetTaskService;
+
+  @Inject()
+  private getTasksService: GetTasksService;
+
+  /**
+   * Creates a new task associated to specific project.
+   * @param  {number} tenantId - Tenant id.
+   * @param  {number} project - Project id.
+   * @param  {ICreateTaskDTO} taskDTO - Create project DTO.
+   * @return {Promise<IProjectTaskCreatePOJO>}
+   */
+  public createTask = (
+    tenantId: number,
+    projectId: number,
+    taskDTO: ICreateTaskDTO
+  ): Promise<IProjectTaskCreatePOJO> => {
+    return this.createTaskService.createTask(tenantId, projectId, taskDTO);
+  };
+
+  /**
+   * Edits details of the given task.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} vendorId - Vendor id.
+   * @param {IEditTaskDTO} projectDTO - Create project DTO.
+   * @returns {Promise<IProjectTaskEditPOJO>}
+   */
+  public editTask = (
+    tenantId: number,
+    taskId: number,
+    taskDTO: IEditTaskDTO
+  ): Promise<IProjectTaskEditPOJO> => {
+    return this.editTaskService.editTask(tenantId, taskId, taskDTO);
+  };
+
+  /**
+   * Deletes the given task.
+   * @param  {number} tenantId
+   * @param  {number} taskId - Task id.
+   * @return {Promise<void>}
+   */
+  public deleteTask = (tenantId: number, taskId: number): Promise<void> => {
+    return this.deleteTaskService.deleteTask(tenantId, taskId);
+  };
+
+  /**
+   * Retrieves the given task details.
+   * @param {number} tenantId
+   * @param {number} taskId
+   * @returns {Promise<IProjectTaskGetPOJO>}
+   */
+  public getTask = (
+    tenantId: number,
+    taskId: number
+  ): Promise<IProjectTaskGetPOJO> => {
+    return this.getTaskService.getTask(tenantId, taskId);
+  };
+
+  /**
+   * Retrieves the vendors paginated list.
+   * @param {number} tenantId
+   * @param {IVendorsFilter} filterDTO
+   * @returns {Promise<IProjectTaskGetPOJO[]>}
+   */
+  public getTasks = (
+    tenantId: number,
+    projectId: number
+  ): Promise<IProjectTaskGetPOJO[]> => {
+    return this.getTasksService.getTasks(tenantId, projectId);
+  };
+}
diff --git a/packages/server/src/services/Projects/Tasks/constants.ts b/packages/server/src/services/Projects/Tasks/constants.ts
new file mode 100644
index 000000000..5f7cb0008
--- /dev/null
+++ b/packages/server/src/services/Projects/Tasks/constants.ts
@@ -0,0 +1,5 @@
+export enum ProjectTaskChargeType {
+  Fixed = 'FIXED',
+  Time = 'TIME',
+  NonChargable = 'NON_CHARGABLE',
+}
diff --git a/packages/server/src/services/Projects/Times/CreateTime.ts b/packages/server/src/services/Projects/Times/CreateTime.ts
new file mode 100644
index 000000000..ed3a10340
--- /dev/null
+++ b/packages/server/src/services/Projects/Times/CreateTime.ts
@@ -0,0 +1,72 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import {
+  IProjectTimeCreatedEventPayload,
+  IProjectTimeCreateDTO,
+  IProjectTimeCreateEventPayload,
+  IProjectTimeCreatePOJO,
+  IProjectTimeCreatingEventPayload,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+
+@Service()
+export class CreateTimeService {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Creates a new time.
+   * @param {number} taskId -
+   * @param {IProjectTimeCreateDTO} timeDTO -
+   * @returns {Promise<IProjectTimeCreatePOJO>}
+   */
+  public createTime = async (
+    tenantId: number,
+    taskId: number,
+    timeDTO: IProjectTimeCreateDTO
+  ): Promise<IProjectTimeCreatePOJO> => {
+    const { Time, Task } = this.tenancy.models(tenantId);
+
+    const task = await Task.query().findById(taskId).throwIfNotFound();
+
+    // Triggers `onProjectTimeCreate` event.
+    await this.eventPublisher.emitAsync(events.projectTime.onCreate, {
+      tenantId,
+      timeDTO,
+    } as IProjectTimeCreateEventPayload);
+
+    // Creates a new project under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onProjectTimeCreating` event.
+      await this.eventPublisher.emitAsync(events.projectTime.onCreating, {
+        tenantId,
+        timeDTO,
+        trx,
+      } as IProjectTimeCreatingEventPayload);
+
+      const time = await Time.query().insert({
+        ...timeDTO,
+        taskId,
+        projectId: task.projectId,
+      });
+
+      // Triggers `onProjectTimeCreated` event.
+      await this.eventPublisher.emitAsync(events.projectTime.onCreated, {
+        tenantId,
+        time,
+        trx,
+      } as IProjectTimeCreatedEventPayload);
+
+      return time;
+    });
+  };
+}
diff --git a/packages/server/src/services/Projects/Times/DeleteTime.ts b/packages/server/src/services/Projects/Times/DeleteTime.ts
new file mode 100644
index 000000000..91026133f
--- /dev/null
+++ b/packages/server/src/services/Projects/Times/DeleteTime.ts
@@ -0,0 +1,61 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import {
+  IProjectTimeDeletedEventPayload,
+  IProjectTimeDeleteEventPayload,
+  IProjectTimeDeletingEventPayload,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+
+@Service()
+export class DeleteTimeService {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Deletes the give task's time that associated to the given project.
+   * @param   {number} projectId -
+   * @returns {Promise<void>}
+   */
+  public deleteTime = async (tenantId: number, timeId: number) => {
+    const { Time } = this.tenancy.models(tenantId);
+
+    // Validate customer existance.
+    const oldTime = await Time.query().findById(timeId).throwIfNotFound();
+
+    // Triggers `onProjectDelete` event.
+    await this.eventPublisher.emitAsync(events.projectTime.onDelete, {
+      tenantId,
+      timeId,
+    } as IProjectTimeDeleteEventPayload);
+
+    // Deletes the given project under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onProjectDeleting` event.
+      await this.eventPublisher.emitAsync(events.projectTime.onDeleting, {
+        tenantId,
+        oldTime,
+        trx,
+      } as IProjectTimeDeletingEventPayload);
+
+      // Upsert the project object.
+      await Time.query(trx).findById(timeId).delete();
+
+      // Triggers `onProjectDeleted` event.
+      await this.eventPublisher.emitAsync(events.projectTime.onDeleted, {
+        tenantId,
+        oldTime,
+        trx,
+      } as IProjectTimeDeletedEventPayload);
+    });
+  };
+}
diff --git a/packages/server/src/services/Projects/Times/EditTime.ts b/packages/server/src/services/Projects/Times/EditTime.ts
new file mode 100644
index 000000000..06d93ab14
--- /dev/null
+++ b/packages/server/src/services/Projects/Times/EditTime.ts
@@ -0,0 +1,76 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import {
+  IProjectTimeEditDTO,
+  IProjectTimeEditedEventPayload,
+  IProjectTimeEditEventPayload,
+  IProjectTimeEditingEventPayload,
+  IProjectTimeEditPOJO,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+
+@Service()
+export class EditTimeService {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Edits the given project's time that associated to the given task.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} taskId - Task id.
+   * @returns {Promise<IProjectTimeEditPOJO>}
+   */
+  public editTime = async (
+    tenantId: number,
+    timeId: number,
+    timeDTO: IProjectTimeEditDTO
+  ): Promise<IProjectTimeEditPOJO> => {
+    const { Time } = this.tenancy.models(tenantId);
+
+    // Validate customer existance.
+    const oldTime = await Time.query().findById(timeId).throwIfNotFound();
+
+    // Triggers `onProjectEdit` event.
+    await this.eventPublisher.emitAsync(events.projectTime.onEdit, {
+      tenantId,
+      oldTime,
+      timeDTO,
+    } as IProjectTimeEditEventPayload);
+
+    // Edits the given project under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onProjectEditing` event.
+      await this.eventPublisher.emitAsync(events.projectTime.onEditing, {
+        tenantId,
+        timeDTO,
+        oldTime,
+        trx,
+      } as IProjectTimeEditingEventPayload);
+
+      // Upsert the task's time object.
+      const time = await Time.query(trx).upsertGraphAndFetch({
+        id: timeId,
+        ...timeDTO,
+      });
+      // Triggers `onProjectEdited` event.
+      await this.eventPublisher.emitAsync(events.projectTime.onEdited, {
+        tenantId,
+        oldTime,
+        timeDTO,
+        time,
+        trx,
+      } as IProjectTimeEditedEventPayload);
+
+      return time;
+    });
+  };
+}
diff --git a/packages/server/src/services/Projects/Times/GetTime.ts b/packages/server/src/services/Projects/Times/GetTime.ts
new file mode 100644
index 000000000..5b0603fee
--- /dev/null
+++ b/packages/server/src/services/Projects/Times/GetTime.ts
@@ -0,0 +1,37 @@
+import { IProjectTimeGetPOJO } from '@/interfaces';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+import { TimeTransformer } from './TimeTransformer';
+
+@Service()
+export class GetTimeService {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the tasks list.
+   * @param {number} tenantId - Tenant Id.
+   * @param {number} taskId - Task Id.
+   * @returns {Promise<IProjectTimeGetPOJO>}
+   */
+  public getTime = async (
+    tenantId: number,
+    timeId: number
+  ): Promise<IProjectTimeGetPOJO> => {
+    const { Time } = this.tenancy.models(tenantId);
+
+    // Retrieve the project.
+    const time = await Time.query()
+      .findById(timeId)
+      .withGraphFetched('project.contact')
+      .withGraphFetched('task')
+      .throwIfNotFound();
+
+    // Transformes and returns object.
+    return this.transformer.transform(tenantId, time, new TimeTransformer());
+  };
+}
diff --git a/packages/server/src/services/Projects/Times/GetTimes.ts b/packages/server/src/services/Projects/Times/GetTimes.ts
new file mode 100644
index 000000000..c8adeec6e
--- /dev/null
+++ b/packages/server/src/services/Projects/Times/GetTimes.ts
@@ -0,0 +1,36 @@
+import { Inject, Service } from 'typedi';
+import { IProjectTimeGetPOJO } from '@/interfaces';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { TimeTransformer } from './TimeTransformer';
+
+@Service()
+export class GetTimelineService {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the tasks list.
+   * @param {number} tenantId - Tenant Id.
+   * @param {number} taskId - Task Id.
+   * @returns {Promise<IProjectTimeGetPOJO[]>}
+   */
+  public getTimeline = async (
+    tenantId: number,
+    projectId: number
+  ): Promise<IProjectTimeGetPOJO[]> => {
+    const { Time } = this.tenancy.models(tenantId);
+
+    // Retrieve the project.
+    const times = await Time.query()
+      .where('projectId', projectId)
+      .withGraphFetched('project.contact')
+      .withGraphFetched('task');
+
+    // Transformes and returns object.
+    return this.transformer.transform(tenantId, times, new TimeTransformer());
+  };
+}
diff --git a/packages/server/src/services/Projects/Times/SyncActualTimeTask.ts b/packages/server/src/services/Projects/Times/SyncActualTimeTask.ts
new file mode 100644
index 000000000..1afe9e5d3
--- /dev/null
+++ b/packages/server/src/services/Projects/Times/SyncActualTimeTask.ts
@@ -0,0 +1,49 @@
+import { Knex } from 'knex';
+import { Inject, Service } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class SyncActualTimeTask {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Increases the actual time of the given task.
+   * @param {number} tenantId
+   * @param {number} taskId
+   * @param {number} actualHours
+   * @param {Knex.Transaction} trx
+   */
+  public increaseActualTimeTask = async (
+    tenantId: number,
+    taskId: number,
+    actualHours: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { Task } = this.tenancy.models(tenantId);
+
+    await Task.query(trx)
+      .findById(taskId)
+      .increment('actualHours', actualHours);
+  };
+
+  /**
+   * Decreases the actual time of the given task.
+   * @param {number} tenantId
+   * @param {number} taskId
+   * @param {number} actualHours
+   * @param {Knex.Transaction} trx
+   */
+  public decreaseActualTimeTask = async (
+    tenantId: number,
+    taskId: number,
+    actualHours: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { Task } = this.tenancy.models(tenantId);
+
+    await Task.query(trx)
+      .findById(taskId)
+      .decrement('actualHours', actualHours);
+  };
+}
diff --git a/packages/server/src/services/Projects/Times/SyncActualTimeTaskSubscriber.ts b/packages/server/src/services/Projects/Times/SyncActualTimeTaskSubscriber.ts
new file mode 100644
index 000000000..45f64f52c
--- /dev/null
+++ b/packages/server/src/services/Projects/Times/SyncActualTimeTaskSubscriber.ts
@@ -0,0 +1,91 @@
+import { Inject, Service } from 'typedi';
+import {
+  IProjectTimeCreatedEventPayload,
+  IProjectTimeDeletedEventPayload,
+  IProjectTimeEditedEventPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import { SyncActualTimeTask } from './SyncActualTimeTask';
+
+@Service()
+export class SyncActualTimeTaskSubscriber {
+  @Inject()
+  private syncActualTimeTask: SyncActualTimeTask;
+
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.projectTime.onCreated,
+      this.handleIncreaseActualTimeOnTimeCreate
+    );
+    bus.subscribe(
+      events.projectTime.onDeleted,
+      this.handleDecreaseActaulTimeOnTimeDelete
+    );
+    bus.subscribe(
+      events.projectTime.onEdited,
+      this.handleAdjustActualTimeOnTimeEdited
+    );
+  }
+
+  /**
+   * Handles increasing the actual time of the task once time entry be created.
+   * @param {IProjectTimeCreatedEventPayload} payload -
+   */
+  private handleIncreaseActualTimeOnTimeCreate = async ({
+    tenantId,
+    time,
+    trx,
+  }: IProjectTimeCreatedEventPayload) => {
+    await this.syncActualTimeTask.increaseActualTimeTask(
+      tenantId,
+      time.taskId,
+      time.duration,
+      trx
+    );
+  };
+
+  /**
+   * Handle decreasing the actual time of the tsak once time entry be deleted.
+   * @param {IProjectTimeDeletedEventPayload} payload
+   */
+  private handleDecreaseActaulTimeOnTimeDelete = async ({
+    tenantId,
+    oldTime,
+    trx,
+  }: IProjectTimeDeletedEventPayload) => {
+    await this.syncActualTimeTask.decreaseActualTimeTask(
+      tenantId,
+      oldTime.taskId,
+      oldTime.duration,
+      trx
+    );
+  };
+
+  /**
+   * Handle adjusting the actual time of the task once time be edited.
+   * @param {IProjectTimeEditedEventPayload} payload -
+   */
+  private handleAdjustActualTimeOnTimeEdited = async ({
+    tenantId,
+    time,
+    oldTime,
+    trx,
+  }: IProjectTimeEditedEventPayload) => {
+    await this.syncActualTimeTask.decreaseActualTimeTask(
+      tenantId,
+      oldTime.taskId,
+      oldTime.duration,
+      trx
+    );
+    await this.syncActualTimeTask.increaseActualTimeTask(
+      tenantId,
+      time.taskId,
+      time.duration,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Projects/Times/TimeTransformer.ts b/packages/server/src/services/Projects/Times/TimeTransformer.ts
new file mode 100644
index 000000000..e18bd74ca
--- /dev/null
+++ b/packages/server/src/services/Projects/Times/TimeTransformer.ts
@@ -0,0 +1,57 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import Time from 'models/Time';
+import { formatMinutes } from 'utils/formatMinutes';
+
+export class TimeTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return ['projectName', 'taskName', 'customerName', 'durationFormatted'];
+  };
+
+  /**
+   * Exclude attributes.
+   * @returns {string[]}
+   */
+  public excludeAttributes = (): string[] => {
+    return ['project', 'task'];
+  };
+
+  /**
+   * Retrieves the project name that associated to the time entry.
+   * @param {Time} time
+   * @returns {string}
+   */
+  public projectName = (time: Time) => {
+    return time.project.name;
+  };
+
+  /**
+   * Retrieves the task name that associated to the time entry.
+   * @param {Time} time
+   * @returns {string}
+   */
+  public taskName = (time: Time) => {
+    return time.task.name;
+  };
+
+  /**
+   * Retrieves the customer name that associated to the task of the time entry.
+   * @param {Time} time
+   * @returns {string}
+   */
+  public customerName = (time: Time) => {
+    return time?.project?.contact?.displayName;
+  };
+
+  /**
+   * Retrieves the formatted duration.
+   * @param {Time} time 
+   * @returns {string}
+   */
+  public durationFormatted = (time: Time) => {
+    return formatMinutes(time.duration);
+  }
+}
diff --git a/packages/server/src/services/Projects/Times/TimesApplication.ts b/packages/server/src/services/Projects/Times/TimesApplication.ts
new file mode 100644
index 000000000..872fc79fb
--- /dev/null
+++ b/packages/server/src/services/Projects/Times/TimesApplication.ts
@@ -0,0 +1,96 @@
+import { Inject, Service } from 'typedi';
+import { CreateTimeService } from './CreateTime';
+import { EditTimeService } from './EditTime';
+import { GetTimelineService } from './GetTimes';
+import { GetTimeService } from './GetTime';
+import { DeleteTimeService } from './DeleteTime';
+import {
+  IProjectTimeCreateDTO,
+  IProjectTimeCreatePOJO,
+  IProjectTimeEditDTO,
+  IProjectTimeEditPOJO,
+  IProjectTimeGetPOJO,
+} from '@/interfaces';
+
+@Service()
+export class TimesApplication {
+  @Inject()
+  private createTimeService: CreateTimeService;
+
+  @Inject()
+  private editTimeService: EditTimeService;
+
+  @Inject()
+  private deleteTimeService: DeleteTimeService;
+
+  @Inject()
+  private getTimeService: GetTimeService;
+
+  @Inject()
+  private getTimelineService: GetTimelineService;
+
+  /**
+   * Creates a new time for specific project's task.
+   * @param  {number} tenantId - Tenant id.
+   * @param  {IProjectTimeCreateDTO} timeDTO - Create project's time DTO.
+   * @return {Promise<IProjectTimeCreatePOJO>}
+   */
+  public createTime = (
+    tenantId: number,
+    taskId: number,
+    timeDTO: IProjectTimeCreateDTO
+  ): Promise<IProjectTimeCreatePOJO> => {
+    return this.createTimeService.createTime(tenantId, taskId, timeDTO);
+  };
+
+  /**
+   * Edits details of the given task.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} vendorId - Vendor id.
+   * @param {IProjectCreateDTO} projectDTO - Create project DTO.
+   * @returns {Promise<IProjectTimeEditPOJO>}
+   */
+  public editTime = (
+    tenantId: number,
+    timeId: number,
+    taskDTO: IProjectTimeEditDTO
+  ): Promise<IProjectTimeEditPOJO> => {
+    return this.editTimeService.editTime(tenantId, timeId, taskDTO);
+  };
+
+  /**
+   * Deletes the given task.
+   * @param {number} tenantId
+   * @param {number} taskId
+   * @return {Promise<void>}
+   */
+  public deleteTime = (tenantId: number, timeId: number): Promise<void> => {
+    return this.deleteTimeService.deleteTime(tenantId, timeId);
+  };
+
+  /**
+   * Retrieves the given task details.
+   * @param {number} tenantId
+   * @param {number} timeId
+   * @returns {Promise<IProjectTimeGetPOJO>}
+   */
+  public getTime = (
+    tenantId: number,
+    timeId: number
+  ): Promise<IProjectTimeGetPOJO> => {
+    return this.getTimeService.getTime(tenantId, timeId);
+  };
+
+  /**
+   * Retrieves the vendors paginated list.
+   * @param {number} tenantId
+   * @param {IVendorsFilter} filterDTO
+   * @returns {Promise<IProjectTimeGetPOJO[]>}
+   */
+  public getTimeline = (
+    tenantId: number,
+    projectId: number
+  ): Promise<IProjectTimeGetPOJO[]> => {
+    return this.getTimelineService.getTimeline(tenantId, projectId);
+  };
+}
diff --git a/packages/server/src/services/Purchases/BillPayments/BillPaymentGLEntries.ts b/packages/server/src/services/Purchases/BillPayments/BillPaymentGLEntries.ts
new file mode 100644
index 000000000..f2118929e
--- /dev/null
+++ b/packages/server/src/services/Purchases/BillPayments/BillPaymentGLEntries.ts
@@ -0,0 +1,277 @@
+import moment from 'moment';
+import { sumBy } from 'lodash';
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import { AccountNormal, IBillPayment, ILedgerEntry } from '@/interfaces';
+import Ledger from '@/services/Accounting/Ledger';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { TenantMetadata } from '@/system/models';
+
+@Service()
+export class BillPaymentGLEntries {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private ledgerStorage: LedgerStorageService;
+
+  /**
+   * Creates a bill payment GL entries.
+   * @param {number} tenantId
+   * @param {number} billPaymentId
+   * @param {Knex.Transaction} trx
+   */
+  public writePaymentGLEntries = async (
+    tenantId: number,
+    billPaymentId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+    const { BillPayment, Account } = this.tenancy.models(tenantId);
+
+    // Retrieves the bill payment details with associated entries.
+    const payment = await BillPayment.query(trx)
+      .findById(billPaymentId)
+      .withGraphFetched('entries.bill');
+
+    // Retrieves the given tenant metadata.
+    const tenantMeta = await TenantMetadata.query().findOne({ tenantId });
+
+    // Finds or creates a new A/P account of the given currency.
+    const APAccount = await accountRepository.findOrCreateAccountsPayable(
+      payment.currencyCode,
+      {},
+      trx
+    );
+    // Exchange gain or loss account.
+    const EXGainLossAccount = await Account.query(trx).modify(
+      'findBySlug',
+      'exchange-grain-loss'
+    );
+    // Retrieves the bill payment ledger.
+    const ledger = this.getBillPaymentLedger(
+      payment,
+      APAccount.id,
+      EXGainLossAccount.id,
+      tenantMeta.baseCurrency
+    );
+    // Commits the ledger on the storage.
+    await this.ledgerStorage.commit(tenantId, ledger, trx);
+  };
+
+  /**
+   * Rewrites the bill payment GL entries.
+   * @param {number} tenantId
+   * @param {number} billPaymentId
+   * @param {Knex.Transaction} trx
+   */
+  public rewritePaymentGLEntries = async (
+    tenantId: number,
+    billPaymentId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    // Revert payment GL entries.
+    await this.revertPaymentGLEntries(tenantId, billPaymentId, trx);
+
+    // Write payment GL entries.
+    await this.writePaymentGLEntries(tenantId, billPaymentId, trx);
+  };
+
+  /**
+   * Reverts the bill payment GL entries.
+   * @param {number} tenantId
+   * @param {number} billPaymentId
+   * @param {Knex.Transaction} trx
+   */
+  public revertPaymentGLEntries = async (
+    tenantId: number,
+    billPaymentId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    await this.ledgerStorage.deleteByReference(
+      tenantId,
+      billPaymentId,
+      'BillPayment',
+      trx
+    );
+  };
+
+  /**
+   * Retrieves the payment common entry.
+   * @param   {IBillPayment} billPayment
+   * @returns {}
+   */
+  private getPaymentCommonEntry = (billPayment: IBillPayment) => {
+    const formattedDate = moment(billPayment.paymentDate).format('YYYY-MM-DD');
+
+    return {
+      debit: 0,
+      credit: 0,
+
+      exchangeRate: billPayment.exchangeRate,
+      currencyCode: billPayment.currencyCode,
+
+      transactionId: billPayment.id,
+      transactionType: 'BillPayment',
+
+      transactionNumber: billPayment.paymentNumber,
+      referenceNumber: billPayment.reference,
+
+      date: formattedDate,
+      createdAt: billPayment.createdAt,
+
+      branchId: billPayment.branchId,
+    };
+  };
+
+  /**
+   * Calculates the payment total exchange gain/loss.
+   * @param   {IBillPayment} paymentReceive - Payment receive with entries.
+   * @returns {number}
+   */
+  private getPaymentExGainOrLoss = (billPayment: IBillPayment): number => {
+    return sumBy(billPayment.entries, (entry) => {
+      const paymentLocalAmount = entry.paymentAmount * billPayment.exchangeRate;
+      const invoicePayment = entry.paymentAmount * entry.bill.exchangeRate;
+
+      return invoicePayment - paymentLocalAmount;
+    });
+  };
+
+  /**
+   * Retrieves the payment exchange gain/loss entries.
+   * @param   {IBillPayment} billPayment -
+   * @param   {number} APAccountId -
+   * @param   {number} gainLossAccountId -
+   * @param   {string} baseCurrency -
+   * @returns {ILedgerEntry[]}
+   */
+  private getPaymentExGainOrLossEntries = (
+    billPayment: IBillPayment,
+    APAccountId: number,
+    gainLossAccountId: number,
+    baseCurrency: string
+  ): ILedgerEntry[] => {
+    const commonEntry = this.getPaymentCommonEntry(billPayment);
+    const totalExGainOrLoss = this.getPaymentExGainOrLoss(billPayment);
+    const absExGainOrLoss = Math.abs(totalExGainOrLoss);
+
+    return totalExGainOrLoss
+      ? [
+          {
+            ...commonEntry,
+            currencyCode: baseCurrency,
+            exchangeRate: 1,
+            credit: totalExGainOrLoss > 0 ? absExGainOrLoss : 0,
+            debit: totalExGainOrLoss < 0 ? absExGainOrLoss : 0,
+            accountId: gainLossAccountId,
+            index: 2,
+            indexGroup: 20,
+            accountNormal: AccountNormal.DEBIT,
+          },
+          {
+            ...commonEntry,
+            currencyCode: baseCurrency,
+            exchangeRate: 1,
+            debit: totalExGainOrLoss > 0 ? absExGainOrLoss : 0,
+            credit: totalExGainOrLoss < 0 ? absExGainOrLoss : 0,
+            accountId: APAccountId,
+            index: 3,
+            accountNormal: AccountNormal.DEBIT,
+          },
+        ]
+      : [];
+  };
+
+  /**
+   * Retrieves the payment deposit GL entry.
+   * @param   {IBillPayment} billPayment
+   * @returns {ILedgerEntry}
+   */
+  private getPaymentGLEntry = (billPayment: IBillPayment): ILedgerEntry => {
+    const commonEntry = this.getPaymentCommonEntry(billPayment);
+
+    return {
+      ...commonEntry,
+      credit: billPayment.localAmount,
+      accountId: billPayment.paymentAccountId,
+      accountNormal: AccountNormal.DEBIT,
+      index: 2,
+    };
+  };
+
+  /**
+   * Retrieves the payment GL payable entry.
+   * @param   {IBillPayment} billPayment
+   * @param   {number} APAccountId
+   * @returns {ILedgerEntry}
+   */
+  private getPaymentGLPayableEntry = (
+    billPayment: IBillPayment,
+    APAccountId: number
+  ): ILedgerEntry => {
+    const commonEntry = this.getPaymentCommonEntry(billPayment);
+
+    return {
+      ...commonEntry,
+      exchangeRate: billPayment.exchangeRate,
+      debit: billPayment.localAmount,
+      contactId: billPayment.vendorId,
+      accountId: APAccountId,
+      accountNormal: AccountNormal.CREDIT,
+      index: 1,
+    };
+  };
+
+  /**
+   * Retrieves the payment GL entries.
+   * @param   {IBillPayment} billPayment
+   * @param   {number} APAccountId
+   * @returns {ILedgerEntry[]}
+   */
+  private getPaymentGLEntries = (
+    billPayment: IBillPayment,
+    APAccountId: number,
+    gainLossAccountId: number,
+    baseCurrency: string
+  ): ILedgerEntry[] => {
+    // Retrieves the payment deposit entry.
+    const paymentEntry = this.getPaymentGLEntry(billPayment);
+
+    // Retrieves the payment debit A/R entry.
+    const payableEntry = this.getPaymentGLPayableEntry(
+      billPayment,
+      APAccountId
+    );
+    // Retrieves the exchange gain/loss entries.
+    const exGainLossEntries = this.getPaymentExGainOrLossEntries(
+      billPayment,
+      APAccountId,
+      gainLossAccountId,
+      baseCurrency
+    );
+    return [paymentEntry, payableEntry, ...exGainLossEntries];
+  };
+
+  /**
+   * Retrieves the bill payment ledger.
+   * @param   {IBillPayment} billPayment
+   * @param   {number} APAccountId
+   * @returns {Ledger}
+   */
+  private getBillPaymentLedger = (
+    billPayment: IBillPayment,
+    APAccountId: number,
+    gainLossAccountId: number,
+    baseCurrency: string
+  ): Ledger => {
+    const entries = this.getPaymentGLEntries(
+      billPayment,
+      APAccountId,
+      gainLossAccountId,
+      baseCurrency
+    );
+    return new Ledger(entries);
+  };
+}
diff --git a/packages/server/src/services/Purchases/BillPayments/BillPaymentGLEntriesSubscriber.ts b/packages/server/src/services/Purchases/BillPayments/BillPaymentGLEntriesSubscriber.ts
new file mode 100644
index 000000000..6a7cc983e
--- /dev/null
+++ b/packages/server/src/services/Purchases/BillPayments/BillPaymentGLEntriesSubscriber.ts
@@ -0,0 +1,76 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  IBillPaymentEventCreatedPayload,
+  IBillPaymentEventDeletedPayload,
+  IBillPaymentEventEditedPayload,
+} from '@/interfaces';
+import { BillPaymentGLEntries } from './BillPaymentGLEntries';
+
+@Service()
+export class PaymentWriteGLEntriesSubscriber {
+  @Inject()
+  private billPaymentGLEntries: BillPaymentGLEntries;
+
+  /**
+   * Attaches events with handles.
+   */
+  public attach(bus) {
+    bus.subscribe(events.billPayment.onCreated, this.handleWriteJournalEntries);
+    bus.subscribe(
+      events.billPayment.onEdited,
+      this.handleRewriteJournalEntriesOncePaymentEdited
+    );
+    bus.subscribe(
+      events.billPayment.onDeleted,
+      this.handleRevertJournalEntries
+    );
+  }
+
+  /**
+   * Handle bill payment writing journal entries once created.
+   */
+  private handleWriteJournalEntries = async ({
+    tenantId,
+    billPayment,
+    trx,
+  }: IBillPaymentEventCreatedPayload) => {
+    // Records the journal transactions after bills payment
+    // and change diff acoount balance.
+    await this.billPaymentGLEntries.writePaymentGLEntries(
+      tenantId,
+      billPayment.id,
+      trx
+    );
+  };
+
+  /**
+   * Handle bill payment re-writing journal entries once the payment transaction be edited.
+   */
+  private handleRewriteJournalEntriesOncePaymentEdited = async ({
+    tenantId,
+    billPayment,
+    trx,
+  }: IBillPaymentEventEditedPayload) => {
+    await this.billPaymentGLEntries.rewritePaymentGLEntries(
+      tenantId,
+      billPayment.id,
+      trx
+    );
+  };
+
+  /**
+   * Reverts journal entries once bill payment deleted.
+   */
+  private handleRevertJournalEntries = async ({
+    tenantId,
+    billPaymentId,
+    trx,
+  }: IBillPaymentEventDeletedPayload) => {
+    await this.billPaymentGLEntries.revertPaymentGLEntries(
+      tenantId,
+      billPaymentId,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/BillPayments/BillPaymentTransactionTransformer.ts b/packages/server/src/services/Purchases/BillPayments/BillPaymentTransactionTransformer.ts
new file mode 100644
index 000000000..7f42bcbcb
--- /dev/null
+++ b/packages/server/src/services/Purchases/BillPayments/BillPaymentTransactionTransformer.ts
@@ -0,0 +1,61 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class BillPaymentTransactionTransformer extends Transformer {
+  /**
+   * Include these attributes to sale credit note object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return ['formattedPaymentAmount', 'formattedPaymentDate'];
+  };
+
+  /**
+   * Retrieve formatted bill payment amount.
+   * @param {ICreditNote} credit
+   * @returns {string}
+   */
+  protected formattedPaymentAmount = (entry): string => {
+    return formatNumber(entry.paymentAmount, {
+      currencyCode: entry.payment.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve formatted bill payment date.
+   * @param entry
+   * @returns
+   */
+  protected formattedPaymentDate = (entry): string => {
+    return this.formatDate(entry.payment.paymentDate);
+  };
+
+  /**
+   * 
+   * @param entry 
+   * @returns 
+   */
+  public transform = (entry) => {
+    return {
+      billId: entry.billId,
+      billPaymentId: entry.billPaymentId,
+
+      paymentDate: entry.payment.paymentDate,
+      formattedPaymentDate: entry.formattedPaymentDate,
+
+      paymentAmount: entry.paymentAmount,
+      formattedPaymentAmount: entry.formattedPaymentAmount,
+      currencyCode: entry.payment.currencyCode,
+
+      paymentNumber: entry.payment.paymentNumber,
+      paymentReferenceNo: entry.payment.reference,
+
+      billNumber: entry.bill.billNumber,
+      billReferenceNo: entry.bill.referenceNo,
+
+      paymentAccountId: entry.payment.paymentAccountId,
+      paymentAccountName: entry.payment.paymentAccount.name,
+      paymentAccountSlug: entry.payment.paymentAccount.slug,
+    };
+  };
+}
diff --git a/packages/server/src/services/Purchases/BillPayments/BillPaymentTransformer.ts b/packages/server/src/services/Purchases/BillPayments/BillPaymentTransformer.ts
new file mode 100644
index 000000000..4345f028b
--- /dev/null
+++ b/packages/server/src/services/Purchases/BillPayments/BillPaymentTransformer.ts
@@ -0,0 +1,33 @@
+import { IBillPayment } from '@/interfaces';
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class BillPaymentTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return ['formattedPaymentDate', 'formattedAmount'];
+  };
+
+  /**
+   * Retrieve formatted invoice date.
+   * @param {IBill} invoice
+   * @returns {String}
+   */
+  protected formattedPaymentDate = (billPayment: IBillPayment): string => {
+    return this.formatDate(billPayment.paymentDate);
+  };
+
+  /**
+   * Retrieve formatted bill amount.
+   * @param {IBill} invoice
+   * @returns {string}
+   */
+  protected formattedAmount = (billPayment: IBillPayment): string => {
+    return formatNumber(billPayment.amount, {
+      currencyCode: billPayment.currencyCode,
+    });
+  };
+}
diff --git a/packages/server/src/services/Purchases/BillPayments/BillPayments.ts b/packages/server/src/services/Purchases/BillPayments/BillPayments.ts
new file mode 100644
index 000000000..0c5ffde28
--- /dev/null
+++ b/packages/server/src/services/Purchases/BillPayments/BillPayments.ts
@@ -0,0 +1,713 @@
+import { Inject, Service } from 'typedi';
+import { sumBy, difference } from 'lodash';
+import * as R from 'ramda';
+import { Knex } from 'knex';
+import events from '@/subscribers/events';
+import {
+  IBill,
+  IBillPaymentDTO,
+  IBillPaymentEntryDTO,
+  IBillPayment,
+  IBillPaymentsFilter,
+  IPaginationMeta,
+  IFilterMeta,
+  IBillPaymentEntry,
+  IBillPaymentEventCreatedPayload,
+  IBillPaymentEventEditedPayload,
+  IBillPaymentEventDeletedPayload,
+  IBillPaymentCreatingPayload,
+  IBillPaymentEditingPayload,
+  IBillPaymentDeletingPayload,
+  IVendor,
+} from '@/interfaces';
+import JournalPosterService from '@/services/Sales/JournalPosterService';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { entriesAmountDiff, formatDateFields } from 'utils';
+import { ServiceError } from '@/exceptions';
+import { ACCOUNT_TYPE } from '@/data/AccountTypes';
+import { BillPaymentTransformer } from './BillPaymentTransformer';
+import { ERRORS } from './constants';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import { BranchTransactionDTOTransform } from '@/services/Branches/Integrations/BranchTransactionDTOTransform';
+import { TenantMetadata } from '@/system/models';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+/**
+ * Bill payments service.
+ * @service
+ */
+@Service('BillPayments')
+export default class BillPaymentsService implements IBillPaymentsService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  journalService: JournalPosterService;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  private branchDTOTransform: BranchTransactionDTOTransform;
+
+  /**
+   * Validates the bill payment existance.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {Function} next
+   */
+  private async getPaymentMadeOrThrowError(
+    tenantid: number,
+    paymentMadeId: number
+  ) {
+    const { BillPayment } = this.tenancy.models(tenantid);
+    const billPayment = await BillPayment.query()
+      .withGraphFetched('entries')
+      .findById(paymentMadeId);
+
+    if (!billPayment) {
+      throw new ServiceError(ERRORS.PAYMENT_MADE_NOT_FOUND);
+    }
+    return billPayment;
+  }
+
+  /**
+   * Validates the payment account.
+   * @param {number} tenantId -
+   * @param {number} paymentAccountId
+   * @return {Promise<IAccountType>}
+   */
+  private async getPaymentAccountOrThrowError(
+    tenantId: number,
+    paymentAccountId: number
+  ) {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    const paymentAccount = await accountRepository.findOneById(
+      paymentAccountId
+    );
+    if (!paymentAccount) {
+      throw new ServiceError(ERRORS.PAYMENT_ACCOUNT_NOT_FOUND);
+    }
+    // Validate the payment account type.
+    if (
+      !paymentAccount.isAccountType([
+        ACCOUNT_TYPE.BANK,
+        ACCOUNT_TYPE.CASH,
+        ACCOUNT_TYPE.OTHER_CURRENT_ASSET,
+      ])
+    ) {
+      throw new ServiceError(ERRORS.PAYMENT_ACCOUNT_NOT_CURRENT_ASSET_TYPE);
+    }
+    return paymentAccount;
+  }
+
+  /**
+   * Validates the payment number uniqness.
+   * @param {number} tenantId -
+   * @param {string} paymentMadeNumber -
+   * @return {Promise<IBillPayment>}
+   */
+  private async validatePaymentNumber(
+    tenantId: number,
+    paymentMadeNumber: string,
+    notPaymentMadeId?: number
+  ) {
+    const { BillPayment } = this.tenancy.models(tenantId);
+
+    const foundBillPayment = await BillPayment.query().onBuild(
+      (builder: any) => {
+        builder.findOne('payment_number', paymentMadeNumber);
+
+        if (notPaymentMadeId) {
+          builder.whereNot('id', notPaymentMadeId);
+        }
+      }
+    );
+
+    if (foundBillPayment) {
+      throw new ServiceError(ERRORS.BILL_PAYMENT_NUMBER_NOT_UNQIUE);
+    }
+    return foundBillPayment;
+  }
+
+  /**
+   * Validate whether the entries bills ids exist on the storage.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public async validateBillsExistance(
+    tenantId: number,
+    billPaymentEntries: { billId: number }[],
+    vendorId: number
+  ) {
+    const { Bill } = this.tenancy.models(tenantId);
+    const entriesBillsIds = billPaymentEntries.map((e: any) => e.billId);
+
+    const storedBills = await Bill.query()
+      .whereIn('id', entriesBillsIds)
+      .where('vendor_id', vendorId);
+
+    const storedBillsIds = storedBills.map((t: IBill) => t.id);
+    const notFoundBillsIds = difference(entriesBillsIds, storedBillsIds);
+
+    if (notFoundBillsIds.length > 0) {
+      throw new ServiceError(ERRORS.BILL_ENTRIES_IDS_NOT_FOUND);
+    }
+    // Validate the not opened bills.
+    const notOpenedBills = storedBills.filter((bill) => !bill.openedAt);
+
+    if (notOpenedBills.length > 0) {
+      throw new ServiceError(ERRORS.BILLS_NOT_OPENED_YET, null, {
+        notOpenedBills,
+      });
+    }
+    return storedBills;
+  }
+
+  /**
+   * Validate wether the payment amount bigger than the payable amount.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   * @return {void}
+   */
+  private async validateBillsDueAmount(
+    tenantId: number,
+    billPaymentEntries: IBillPaymentEntryDTO[],
+    oldPaymentEntries: IBillPaymentEntry[] = []
+  ) {
+    const { Bill } = this.tenancy.models(tenantId);
+    const billsIds = billPaymentEntries.map(
+      (entry: IBillPaymentEntryDTO) => entry.billId
+    );
+
+    const storedBills = await Bill.query().whereIn('id', billsIds);
+    const storedBillsMap = new Map(
+      storedBills.map((bill) => {
+        const oldEntries = oldPaymentEntries.filter(
+          (entry) => entry.billId === bill.id
+        );
+        const oldPaymentAmount = sumBy(oldEntries, 'paymentAmount') || 0;
+
+        return [
+          bill.id,
+          { ...bill, dueAmount: bill.dueAmount + oldPaymentAmount },
+        ];
+      })
+    );
+    interface invalidPaymentAmountError {
+      index: number;
+      due_amount: number;
+    }
+    const hasWrongPaymentAmount: invalidPaymentAmountError[] = [];
+
+    billPaymentEntries.forEach((entry: IBillPaymentEntryDTO, index: number) => {
+      const entryBill = storedBillsMap.get(entry.billId);
+      const { dueAmount } = entryBill;
+
+      if (dueAmount < entry.paymentAmount) {
+        hasWrongPaymentAmount.push({ index, due_amount: dueAmount });
+      }
+    });
+    if (hasWrongPaymentAmount.length > 0) {
+      throw new ServiceError(ERRORS.INVALID_BILL_PAYMENT_AMOUNT);
+    }
+  }
+
+  /**
+   * Validate the payment receive entries IDs existance.
+   * @param {Request} req
+   * @param {Response} res
+   * @return {Response}
+   */
+  private async validateEntriesIdsExistance(
+    tenantId: number,
+    billPaymentId: number,
+    billPaymentEntries: IBillPaymentEntry[]
+  ) {
+    const { BillPaymentEntry } = this.tenancy.models(tenantId);
+
+    const entriesIds = billPaymentEntries
+      .filter((entry: any) => entry.id)
+      .map((entry: any) => entry.id);
+
+    const storedEntries = await BillPaymentEntry.query().where(
+      'bill_payment_id',
+      billPaymentId
+    );
+
+    const storedEntriesIds = storedEntries.map((entry: any) => entry.id);
+    const notFoundEntriesIds = difference(entriesIds, storedEntriesIds);
+
+    if (notFoundEntriesIds.length > 0) {
+      throw new ServiceError(ERRORS.BILL_PAYMENT_ENTRIES_NOT_FOUND);
+    }
+  }
+
+  /**
+   * * Validate the payment vendor whether modified.
+   * @param {string} billPaymentNo
+   */
+  private validateVendorNotModified(
+    billPaymentDTO: IBillPaymentDTO,
+    oldBillPayment: IBillPayment
+  ) {
+    if (billPaymentDTO.vendorId !== oldBillPayment.vendorId) {
+      throw new ServiceError(ERRORS.PAYMENT_NUMBER_SHOULD_NOT_MODIFY);
+    }
+  }
+
+  /**
+   * Validates the payment account currency code. The deposit account curreny
+   * should be equals the customer currency code or the base currency.
+   * @param  {string} paymentAccountCurrency
+   * @param  {string} customerCurrency
+   * @param  {string} baseCurrency
+   * @throws {ServiceError(ERRORS.WITHDRAWAL_ACCOUNT_CURRENCY_INVALID)}
+   */
+  public validateWithdrawalAccountCurrency = (
+    paymentAccountCurrency: string,
+    customerCurrency: string,
+    baseCurrency: string
+  ) => {
+    if (
+      paymentAccountCurrency !== customerCurrency &&
+      paymentAccountCurrency !== baseCurrency
+    ) {
+      throw new ServiceError(ERRORS.WITHDRAWAL_ACCOUNT_CURRENCY_INVALID);
+    }
+  };
+
+  /**
+   * Transforms create/edit DTO to model.
+   * @param {number} tenantId
+   * @param {IBillPaymentDTO} billPaymentDTO - Bill payment.
+   * @param {IBillPayment} oldBillPayment - Old bill payment.
+   * @return {Promise<IBillPayment>}
+   */
+  async transformDTOToModel(
+    tenantId: number,
+    billPaymentDTO: IBillPaymentDTO,
+    vendor: IVendor,
+    oldBillPayment?: IBillPayment
+  ): Promise<IBillPayment> {
+    const initialDTO = {
+      ...formatDateFields(billPaymentDTO, ['paymentDate']),
+      amount: sumBy(billPaymentDTO.entries, 'paymentAmount'),
+      currencyCode: vendor.currencyCode,
+      exchangeRate: billPaymentDTO.exchangeRate || 1,
+      entries: billPaymentDTO.entries,
+    };
+    return R.compose(
+      this.branchDTOTransform.transformDTO<IBillPayment>(tenantId)
+    )(initialDTO);
+  }
+
+  /**
+   * Creates a new bill payment transcations and store it to the storage
+   * with associated bills entries and journal transactions.
+   *
+   * Precedures:-
+   * ------
+   * - Records the bill payment transaction.
+   * - Records the bill payment associated entries.
+   * - Increment the payment amount of the given vendor bills.
+   * - Decrement the vendor balance.
+   * - Records payment journal entries.
+   * ------
+   * @param {number} tenantId - Tenant id.
+   * @param {BillPaymentDTO} billPayment - Bill payment object.
+   */
+  public async createBillPayment(
+    tenantId: number,
+    billPaymentDTO: IBillPaymentDTO
+  ): Promise<IBillPayment> {
+    const { BillPayment, Contact } = this.tenancy.models(tenantId);
+
+    const tenantMeta = await TenantMetadata.query().findOne({ tenantId });
+
+    // Retrieves the payment vendor or throw not found error.
+    const vendor = await Contact.query()
+      .findById(billPaymentDTO.vendorId)
+      .modify('vendor')
+      .throwIfNotFound();
+
+    // Transform create DTO to model object.
+    const billPaymentObj = await this.transformDTOToModel(
+      tenantId,
+      billPaymentDTO,
+      vendor
+    );
+    // Validate the payment account existance and type.
+    const paymentAccount = await this.getPaymentAccountOrThrowError(
+      tenantId,
+      billPaymentObj.paymentAccountId
+    );
+    // Validate the payment number uniquiness.
+    if (billPaymentObj.paymentNumber) {
+      await this.validatePaymentNumber(tenantId, billPaymentObj.paymentNumber);
+    }
+    // Validates the bills existance and associated to the given vendor.
+    await this.validateBillsExistance(
+      tenantId,
+      billPaymentObj.entries,
+      billPaymentDTO.vendorId
+    );
+    // Validates the bills due payment amount.
+    await this.validateBillsDueAmount(tenantId, billPaymentObj.entries);
+
+    // Validates the withdrawal account currency code.
+    this.validateWithdrawalAccountCurrency(
+      paymentAccount.currencyCode,
+      vendor.currencyCode,
+      tenantMeta.baseCurrency
+    );
+    // Writes bill payment transacation with associated transactions
+    // under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onBillPaymentCreating` event.
+      await this.eventPublisher.emitAsync(events.billPayment.onCreating, {
+        tenantId,
+        billPaymentDTO,
+        trx,
+      } as IBillPaymentCreatingPayload);
+
+      // Writes the bill payment graph to the storage.
+      const billPayment = await BillPayment.query(trx).insertGraphAndFetch({
+        ...billPaymentObj,
+      });
+
+      // Triggers `onBillPaymentCreated` event.
+      await this.eventPublisher.emitAsync(events.billPayment.onCreated, {
+        tenantId,
+        billPayment,
+        billPaymentId: billPayment.id,
+        trx,
+      } as IBillPaymentEventCreatedPayload);
+
+      return billPayment;
+    });
+  }
+
+  /**
+   * Edits the details of the given bill payment.
+   *
+   * Preceducres:
+   * ------
+   * - Update the bill payment transaction.
+   * - Insert the new bill payment entries that have no ids.
+   * - Update the bill paymeny entries that have ids.
+   * - Delete the bill payment entries that not presented.
+   * - Re-insert the journal transactions and update the diff accounts balance.
+   * - Update the diff vendor balance.
+   * - Update the diff bill payment amount.
+   * ------
+   * @param {number} tenantId - Tenant id
+   * @param {Integer} billPaymentId
+   * @param {BillPaymentDTO} billPayment
+   * @param {IBillPayment} oldBillPayment
+   */
+  public async editBillPayment(
+    tenantId: number,
+    billPaymentId: number,
+    billPaymentDTO
+  ): Promise<IBillPayment> {
+    const { BillPayment, Contact } = this.tenancy.models(tenantId);
+
+    const tenantMeta = await TenantMetadata.query().findOne({ tenantId });
+
+    //
+    const oldBillPayment = await this.getPaymentMadeOrThrowError(
+      tenantId,
+      billPaymentId
+    );
+
+    //
+    const vendor = await Contact.query()
+      .modify('vendor')
+      .findById(billPaymentDTO.vendorId)
+      .throwIfNotFound();
+
+    // Transform bill payment DTO to model object.
+    const billPaymentObj = await this.transformDTOToModel(
+      tenantId,
+      billPaymentDTO,
+      vendor,
+      oldBillPayment
+    );
+    // Validate vendor not modified.
+    this.validateVendorNotModified(billPaymentDTO, oldBillPayment);
+
+    // Validate the payment account existance and type.
+    const paymentAccount = await this.getPaymentAccountOrThrowError(
+      tenantId,
+      billPaymentObj.paymentAccountId
+    );
+    // Validate the items entries IDs existance on the storage.
+    await this.validateEntriesIdsExistance(
+      tenantId,
+      billPaymentId,
+      billPaymentObj.entries
+    );
+    // Validate the bills existance and associated to the given vendor.
+    await this.validateBillsExistance(
+      tenantId,
+      billPaymentObj.entries,
+      billPaymentDTO.vendorId
+    );
+    // Validates the bills due payment amount.
+    await this.validateBillsDueAmount(
+      tenantId,
+      billPaymentObj.entries,
+      oldBillPayment.entries
+    );
+    // Validate the payment number uniquiness.
+    if (billPaymentObj.paymentNumber) {
+      await this.validatePaymentNumber(
+        tenantId,
+        billPaymentObj.paymentNumber,
+        billPaymentId
+      );
+    }
+    // Validates the withdrawal account currency code.
+    this.validateWithdrawalAccountCurrency(
+      paymentAccount.currencyCode,
+      vendor.currencyCode,
+      tenantMeta.baseCurrency
+    );
+    // Edits the bill transactions with associated transactions
+    // under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onBillPaymentEditing` event.
+      await this.eventPublisher.emitAsync(events.billPayment.onEditing, {
+        tenantId,
+        oldBillPayment,
+        billPaymentDTO,
+        trx,
+      } as IBillPaymentEditingPayload);
+
+      // Deletes the bill payment transaction graph from the storage.
+      const billPayment = await BillPayment.query(trx).upsertGraphAndFetch({
+        id: billPaymentId,
+        ...billPaymentObj,
+      });
+      // Triggers `onBillPaymentEdited` event.
+      await this.eventPublisher.emitAsync(events.billPayment.onEdited, {
+        tenantId,
+        billPaymentId,
+        billPayment,
+        oldBillPayment,
+        trx,
+      } as IBillPaymentEventEditedPayload);
+
+      return billPayment;
+    });
+  }
+
+  /**
+   * Deletes the bill payment and associated transactions.
+   * @param  {number} tenantId - Tenant id.
+   * @param  {Integer} billPaymentId - The given bill payment id.
+   * @return {Promise}
+   */
+  public async deleteBillPayment(tenantId: number, billPaymentId: number) {
+    const { BillPayment, BillPaymentEntry } = this.tenancy.models(tenantId);
+
+    // Retrieve the bill payment or throw not found service error.
+    const oldBillPayment = await this.getPaymentMadeOrThrowError(
+      tenantId,
+      billPaymentId
+    );
+    // Deletes the bill transactions with associated transactions under
+    // unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onBillPaymentDeleting` payload.
+      await this.eventPublisher.emitAsync(events.billPayment.onDeleting, {
+        tenantId,
+        trx,
+        oldBillPayment,
+      } as IBillPaymentDeletingPayload);
+
+      // Deletes the bill payment assocaited entries.
+      await BillPaymentEntry.query(trx)
+        .where('bill_payment_id', billPaymentId)
+        .delete();
+
+      // Deletes the bill payment transaction.
+      await BillPayment.query(trx).where('id', billPaymentId).delete();
+
+      // Triggers `onBillPaymentDeleted` event.
+      await this.eventPublisher.emitAsync(events.billPayment.onDeleted, {
+        tenantId,
+        billPaymentId,
+        oldBillPayment,
+        trx,
+      } as IBillPaymentEventDeletedPayload);
+    });
+  }
+
+  /**
+   * Retrieve payment made associated bills.
+   * @param {number} tenantId -
+   * @param {number} billPaymentId -
+   */
+  public async getPaymentBills(tenantId: number, billPaymentId: number) {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    const billPayment = await this.getPaymentMadeOrThrowError(
+      tenantId,
+      billPaymentId
+    );
+    const paymentBillsIds = billPayment.entries.map((entry) => entry.id);
+
+    const bills = await Bill.query().whereIn('id', paymentBillsIds);
+
+    return bills;
+  }
+
+  /**
+   * Retrieve bill payment.
+   * @param {number} tenantId
+   * @param {number} billPyamentId
+   * @return {Promise<IBillPayment>}
+   */
+  public async getBillPayment(
+    tenantId: number,
+    billPyamentId: number
+  ): Promise<IBillPayment> {
+    const { BillPayment } = this.tenancy.models(tenantId);
+
+    const billPayment = await BillPayment.query()
+      .withGraphFetched('entries.bill')
+      .withGraphFetched('vendor')
+      .withGraphFetched('paymentAccount')
+      .withGraphFetched('transactions')
+      .withGraphFetched('branch')
+      .findById(billPyamentId);
+
+    if (!billPayment) {
+      throw new ServiceError(ERRORS.PAYMENT_MADE_NOT_FOUND);
+    }
+    return this.transformer.transform(
+      tenantId,
+      billPayment,
+      new BillPaymentTransformer()
+    );
+  }
+
+  private parseListFilterDTO(filterDTO) {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  }
+
+  /**
+   * Retrieve bill payment paginted and filterable list.
+   * @param {number} tenantId
+   * @param {IBillPaymentsFilter} billPaymentsFilter
+   */
+  public async listBillPayments(
+    tenantId: number,
+    filterDTO: IBillPaymentsFilter
+  ): Promise<{
+    billPayments: IBillPayment;
+    pagination: IPaginationMeta;
+    filterMeta: IFilterMeta;
+  }> {
+    const { BillPayment } = this.tenancy.models(tenantId);
+
+    // Parses filter DTO.
+    const filter = this.parseListFilterDTO(filterDTO);
+
+    // Dynamic list service.
+    const dynamicList = await this.dynamicListService.dynamicList(
+      tenantId,
+      BillPayment,
+      filter
+    );
+
+    const { results, pagination } = await BillPayment.query()
+      .onBuild((builder) => {
+        builder.withGraphFetched('vendor');
+        builder.withGraphFetched('paymentAccount');
+
+        dynamicList.buildQuery()(builder);
+      })
+      .pagination(filter.page - 1, filter.pageSize);
+
+    // Transformes the bill payments models to POJO.
+    const billPayments = await this.transformer.transform(
+      tenantId,
+      results,
+      new BillPaymentTransformer()
+    );
+    return {
+      billPayments,
+      pagination,
+      filterMeta: dynamicList.getResponseMeta(),
+    };
+  }
+
+  /**
+   * Saves bills payment amount changes different.
+   * @param {number} tenantId -
+   * @param {IBillPaymentEntryDTO[]} paymentMadeEntries -
+   * @param {IBillPaymentEntryDTO[]} oldPaymentMadeEntries -
+   */
+  public async saveChangeBillsPaymentAmount(
+    tenantId: number,
+    paymentMadeEntries: IBillPaymentEntryDTO[],
+    oldPaymentMadeEntries?: IBillPaymentEntryDTO[],
+    trx?: Knex.Transaction
+  ): Promise<void> {
+    const { Bill } = this.tenancy.models(tenantId);
+    const opers: Promise<void>[] = [];
+
+    const diffEntries = entriesAmountDiff(
+      paymentMadeEntries,
+      oldPaymentMadeEntries,
+      'paymentAmount',
+      'billId'
+    );
+    diffEntries.forEach(
+      (diffEntry: { paymentAmount: number; billId: number }) => {
+        if (diffEntry.paymentAmount === 0) {
+          return;
+        }
+        const oper = Bill.changePaymentAmount(
+          diffEntry.billId,
+          diffEntry.paymentAmount,
+          trx
+        );
+        opers.push(oper);
+      }
+    );
+    await Promise.all(opers);
+  }
+
+  /**
+   * Validates the given vendor has no associated payments.
+   * @param {number} tenantId
+   * @param {number} vendorId
+   */
+  public async validateVendorHasNoPayments(tenantId: number, vendorId: number) {
+    const { BillPayment } = this.tenancy.models(tenantId);
+
+    const payments = await BillPayment.query().where('vendor_id', vendorId);
+
+    if (payments.length > 0) {
+      throw new ServiceError(ERRORS.VENDOR_HAS_PAYMENTS);
+    }
+  }
+}
diff --git a/packages/server/src/services/Purchases/BillPayments/BillPaymentsPages.ts b/packages/server/src/services/Purchases/BillPayments/BillPaymentsPages.ts
new file mode 100644
index 000000000..7d5a0572c
--- /dev/null
+++ b/packages/server/src/services/Purchases/BillPayments/BillPaymentsPages.ts
@@ -0,0 +1,102 @@
+import { Inject, Service } from 'typedi';
+import { omit } from 'lodash';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import { IBill, IBillPayment, IBillReceivePageEntry } from '@/interfaces';
+import { ERRORS } from './constants';
+import { ServiceError } from '@/exceptions';
+
+/**
+ * Bill payments edit and create pages services.
+ */
+@Service()
+export default class BillPaymentsPages {
+  @Inject()
+  tenancy: TenancyService;
+
+  /**
+   * Retrieve bill payment with associated metadata.
+   * @param {number} billPaymentId - The bill payment id.
+   * @return {object}
+   */
+  public async getBillPaymentEditPage(
+    tenantId: number,
+    billPaymentId: number
+  ): Promise<{
+    billPayment: Omit<IBillPayment, 'entries'>;
+    entries: IBillReceivePageEntry[];
+  }> {
+    const { BillPayment, Bill } = this.tenancy.models(tenantId);
+    const billPayment = await BillPayment.query()
+      .findById(billPaymentId)
+      .withGraphFetched('entries.bill');
+
+    // Throw not found the bill payment.
+    if (!billPayment) {
+      throw new ServiceError(ERRORS.PAYMENT_MADE_NOT_FOUND);
+    }
+    const paymentEntries = billPayment.entries.map((entry) => ({
+      ...this.mapBillToPageEntry(entry.bill),
+      dueAmount: entry.bill.dueAmount + entry.paymentAmount,
+      paymentAmount: entry.paymentAmount,
+    }));
+
+    const resPayableBills = await Bill.query()
+      .modify('opened')
+      .modify('dueBills')
+      .where('vendor_id', billPayment.vendorId)
+      .whereNotIn(
+        'id',
+        billPayment.entries.map((e) => e.billId)
+      )
+      .orderBy('bill_date', 'ASC');
+
+    // Mapping the payable bills to entries.
+    const restPayableEntries = resPayableBills.map(this.mapBillToPageEntry);
+    const entries = [...paymentEntries, ...restPayableEntries];
+
+    return {
+      billPayment: omit(billPayment, ['entries']),
+      entries,
+    };
+  }
+
+  /**
+   * Retrieve the payable entries of the new page once vendor be selected.
+   * @param {number} tenantId
+   * @param {number} vendorId
+   */
+  public async getNewPageEntries(
+    tenantId: number,
+    vendorId: number
+  ): Promise<IBillReceivePageEntry[]> {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    // Retrieve all payable bills that assocaited to the payment made transaction.
+    const payableBills = await Bill.query()
+      .modify('opened')
+      .modify('dueBills')
+      .where('vendor_id', vendorId)
+      .orderBy('bill_date', 'ASC');
+
+    return payableBills.map(this.mapBillToPageEntry);
+  }
+
+  /**
+   * Retrive edit page invoices entries from the given sale invoices models.
+   * @param  {ISaleInvoice[]} invoices - Invoices.
+   * @return {IPaymentReceiveEditPageEntry}
+   */
+  private mapBillToPageEntry(bill: IBill): IBillReceivePageEntry {
+    return {
+      entryType: 'invoice',
+      billId: bill.id,
+      billNo: bill.billNumber,
+      amount: bill.amount,
+      dueAmount: bill.dueAmount,
+      totalPaymentAmount: bill.paymentAmount,
+      paymentAmount: bill.paymentAmount,
+      currencyCode: bill.currencyCode,
+      date: bill.billDate,
+    };
+  }
+}
diff --git a/packages/server/src/services/Purchases/BillPayments/constants.ts b/packages/server/src/services/Purchases/BillPayments/constants.ts
new file mode 100644
index 000000000..98cd2540b
--- /dev/null
+++ b/packages/server/src/services/Purchases/BillPayments/constants.ts
@@ -0,0 +1,17 @@
+export const ERRORS = {
+  BILL_VENDOR_NOT_FOUND: 'VENDOR_NOT_FOUND',
+  PAYMENT_MADE_NOT_FOUND: 'PAYMENT_MADE_NOT_FOUND',
+  BILL_PAYMENT_NUMBER_NOT_UNQIUE: 'BILL_PAYMENT_NUMBER_NOT_UNQIUE',
+  PAYMENT_ACCOUNT_NOT_FOUND: 'PAYMENT_ACCOUNT_NOT_FOUND',
+  PAYMENT_ACCOUNT_NOT_CURRENT_ASSET_TYPE:
+    'PAYMENT_ACCOUNT_NOT_CURRENT_ASSET_TYPE',
+  BILL_ENTRIES_IDS_NOT_FOUND: 'BILL_ENTRIES_IDS_NOT_FOUND',
+  BILL_PAYMENT_ENTRIES_NOT_FOUND: 'BILL_PAYMENT_ENTRIES_NOT_FOUND',
+  INVALID_BILL_PAYMENT_AMOUNT: 'INVALID_BILL_PAYMENT_AMOUNT',
+  PAYMENT_NUMBER_SHOULD_NOT_MODIFY: 'PAYMENT_NUMBER_SHOULD_NOT_MODIFY',
+  BILLS_NOT_OPENED_YET: 'BILLS_NOT_OPENED_YET',
+  VENDOR_HAS_PAYMENTS: 'VENDOR_HAS_PAYMENTS',
+  WITHDRAWAL_ACCOUNT_CURRENCY_INVALID: 'WITHDRAWAL_ACCOUNT_CURRENCY_INVALID',
+};
+
+export const DEFAULT_VIEWS = [];
diff --git a/packages/server/src/services/Purchases/BillPaymentsService.ts b/packages/server/src/services/Purchases/BillPaymentsService.ts
new file mode 100644
index 000000000..faa321181
--- /dev/null
+++ b/packages/server/src/services/Purchases/BillPaymentsService.ts
@@ -0,0 +1,35 @@
+import { Service, Inject } from 'typedi';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import { BillPaymentTransactionTransformer } from './BillPayments/BillPaymentTransactionTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export default class BillPaymentsService {
+  @Inject()
+  private tenancy: TenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the specific bill associated payment transactions.
+   * @param {number} tenantId
+   * @param {number} billId
+   * @returns {}
+   */
+  public getBillPayments = async (tenantId: number, billId: number) => {
+    const { BillPaymentEntry } = this.tenancy.models(tenantId);
+
+    const billsEntries = await BillPaymentEntry.query()
+      .where('billId', billId)
+      .withGraphJoined('payment.paymentAccount')
+      .withGraphJoined('bill')
+      .orderBy('payment:paymentDate', 'ASC');
+
+    return this.transformer.transform(
+      tenantId,
+      billsEntries,
+      new BillPaymentTransactionTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/Bills.ts b/packages/server/src/services/Purchases/Bills.ts
new file mode 100644
index 000000000..a98632c36
--- /dev/null
+++ b/packages/server/src/services/Purchases/Bills.ts
@@ -0,0 +1,751 @@
+import { omit, sumBy } from 'lodash';
+import moment from 'moment';
+import { Inject, Service } from 'typedi';
+import * as R from 'ramda';
+import { Knex } from 'knex';
+import composeAsync from 'async/compose';
+import events from '@/subscribers/events';
+import InventoryService from '@/services/Inventory/Inventory';
+import SalesInvoicesCost from '@/services/Sales/SalesInvoicesCost';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { formatDateFields, transformToMap } from 'utils';
+import {
+  IBillDTO,
+  IBill,
+  ISystemUser,
+  IBillEditDTO,
+  IPaginationMeta,
+  IFilterMeta,
+  IBillsFilter,
+  IBillsService,
+  IItemEntry,
+  IItemEntryDTO,
+  IBillCreatedPayload,
+  IBillEditedPayload,
+  IBIllEventDeletedPayload,
+  IBillEventDeletingPayload,
+  IBillEditingPayload,
+  IBillCreatingPayload,
+  IVendor,
+} from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+import JournalPosterService from '@/services/Sales/JournalPosterService';
+import { ERRORS } from './constants';
+import EntriesService from '@/services/Entries';
+import { PurchaseInvoiceTransformer } from './PurchaseInvoices/PurchaseInvoiceTransformer';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+import { BranchTransactionDTOTransform } from '@/services/Branches/Integrations/BranchTransactionDTOTransform';
+import { WarehouseTransactionDTOTransform } from '@/services/Warehouses/Integrations/WarehouseTransactionDTOTransform';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+/**
+ * Vendor bills services.
+ * @service
+ */
+@Service('Bills')
+export default class BillsService
+  extends SalesInvoicesCost
+  implements IBillsService
+{
+  @Inject()
+  inventoryService: InventoryService;
+
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  @Inject()
+  itemsEntriesService: ItemsEntriesService;
+
+  @Inject()
+  journalPosterService: JournalPosterService;
+
+  @Inject()
+  entriesService: EntriesService;
+
+  @Inject()
+  transformer: TransformerInjectable;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  private branchDTOTransform: BranchTransactionDTOTransform;
+
+  @Inject()
+  private warehouseDTOTransform: WarehouseTransactionDTOTransform;
+
+  /**
+   * Validates the given bill existance.
+   * @async
+   * @param {number} tenantId -
+   * @param {number} billId -
+   */
+  public async getBillOrThrowError(tenantId: number, billId: number) {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    const foundBill = await Bill.query()
+      .findById(billId)
+      .withGraphFetched('entries');
+
+    if (!foundBill) {
+      throw new ServiceError(ERRORS.BILL_NOT_FOUND);
+    }
+    return foundBill;
+  }
+
+  /**
+   * Validates the bill number existance.
+   * @async
+   * @param {Request} req
+   * @param {Response} res
+   * @param {Function} next
+   */
+  private async validateBillNumberExists(
+    tenantId: number,
+    billNumber: string,
+    notBillId?: number
+  ) {
+    const { Bill } = this.tenancy.models(tenantId);
+    const foundBills = await Bill.query()
+      .where('bill_number', billNumber)
+      .onBuild((builder) => {
+        if (notBillId) {
+          builder.whereNot('id', notBillId);
+        }
+      });
+
+    if (foundBills.length > 0) {
+      throw new ServiceError(ERRORS.BILL_NUMBER_EXISTS);
+    }
+  }
+
+  /**
+   * Validate the bill has no payment entries.
+   * @param {number} tenantId
+   * @param {number} billId - Bill id.
+   */
+  private async validateBillHasNoEntries(tenantId, billId: number) {
+    const { BillPaymentEntry } = this.tenancy.models(tenantId);
+
+    // Retireve the bill associate payment made entries.
+    const entries = await BillPaymentEntry.query().where('bill_id', billId);
+
+    if (entries.length > 0) {
+      throw new ServiceError(ERRORS.BILL_HAS_ASSOCIATED_PAYMENT_ENTRIES);
+    }
+    return entries;
+  }
+
+  /**
+   * Validate the bill number require.
+   * @param {string} billNo -
+   */
+  private validateBillNoRequire(billNo: string) {
+    if (!billNo) {
+      throw new ServiceError(ERRORS.BILL_NO_IS_REQUIRED);
+    }
+  }
+
+  /**
+   * Validate bill transaction has no associated allocated landed cost transactions.
+   * @param {number} tenantId
+   * @param {number} billId
+   */
+  private async validateBillHasNoLandedCost(tenantId: number, billId: number) {
+    const { BillLandedCost } = this.tenancy.models(tenantId);
+
+    const billLandedCosts = await BillLandedCost.query().where(
+      'billId',
+      billId
+    );
+    if (billLandedCosts.length > 0) {
+      throw new ServiceError(ERRORS.BILL_HAS_ASSOCIATED_LANDED_COSTS);
+    }
+  }
+
+  /**
+   * Validate transaction entries that have landed cost type should not be
+   * inventory items.
+   * @param {number} tenantId -
+   * @param {IItemEntryDTO[]} newEntriesDTO -
+   */
+  public async validateCostEntriesShouldBeInventoryItems(
+    tenantId: number,
+    newEntriesDTO: IItemEntryDTO[]
+  ) {
+    const { Item } = this.tenancy.models(tenantId);
+
+    const entriesItemsIds = newEntriesDTO.map((e) => e.itemId);
+    const entriesItems = await Item.query().whereIn('id', entriesItemsIds);
+
+    const entriesItemsById = transformToMap(entriesItems, 'id');
+
+    // Filter the landed cost entries that not associated with inventory item.
+    const nonInventoryHasCost = newEntriesDTO.filter((entry) => {
+      const item = entriesItemsById.get(entry.itemId);
+
+      return entry.landedCost && item.type !== 'inventory';
+    });
+    if (nonInventoryHasCost.length > 0) {
+      throw new ServiceError(
+        ERRORS.LANDED_COST_ENTRIES_SHOULD_BE_INVENTORY_ITEMS
+      );
+    }
+  }
+
+  /**
+   * Sets the default cost account to the bill entries.
+   */
+  private setBillEntriesDefaultAccounts(tenantId: number) {
+    return async (entries: IItemEntry[]) => {
+      const { Item } = this.tenancy.models(tenantId);
+
+      const entriesItemsIds = entries.map((e) => e.itemId);
+      const items = await Item.query().whereIn('id', entriesItemsIds);
+
+      return entries.map((entry) => {
+        const item = items.find((i) => i.id === entry.itemId);
+
+        return {
+          ...entry,
+          ...(item.type !== 'inventory' && {
+            costAccountId: entry.costAccountId || item.costAccountId,
+          }),
+        };
+      });
+    };
+  }
+
+  /**
+   * Retrieve the bill entries total.
+   * @param {IItemEntry[]} entries
+   * @returns {number}
+   */
+  private getBillEntriesTotal(tenantId: number, entries: IItemEntry[]): number {
+    const { ItemEntry } = this.tenancy.models(tenantId);
+
+    return sumBy(entries, (e) => ItemEntry.calcAmount(e));
+  }
+
+  /**
+   * Retrieve the bill landed cost amount.
+   * @param {IBillDTO} billDTO
+   * @returns {number}
+   */
+  private getBillLandedCostAmount(tenantId: number, billDTO: IBillDTO): number {
+    const costEntries = billDTO.entries.filter((entry) => entry.landedCost);
+
+    return this.getBillEntriesTotal(tenantId, costEntries);
+  }
+
+  /**
+   * Converts create bill DTO to model.
+   * @param   {number} tenantId
+   * @param   {IBillDTO} billDTO
+   * @param   {IBill} oldBill
+   * @returns {IBill}
+   */
+  private async billDTOToModel(
+    tenantId: number,
+    billDTO: IBillDTO,
+    vendor: IVendor,
+    authorizedUser: ISystemUser,
+    oldBill?: IBill
+  ) {
+    const { ItemEntry } = this.tenancy.models(tenantId);
+
+    const amount = sumBy(billDTO.entries, (e) => ItemEntry.calcAmount(e));
+
+    // Retrieve the landed cost amount from landed cost entries.
+    const landedCostAmount = this.getBillLandedCostAmount(tenantId, billDTO);
+
+    // Bill number from DTO or from auto-increment.
+    const billNumber = billDTO.billNumber || oldBill?.billNumber;
+
+    const initialEntries = billDTO.entries.map((entry) => ({
+      reference_type: 'Bill',
+      ...omit(entry, ['amount']),
+    }));
+    const entries = await composeAsync(
+      // Sets the default cost account to the bill entries.
+      this.setBillEntriesDefaultAccounts(tenantId)
+    )(initialEntries);
+
+    const initialDTO = {
+      ...formatDateFields(omit(billDTO, ['open', 'entries']), [
+        'billDate',
+        'dueDate',
+      ]),
+      amount,
+      landedCostAmount,
+      currencyCode: vendor.currencyCode,
+      exchangeRate: billDTO.exchangeRate || 1,
+      billNumber,
+      entries,
+      // Avoid rewrite the open date in edit mode when already opened.
+      ...(billDTO.open &&
+        !oldBill?.openedAt && {
+          openedAt: moment().toMySqlDateTime(),
+        }),
+      userId: authorizedUser.id,
+    };
+    return R.compose(
+      this.branchDTOTransform.transformDTO(tenantId),
+      this.warehouseDTOTransform.transformDTO(tenantId)
+    )(initialDTO);
+  }
+
+  /**
+   * Creates a new bill and stored it to the storage.
+   * ----
+   * Precedures.
+   * ----
+   * - Insert bill transactions to the storage.
+   * - Insert bill entries to the storage.
+   * - Increment the given vendor id.
+   * - Record bill journal transactions on the given accounts.
+   * - Record bill items inventory transactions.
+   * ----
+   * @param  {number} tenantId - The given tenant id.
+   * @param  {IBillDTO} billDTO -
+   * @return {Promise<IBill>}
+   */
+  public async createBill(
+    tenantId: number,
+    billDTO: IBillDTO,
+    authorizedUser: ISystemUser
+  ): Promise<IBill> {
+    const { Bill, Contact } = this.tenancy.models(tenantId);
+
+    // Retrieves the given bill vendor or throw not found error.
+    const vendor = await Contact.query()
+      .modify('vendor')
+      .findById(billDTO.vendorId)
+      .throwIfNotFound();
+
+    // Validate the bill number uniqiness on the storage.
+    await this.validateBillNumberExists(tenantId, billDTO.billNumber);
+
+    // Validate items IDs existance.
+    await this.itemsEntriesService.validateItemsIdsExistance(
+      tenantId,
+      billDTO.entries
+    );
+    // Validate non-purchasable items.
+    await this.itemsEntriesService.validateNonPurchasableEntriesItems(
+      tenantId,
+      billDTO.entries
+    );
+    // Validates the cost entries should be with inventory items.
+    await this.validateCostEntriesShouldBeInventoryItems(
+      tenantId,
+      billDTO.entries
+    );
+    // Transform the bill DTO to model object.
+    const billObj = await this.billDTOToModel(
+      tenantId,
+      billDTO,
+      vendor,
+      authorizedUser
+    );
+    // Write new bill transaction with associated transactions under UOW env.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onBillCreating` event.
+      await this.eventPublisher.emitAsync(events.bill.onCreating, {
+        trx,
+        billDTO,
+        tenantId,
+      } as IBillCreatingPayload);
+
+      // Inserts the bill graph object to the storage.
+      const bill = await Bill.query(trx).upsertGraph(billObj);
+
+      // Triggers `onBillCreated` event.
+      await this.eventPublisher.emitAsync(events.bill.onCreated, {
+        tenantId,
+        bill,
+        billId: bill.id,
+        trx,
+      } as IBillCreatedPayload);
+
+      return bill;
+    });
+  }
+
+  /**
+   * Edits details of the given bill id with associated entries.
+   *
+   * Precedures:
+   * -------
+   * - Update the bill transaction on the storage.
+   * - Update the bill entries on the storage and insert the not have id and delete
+   *   once that not presented.
+   * - Increment the diff amount on the given vendor id.
+   * - Re-write the inventory transactions.
+   * - Re-write the bill journal transactions.
+   * ------
+   * @param {number} tenantId - The given tenant id.
+   * @param {Integer} billId - The given bill id.
+   * @param {IBillEditDTO} billDTO - The given new bill details.
+   * @return {Promise<IBill>}
+   */
+  public async editBill(
+    tenantId: number,
+    billId: number,
+    billDTO: IBillEditDTO,
+    authorizedUser: ISystemUser
+  ): Promise<IBill> {
+    const { Bill, Contact } = this.tenancy.models(tenantId);
+
+    const oldBill = await this.getBillOrThrowError(tenantId, billId);
+
+    // Retrieve vendor details or throw not found service error.
+    const vendor = await Contact.query()
+      .findById(billDTO.vendorId)
+      .modify('vendor')
+      .throwIfNotFound();
+
+    // Validate bill number uniqiness on the storage.
+    if (billDTO.billNumber) {
+      await this.validateBillNumberExists(tenantId, billDTO.billNumber, billId);
+    }
+    // Validate the entries ids existance.
+    await this.itemsEntriesService.validateEntriesIdsExistance(
+      tenantId,
+      billId,
+      'Bill',
+      billDTO.entries
+    );
+    // Validate the items ids existance on the storage.
+    await this.itemsEntriesService.validateItemsIdsExistance(
+      tenantId,
+      billDTO.entries
+    );
+    // Accept the purchasable items only.
+    await this.itemsEntriesService.validateNonPurchasableEntriesItems(
+      tenantId,
+      billDTO.entries
+    );
+    // Transforms the bill DTO to model object.
+    const billObj = await this.billDTOToModel(
+      tenantId,
+      billDTO,
+      vendor,
+      authorizedUser,
+      oldBill
+    );
+    // Validate landed cost entries that have allocated cost could not be deleted.
+    await this.entriesService.validateLandedCostEntriesNotDeleted(
+      oldBill.entries,
+      billObj.entries
+    );
+    // Validate new landed cost entries should be bigger than new entries.
+    await this.entriesService.validateLocatedCostEntriesSmallerThanNewEntries(
+      oldBill.entries,
+      billObj.entries
+    );
+    // Edits bill transactions and associated transactions under UOW envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onBillEditing` event.
+      await this.eventPublisher.emitAsync(events.bill.onEditing, {
+        trx,
+        tenantId,
+        oldBill,
+        billDTO,
+      } as IBillEditingPayload);
+
+      // Update the bill transaction.
+      const bill = await Bill.query(trx).upsertGraph({
+        id: billId,
+        ...billObj,
+      });
+      // Triggers event `onBillEdited`.
+      await this.eventPublisher.emitAsync(events.bill.onEdited, {
+        tenantId,
+        billId,
+        oldBill,
+        bill,
+        trx,
+      } as IBillEditedPayload);
+
+      return bill;
+    });
+  }
+
+  /**
+   * Deletes the bill with associated entries.
+   * @param {Integer} billId
+   * @return {void}
+   */
+  public async deleteBill(tenantId: number, billId: number) {
+    const { ItemEntry, Bill } = this.tenancy.models(tenantId);
+
+    // Retrieve the given bill or throw not found error.
+    const oldBill = await this.getBillOrThrowError(tenantId, billId);
+
+    // Validate the givne bill has no associated landed cost transactions.
+    await this.validateBillHasNoLandedCost(tenantId, billId);
+
+    // Validate the purchase bill has no assocaited payments transactions.
+    await this.validateBillHasNoEntries(tenantId, billId);
+
+    // Validate the given bill has no associated reconciled with vendor credits.
+    await this.validateBillHasNoAppliedToCredit(tenantId, billId);
+
+    // Deletes bill transaction with associated transactions under
+    // unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onBillDeleting` event.
+      await this.eventPublisher.emitAsync(events.bill.onDeleting, {
+        trx,
+        tenantId,
+        oldBill,
+      } as IBillEventDeletingPayload);
+
+      // Delete all associated bill entries.
+      await ItemEntry.query(trx)
+        .where('reference_type', 'Bill')
+        .where('reference_id', billId)
+        .delete();
+
+      // Delete the bill transaction.
+      await Bill.query(trx).findById(billId).delete();
+
+      // Triggers `onBillDeleted` event.
+      await this.eventPublisher.emitAsync(events.bill.onDeleted, {
+        tenantId,
+        billId,
+        oldBill,
+        trx,
+      } as IBIllEventDeletedPayload);
+    });
+  }
+
+  validateBillHasNoAppliedToCredit = async (
+    tenantId: number,
+    billId: number
+  ) => {
+    const { VendorCreditAppliedBill } = this.tenancy.models(tenantId);
+
+    const appliedTransactions = await VendorCreditAppliedBill.query().where(
+      'billId',
+      billId
+    );
+    if (appliedTransactions.length > 0) {
+      throw new ServiceError(ERRORS.BILL_HAS_APPLIED_TO_VENDOR_CREDIT);
+    }
+  };
+
+  /**
+   * Parses bills list filter DTO.
+   * @param filterDTO -
+   */
+  private parseListFilterDTO(filterDTO) {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  }
+
+  /**
+   * Retrieve bills data table list.
+   * @param {number} tenantId -
+   * @param {IBillsFilter} billsFilter -
+   */
+  public async getBills(
+    tenantId: number,
+    filterDTO: IBillsFilter
+  ): Promise<{
+    bills: IBill;
+    pagination: IPaginationMeta;
+    filterMeta: IFilterMeta;
+  }> {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    // Parses bills list filter DTO.
+    const filter = this.parseListFilterDTO(filterDTO);
+
+    // Dynamic list service.
+    const dynamicFilter = await this.dynamicListService.dynamicList(
+      tenantId,
+      Bill,
+      filter
+    );
+    const { results, pagination } = await Bill.query()
+      .onBuild((builder) => {
+        builder.withGraphFetched('vendor');
+        dynamicFilter.buildQuery()(builder);
+      })
+      .pagination(filter.page - 1, filter.pageSize);
+
+    // Tranform the bills to POJO.
+    const bills = await this.transformer.transform(
+      tenantId,
+      results,
+      new PurchaseInvoiceTransformer()
+    );
+    return {
+      bills,
+      pagination,
+      filterMeta: dynamicFilter.getResponseMeta(),
+    };
+  }
+
+  /**
+   * Retrieve all due bills or for specific given vendor id.
+   * @param {number} tenantId -
+   * @param {number} vendorId -
+   */
+  public async getDueBills(
+    tenantId: number,
+    vendorId?: number
+  ): Promise<IBill[]> {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    const dueBills = await Bill.query().onBuild((query) => {
+      query.orderBy('bill_date', 'DESC');
+      query.modify('dueBills');
+
+      if (vendorId) {
+        query.where('vendor_id', vendorId);
+      }
+    });
+    return dueBills;
+  }
+
+  /**
+   * Retrieve the given bill details with associated items entries.
+   * @param {Integer} billId - Specific bill.
+   * @returns {Promise<IBill>}
+   */
+  public async getBill(tenantId: number, billId: number): Promise<IBill> {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    const bill = await Bill.query()
+      .findById(billId)
+      .withGraphFetched('vendor')
+      .withGraphFetched('entries.item')
+      .withGraphFetched('branch');
+
+    if (!bill) {
+      throw new ServiceError(ERRORS.BILL_NOT_FOUND);
+    }
+    return this.transformer.transform(
+      tenantId,
+      bill,
+      new PurchaseInvoiceTransformer()
+    );
+  }
+
+  /**
+   * Mark the bill as open.
+   * @param {number} tenantId
+   * @param {number} billId
+   */
+  public async openBill(tenantId: number, billId: number): Promise<void> {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    // Retrieve the given bill or throw not found error.
+    const oldBill = await this.getBillOrThrowError(tenantId, billId);
+
+    if (oldBill.isOpen) {
+      throw new ServiceError(ERRORS.BILL_ALREADY_OPEN);
+    }
+    //
+    return this.uow.withTransaction(tenantId, async (trx) => {
+      // Record the bill opened at on the storage.
+      await Bill.query(trx).findById(billId).patch({
+        openedAt: moment().toMySqlDateTime(),
+      });
+    });
+  }
+
+  /**
+   * Records the inventory transactions from the given bill input.
+   * @param  {Bill} bill - Bill model object.
+   * @param  {number} billId - Bill id.
+   * @return {Promise<void>}
+   */
+  public async recordInventoryTransactions(
+    tenantId: number,
+    billId: number,
+    override?: boolean,
+    trx?: Knex.Transaction
+  ): Promise<void> {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    // Retireve bill with assocaited entries and allocated cost entries.
+    const bill = await Bill.query(trx)
+      .findById(billId)
+      .withGraphFetched('entries.allocatedCostEntries');
+
+    // Loads the inventory items entries of the given sale invoice.
+    const inventoryEntries =
+      await this.itemsEntriesService.filterInventoryEntries(
+        tenantId,
+        bill.entries
+      );
+    const transaction = {
+      transactionId: bill.id,
+      transactionType: 'Bill',
+      exchangeRate: bill.exchangeRate,
+
+      date: bill.billDate,
+      direction: 'IN',
+      entries: inventoryEntries,
+      createdAt: bill.createdAt,
+
+      warehouseId: bill.warehouseId,
+    };
+    await this.inventoryService.recordInventoryTransactionsFromItemsEntries(
+      tenantId,
+      transaction,
+      override,
+      trx
+    );
+  }
+
+  /**
+   * Reverts the inventory transactions of the given bill id.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} billId - Bill id.
+   * @return {Promise<void>}
+   */
+  public async revertInventoryTransactions(
+    tenantId: number,
+    billId: number,
+    trx?: Knex.Transaction
+  ) {
+    // Deletes the inventory transactions by the given reference id and type.
+    await this.inventoryService.deleteInventoryTransactions(
+      tenantId,
+      billId,
+      'Bill',
+      trx
+    );
+  }
+
+  /**
+   * Validate the given vendor has no associated bills transactions.
+   * @param {number} tenantId
+   * @param {number} vendorId - Vendor id.
+   */
+  public async validateVendorHasNoBills(tenantId: number, vendorId: number) {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    const bills = await Bill.query().where('vendor_id', vendorId);
+
+    if (bills.length > 0) {
+      throw new ServiceError(ERRORS.VENDOR_HAS_BILLS);
+    }
+  }
+}
diff --git a/packages/server/src/services/Purchases/Bills/BillGLEntries.ts b/packages/server/src/services/Purchases/Bills/BillGLEntries.ts
new file mode 100644
index 000000000..ebfbc8da8
--- /dev/null
+++ b/packages/server/src/services/Purchases/Bills/BillGLEntries.ts
@@ -0,0 +1,219 @@
+import moment from 'moment';
+import { sumBy } from 'lodash';
+import { Knex } from 'knex';
+import { Inject, Service } from 'typedi';
+import * as R from 'ramda';
+import { AccountNormal, IBill, IItemEntry, ILedgerEntry } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import Ledger from '@/services/Accounting/Ledger';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+
+@Service()
+export class BillGLEntries {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private ledgerStorage: LedgerStorageService;
+
+  /**
+   * Creates bill GL entries.
+   * @param {number} tenantId -
+   * @param {number} billId -
+   * @param {Knex.Transaction} trx -
+   */
+  public writeBillGLEntries = async (
+    tenantId: number,
+    billId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+    const { Bill } = this.tenancy.models(tenantId);
+
+    // Retrieves bill with associated entries and landed costs.
+    const bill = await Bill.query(trx)
+      .findById(billId)
+      .withGraphFetched('entries.item')
+      .withGraphFetched('entries.allocatedCostEntries')
+      .withGraphFetched('locatedLandedCosts.allocateEntries');
+
+    // Finds or create a A/P account based on the given currency.
+    const APAccount = await accountRepository.findOrCreateAccountsPayable(
+      bill.currencyCode,
+      {},
+      trx
+    );
+    const billLedger = this.getBillLedger(bill, APAccount.id);
+
+    // Commit the GL enties on the storage.
+    await this.ledgerStorage.commit(tenantId, billLedger, trx);
+  };
+
+  /**
+   * Reverts the given bill GL entries.
+   * @param {number} tenantId
+   * @param {number} billId
+   * @param {Knex.Transaction} trx
+   */
+  public revertBillGLEntries = async (
+    tenantId: number,
+    billId: number,
+    trx?: Knex.Transaction
+  ) => {
+    await this.ledgerStorage.deleteByReference(tenantId, billId, 'Bill', trx);
+  };
+
+  /**
+   * Rewrites the given bill GL entries.
+   * @param {number} tenantId
+   * @param {number} billId
+   * @param {Knex.Transaction} trx
+   */
+  public rewriteBillGLEntries = async (
+    tenantId: number,
+    billId: number,
+    trx?: Knex.Transaction
+  ) => {
+    // Reverts the bill GL entries.
+    await this.revertBillGLEntries(tenantId, billId, trx);
+
+    // Writes the bill GL entries.
+    await this.writeBillGLEntries(tenantId, billId, trx);
+  };
+
+  /**
+   * Retrieves the bill common entry.
+   * @param   {IBill} bill
+   * @returns {ILedgerEntry}
+   */
+  private getBillCommonEntry = (bill: IBill) => {
+    return {
+      debit: 0,
+      credit: 0,
+      currencyCode: bill.currencyCode,
+      exchangeRate: bill.exchangeRate || 1,
+
+      transactionId: bill.id,
+      transactionType: 'Bill',
+
+      date: moment(bill.billDate).format('YYYY-MM-DD'),
+      userId: bill.userId,
+
+      referenceNumber: bill.referenceNo,
+      transactionNumber: bill.billNumber,
+
+      branchId: bill.branchId,
+      projectId: bill.projectId,
+
+      createdAt: bill.createdAt,
+    };
+  };
+
+  /**
+   * Retrieves the bill item inventory/cost entry.
+   * @param {IBill} bill -
+   * @param {IItemEntry} entry -
+   * @param {number} index -
+   */
+  private getBillItemEntry = R.curry(
+    (bill: IBill, entry: IItemEntry, index: number): ILedgerEntry => {
+      const commonJournalMeta = this.getBillCommonEntry(bill);
+
+      const localAmount = bill.exchangeRate * entry.amount;
+      const landedCostAmount = sumBy(entry.allocatedCostEntries, 'cost');
+
+      return {
+        ...commonJournalMeta,
+        debit: localAmount + landedCostAmount,
+        accountId:
+          ['inventory'].indexOf(entry.item.type) !== -1
+            ? entry.item.inventoryAccountId
+            : entry.costAccountId,
+        index: index + 1,
+        indexGroup: 10,
+        itemId: entry.itemId,
+        itemQuantity: entry.quantity,
+        accountNormal: AccountNormal.DEBIT,
+      };
+    }
+  );
+
+  /**
+   * Retrieves the bill landed cost entry.
+   * @param {IBill} bill -
+   * @param {} landedCost -
+   * @param {number} index -
+   */
+  private getBillLandedCostEntry = R.curry(
+    (bill: IBill, landedCost, index: number): ILedgerEntry => {
+      const commonJournalMeta = this.getBillCommonEntry(bill);
+
+      return {
+        ...commonJournalMeta,
+        credit: landedCost.amount,
+        accountId: landedCost.costAccountId,
+        accountNormal: AccountNormal.DEBIT,
+        index: 1,
+        indexGroup: 20,
+      };
+    }
+  );
+
+  /**
+   * Retrieves the bill payable entry.
+   * @param   {number} payableAccountId
+   * @param   {IBill} bill
+   * @returns {ILedgerEntry}
+   */
+  private getBillPayableEntry = (
+    payableAccountId: number,
+    bill: IBill
+  ): ILedgerEntry => {
+    const commonJournalMeta = this.getBillCommonEntry(bill);
+
+    return {
+      ...commonJournalMeta,
+      credit: bill.localAmount,
+      accountId: payableAccountId,
+      contactId: bill.vendorId,
+      accountNormal: AccountNormal.CREDIT,
+      index: 1,
+      indexGroup: 5,
+    };
+  };
+
+  /**
+   * Retrieves the given bill GL entries.
+   * @param   {IBill} bill
+   * @param   {number} payableAccountId
+   * @returns {ILedgerEntry[]}
+   */
+  private getBillGLEntries = (
+    bill: IBill,
+    payableAccountId: number
+  ): ILedgerEntry[] => {
+    const payableEntry = this.getBillPayableEntry(payableAccountId, bill);
+
+    const itemEntryTransformer = this.getBillItemEntry(bill);
+    const landedCostTransformer = this.getBillLandedCostEntry(bill);
+
+    const itemsEntries = bill.entries.map(itemEntryTransformer);
+    const landedCostEntries = bill.locatedLandedCosts.map(
+      landedCostTransformer
+    );
+    // Allocate cost entries journal entries.
+    return [payableEntry, ...itemsEntries, ...landedCostEntries];
+  };
+
+  /**
+   * Retrieves the given bill ledger.
+   * @param   {IBill} bill
+   * @param   {number} payableAccountId
+   * @returns {Ledger}
+   */
+  private getBillLedger = (bill: IBill, payableAccountId: number) => {
+    const entries = this.getBillGLEntries(bill, payableAccountId);
+
+    return new Ledger(entries);
+  };
+}
diff --git a/packages/server/src/services/Purchases/Bills/BillGLEntriesSubscriber.ts b/packages/server/src/services/Purchases/Bills/BillGLEntriesSubscriber.ts
new file mode 100644
index 000000000..8658c0f81
--- /dev/null
+++ b/packages/server/src/services/Purchases/Bills/BillGLEntriesSubscriber.ts
@@ -0,0 +1,70 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import BillsService from '@/services/Purchases/Bills';
+import {
+  IBillCreatedPayload,
+  IBillEditedPayload,
+  IBIllEventDeletedPayload,
+} from '@/interfaces';
+import { BillGLEntries } from './BillGLEntries';
+
+@Service()
+export class BillGLEntriesSubscriber {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  billGLEntries: BillGLEntries;
+
+  /**
+   * Attachs events with handles.
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.bill.onCreated,
+      this.handlerWriteJournalEntriesOnCreate
+    );
+    bus.subscribe(
+      events.bill.onEdited,
+      this.handleOverwriteJournalEntriesOnEdit
+    );
+    bus.subscribe(events.bill.onDeleted, this.handlerDeleteJournalEntries);
+  }
+
+  /**
+   * Handles writing journal entries once bill created.
+   * @param {IBillCreatedPayload} payload -
+   */
+  private handlerWriteJournalEntriesOnCreate = async ({
+    tenantId,
+    billId,
+    trx,
+  }: IBillCreatedPayload) => {
+    await this.billGLEntries.writeBillGLEntries(tenantId, billId, trx);
+  };
+
+  /**
+   * Handles the overwriting journal entries once bill edited.
+   * @param {IBillEditedPayload} payload -
+   */
+  private handleOverwriteJournalEntriesOnEdit = async ({
+    tenantId,
+    billId,
+    trx,
+  }: IBillEditedPayload) => {
+    await this.billGLEntries.rewriteBillGLEntries(tenantId, billId, trx);
+  };
+
+  /**
+   * Handles revert journal entries on bill deleted.
+   * @param {IBIllEventDeletedPayload} payload -
+   */
+  private handlerDeleteJournalEntries = async ({
+    tenantId,
+    billId,
+    trx,
+  }: IBIllEventDeletedPayload) => {
+    await this.billGLEntries.revertBillGLEntries(tenantId, billId, trx);
+  };
+}
diff --git a/packages/server/src/services/Purchases/Bills/BillPaymentsGLEntriesRewrite.ts b/packages/server/src/services/Purchases/Bills/BillPaymentsGLEntriesRewrite.ts
new file mode 100644
index 000000000..66ca5b841
--- /dev/null
+++ b/packages/server/src/services/Purchases/Bills/BillPaymentsGLEntriesRewrite.ts
@@ -0,0 +1,76 @@
+import { Knex } from 'knex';
+import async from 'async';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+import { BillPaymentGLEntries } from '../BillPayments/BillPaymentGLEntries';
+
+@Service()
+export class BillPaymentsGLEntriesRewrite {
+  @Inject()
+  public tenancy: HasTenancyService;
+
+  @Inject()
+  public paymentGLEntries: BillPaymentGLEntries;
+
+  /**
+   * Rewrites payments GL entries that associated to the given bill.
+   * @param {number} tenantId
+   * @param {number} billId
+   * @param {Knex.Transaction} trx
+   */
+  public rewriteBillPaymentsGLEntries = async (
+    tenantId: number,
+    billId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { BillPaymentEntry } = this.tenancy.models(tenantId);
+
+    const billPaymentEntries = await BillPaymentEntry.query().where(
+      'billId',
+      billId
+    );
+    const paymentsIds = billPaymentEntries.map((e) => e.billPaymentId);
+
+    await this.rewritePaymentsGLEntriesQueue(tenantId, paymentsIds, trx);
+  };
+
+  /**
+   * Rewrites the payments GL entries under async queue.
+   * @param {number} tenantId
+   * @param {number[]} paymentsIds
+   * @param {Knex.Transaction} trx
+   */
+  public rewritePaymentsGLEntriesQueue = async (
+    tenantId: number,
+    paymentsIds: number[],
+    trx?: Knex.Transaction
+  ) => {
+    // Initiate a new queue for accounts balance mutation.
+    const rewritePaymentGL = async.queue(this.rewritePaymentsGLEntriesTask, 10);
+
+    paymentsIds.forEach((paymentId: number) => {
+      rewritePaymentGL.push({ paymentId, trx, tenantId });
+    });
+    //
+    if (paymentsIds.length > 0) await rewritePaymentGL.drain();
+  };
+
+  /**
+   * Rewrites the payments GL entries task.
+   * @param {number} tenantId -
+   * @param {number} paymentId -
+   * @param {Knex.Transaction} trx -
+   * @returns {Promise<void>}
+   */
+  public rewritePaymentsGLEntriesTask = async ({
+    tenantId,
+    paymentId,
+    trx,
+  }) => {
+    await this.paymentGLEntries.rewritePaymentGLEntries(
+      tenantId,
+      paymentId,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/Bills/BillPaymentsGLEntriesRewriteSubscriber.ts b/packages/server/src/services/Purchases/Bills/BillPaymentsGLEntriesRewriteSubscriber.ts
new file mode 100644
index 000000000..f670f7b38
--- /dev/null
+++ b/packages/server/src/services/Purchases/Bills/BillPaymentsGLEntriesRewriteSubscriber.ts
@@ -0,0 +1,36 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import { IBillEditedPayload } from '@/interfaces';
+import { BillPaymentsGLEntriesRewrite } from './BillPaymentsGLEntriesRewrite';
+
+@Service()
+export class BillPaymentsGLEntriesRewriteSubscriber {
+  @Inject()
+  private billPaymentGLEntriesRewrite: BillPaymentsGLEntriesRewrite;
+
+  /**
+   * Attachs events with handles.
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.bill.onEdited,
+      this.handlerRewritePaymentsGLOnBillEdited
+    );
+  }
+
+  /**
+   * Handles writing journal entries once bill created.
+   * @param {IBillCreatedPayload} payload -
+   */
+  private handlerRewritePaymentsGLOnBillEdited = async ({
+    tenantId,
+    billId,
+    trx,
+  }: IBillEditedPayload) => {
+    await this.billPaymentGLEntriesRewrite.rewriteBillPaymentsGLEntries(
+      tenantId,
+      billId,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/LandedCost/AllocateLandedCost.ts b/packages/server/src/services/Purchases/LandedCost/AllocateLandedCost.ts
new file mode 100644
index 000000000..5aaf8fde6
--- /dev/null
+++ b/packages/server/src/services/Purchases/LandedCost/AllocateLandedCost.ts
@@ -0,0 +1,101 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import {
+  IAllocatedLandedCostCreatedPayload,
+  IBillLandedCost,
+  ILandedCostDTO,
+} from '@/interfaces';
+import BaseLandedCostService from './BaseLandedCost';
+import events from '@/subscribers/events';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+@Service()
+export default class AllocateLandedCost extends BaseLandedCostService {
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  /**
+   * =================================
+   * - Allocate landed cost.
+   * =================================
+   * - Validates the allocate cost not the same purchase invoice id.
+   * - Get the given bill (purchase invoice) or throw not found error.
+   * - Get the given landed cost transaction or throw not found error.
+   * - Validate landed cost transaction has enough unallocated cost amount.
+   * - Validate landed cost transaction entry has enough unallocated cost amount.
+   * - Validate allocate entries existance and associated with cost bill transaction.
+   * - Writes inventory landed cost transaction.
+   * - Increment the allocated landed cost transaction.
+   * - Increment the allocated landed cost transaction entry.
+   * --------------------------------
+   * @param {ILandedCostDTO} landedCostDTO - Landed cost DTO.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} billId - Purchase invoice id.
+   */
+  public allocateLandedCost = async (
+    tenantId: number,
+    allocateCostDTO: ILandedCostDTO,
+    billId: number
+  ): Promise<IBillLandedCost> => {
+    const { BillLandedCost } = this.tenancy.models(tenantId);
+
+    // Retrieve total cost of allocated items.
+    const amount = this.getAllocateItemsCostTotal(allocateCostDTO);
+
+    // Retrieve the purchase invoice or throw not found error.
+    const bill = await this.billsService.getBillOrThrowError(tenantId, billId);
+
+    // Retrieve landed cost transaction or throw not found service error.
+    const costTransaction = await this.getLandedCostOrThrowError(
+      tenantId,
+      allocateCostDTO.transactionType,
+      allocateCostDTO.transactionId
+    );
+    // Retrieve landed cost transaction entries.
+    const costTransactionEntry = await this.getLandedCostEntry(
+      tenantId,
+      allocateCostDTO.transactionType,
+      allocateCostDTO.transactionId,
+      allocateCostDTO.transactionEntryId
+    );
+    // Validates allocate cost items association with the purchase invoice entries.
+    this.validateAllocateCostItems(bill.entries, allocateCostDTO.items);
+
+    // Validate the amount of cost with unallocated landed cost.
+    this.validateLandedCostEntryAmount(
+      costTransactionEntry.unallocatedCostAmount,
+      amount
+    );
+    // Transformes DTO to bill landed cost model object.
+    const billLandedCostObj = this.transformToBillLandedCost(
+      allocateCostDTO,
+      bill,
+      costTransaction,
+      costTransactionEntry
+    );
+    // Saves landed cost transactions with associated tranasctions under
+    // unit-of-work eniverment.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Save the bill landed cost model.
+      const billLandedCost = await BillLandedCost.query(trx).insertGraph(
+        billLandedCostObj
+      );
+      // Triggers `onBillLandedCostCreated` event.
+      await this.eventPublisher.emitAsync(events.billLandedCost.onCreated, {
+        tenantId,
+        bill,
+        billLandedCostId: billLandedCost.id,
+        billLandedCost,
+        costTransaction,
+        costTransactionEntry,
+        trx,
+      } as IAllocatedLandedCostCreatedPayload);
+
+      return billLandedCost;
+    });
+  };
+}
diff --git a/packages/server/src/services/Purchases/LandedCost/BaseLandedCost.ts b/packages/server/src/services/Purchases/LandedCost/BaseLandedCost.ts
new file mode 100644
index 000000000..9bef3dd53
--- /dev/null
+++ b/packages/server/src/services/Purchases/LandedCost/BaseLandedCost.ts
@@ -0,0 +1,200 @@
+import { Inject, Service } from 'typedi';
+import { difference, sumBy } from 'lodash';
+import BillsService from '../Bills';
+import { ServiceError } from '@/exceptions';
+import {
+  IItemEntry,
+  IBill,
+  ILandedCostItemDTO,
+  ILandedCostDTO,
+  IBillLandedCostTransaction,
+  ILandedCostTransaction,
+  ILandedCostTransactionEntry,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import TransactionLandedCost from './TransctionLandedCost';
+import { ERRORS } from './utils';
+import { CONFIG } from './utils';
+
+@Service()
+export default class BaseLandedCostService {
+  @Inject()
+  public billsService: BillsService;
+
+  @Inject()
+  public tenancy: HasTenancyService;
+
+  @Inject()
+  public transactionLandedCost: TransactionLandedCost;
+
+  /**
+   * Validates allocate cost items association with the purchase invoice entries.
+   * @param {IItemEntry[]} purchaseInvoiceEntries
+   * @param {ILandedCostItemDTO[]} landedCostItems
+   */
+  protected validateAllocateCostItems = (
+    purchaseInvoiceEntries: IItemEntry[],
+    landedCostItems: ILandedCostItemDTO[]
+  ): void => {
+    // Purchase invoice entries items ids.
+    const purchaseInvoiceItems = purchaseInvoiceEntries.map((e) => e.id);
+    const landedCostItemsIds = landedCostItems.map((item) => item.entryId);
+
+    // Not found items ids.
+    const notFoundItemsIds = difference(
+      purchaseInvoiceItems,
+      landedCostItemsIds
+    );
+    // Throw items ids not found service error.
+    if (notFoundItemsIds.length > 0) {
+      throw new ServiceError(ERRORS.LANDED_COST_ITEMS_IDS_NOT_FOUND);
+    }
+  };
+
+  /**
+   * Transformes DTO to bill landed cost model object.
+   * @param {ILandedCostDTO} landedCostDTO
+   * @param {IBill} bill
+   * @param {ILandedCostTransaction} costTransaction
+   * @param {ILandedCostTransactionEntry} costTransactionEntry
+   * @returns
+   */
+  protected transformToBillLandedCost(
+    landedCostDTO: ILandedCostDTO,
+    bill: IBill,
+    costTransaction: ILandedCostTransaction,
+    costTransactionEntry: ILandedCostTransactionEntry
+  ) {
+    const amount = sumBy(landedCostDTO.items, 'cost');
+
+    return {
+      billId: bill.id,
+
+      fromTransactionType: landedCostDTO.transactionType,
+      fromTransactionId: landedCostDTO.transactionId,
+      fromTransactionEntryId: landedCostDTO.transactionEntryId,
+
+      amount,
+      currencyCode: costTransaction.currencyCode,
+      exchangeRate: costTransaction.exchangeRate || 1,
+
+      allocationMethod: landedCostDTO.allocationMethod,
+      allocateEntries: landedCostDTO.items,
+
+      description: landedCostDTO.description,
+      costAccountId: costTransactionEntry.costAccountId,
+    };
+  }
+
+  /**
+   * Retrieve the cost transaction or throw not found error.
+   * @param {number} tenantId
+   * @param {transactionType} transactionType -
+   * @param {transactionId} transactionId -
+   */
+  public getLandedCostOrThrowError = async (
+    tenantId: number,
+    transactionType: string,
+    transactionId: number
+  ) => {
+    const Model = this.transactionLandedCost.getModel(
+      tenantId,
+      transactionType
+    );
+    const model = await Model.query().findById(transactionId);
+
+    if (!model) {
+      throw new ServiceError(ERRORS.LANDED_COST_TRANSACTION_NOT_FOUND);
+    }
+    return this.transactionLandedCost.transformToLandedCost(
+      transactionType,
+      model
+    );
+  };
+
+  /**
+   * Retrieve the landed cost entries.
+   * @param {number} tenantId
+   * @param {string} transactionType
+   * @param {number} transactionId
+   * @returns
+   */
+  public getLandedCostEntry = async (
+    tenantId: number,
+    transactionType: string,
+    transactionId: number,
+    transactionEntryId: number
+  ): Promise<any> => {
+    const Model = this.transactionLandedCost.getModel(
+      tenantId,
+      transactionType
+    );
+    const relation = CONFIG.COST_TYPES[transactionType].entries;
+
+    const entry = await Model.relatedQuery(relation)
+      .for(transactionId)
+      .findOne('id', transactionEntryId)
+      .where('landedCost', true)
+      .onBuild((q) => {
+        if (transactionType === 'Bill') {
+          q.withGraphFetched('item');
+        } else if (transactionType === 'Expense') {
+          q.withGraphFetched('expenseAccount');
+        }
+      });
+
+    if (!entry) {
+      throw new ServiceError(ERRORS.LANDED_COST_ENTRY_NOT_FOUND);
+    }
+    return this.transactionLandedCost.transformToLandedCostEntry(
+      transactionType,
+      entry
+    );
+  };
+
+  /**
+   * Retrieve allocate items cost total.
+   * @param {ILandedCostDTO} landedCostDTO
+   * @returns {number}
+   */
+  protected getAllocateItemsCostTotal = (
+    landedCostDTO: ILandedCostDTO
+  ): number => {
+    return sumBy(landedCostDTO.items, 'cost');
+  };
+
+  /**
+   * Validates the landed cost entry amount.
+   * @param {number} unallocatedCost -
+   * @param {number} amount -
+   */
+  protected validateLandedCostEntryAmount = (
+    unallocatedCost: number,
+    amount: number
+  ): void => {
+    if (unallocatedCost < amount) {
+      throw new ServiceError(ERRORS.COST_AMOUNT_BIGGER_THAN_UNALLOCATED_AMOUNT);
+    }
+  };
+
+  /**
+   * Retrieve the give bill landed cost or throw not found service error.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} landedCostId - Landed cost id.
+   * @returns {Promise<IBillLandedCost>}
+   */
+  public getBillLandedCostOrThrowError = async (
+    tenantId: number,
+    landedCostId: number
+  ): Promise<IBillLandedCostTransaction> => {
+    const { BillLandedCost } = this.tenancy.models(tenantId);
+
+    // Retrieve the bill landed cost model.
+    const billLandedCost = await BillLandedCost.query().findById(landedCostId);
+
+    if (!billLandedCost) {
+      throw new ServiceError(ERRORS.BILL_LANDED_COST_NOT_FOUND);
+    }
+    return billLandedCost;
+  };
+}
diff --git a/packages/server/src/services/Purchases/LandedCost/BillAllocatedLandedCostTransactions.ts b/packages/server/src/services/Purchases/LandedCost/BillAllocatedLandedCostTransactions.ts
new file mode 100644
index 000000000..29b843e7a
--- /dev/null
+++ b/packages/server/src/services/Purchases/LandedCost/BillAllocatedLandedCostTransactions.ts
@@ -0,0 +1,170 @@
+import { Inject, Service } from 'typedi';
+import { omit } from 'lodash';
+import * as R from 'ramda';
+import * as qim from 'qim';
+import { IBillLandedCostTransaction } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { formatNumber } from 'utils';
+import I18nService from '@/services/I18n/I18nService';
+
+@Service()
+export default class BillAllocatedLandedCostTransactions {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private i18nService: I18nService;
+
+  /**
+   * Retrieve the bill associated landed cost transactions.
+   * @param  {number} tenantId - Tenant id.
+   * @param  {number} billId - Bill id.
+   * @return {Promise<IBillLandedCostTransaction>}
+   */
+  public getBillLandedCostTransactions = async (
+    tenantId: number,
+    billId: number
+  ): Promise<IBillLandedCostTransaction> => {
+    const { BillLandedCost, Bill } = this.tenancy.models(tenantId);
+
+    // Retrieve the given bill id or throw not found service error.
+    const bill = await Bill.query().findById(billId).throwIfNotFound();
+
+    // Retrieve the bill associated allocated landed cost with bill and expense entry.
+    const landedCostTransactions = await BillLandedCost.query()
+      .where('bill_id', billId)
+      .withGraphFetched('allocateEntries')
+      .withGraphFetched('allocatedFromBillEntry.item')
+      .withGraphFetched('allocatedFromExpenseEntry.expenseAccount')
+      .withGraphFetched('bill');
+
+    const transactionsJson = this.i18nService.i18nApply(
+      [[qim.$each, 'allocationMethodFormatted']],
+      landedCostTransactions.map((a) => a.toJSON()),
+      tenantId
+    );
+    return this.transformBillLandedCostTransactions(transactionsJson);
+  };
+
+  /**
+   *
+   * @param {IBillLandedCostTransaction[]} landedCostTransactions
+   * @returns
+   */
+  private transformBillLandedCostTransactions = (
+    landedCostTransactions: IBillLandedCostTransaction[]
+  ) => {
+    return landedCostTransactions.map(this.transformBillLandedCostTransaction);
+  };
+
+  /**
+   *
+   * @param {IBillLandedCostTransaction} transaction
+   * @returns
+   */
+  private transformBillLandedCostTransaction = (
+    transaction: IBillLandedCostTransaction
+  ) => {
+    const getTransactionName = R.curry(this.condBillLandedTransactionName)(
+      transaction.fromTransactionType
+    );
+    const getTransactionDesc = R.curry(
+      this.condBillLandedTransactionDescription
+    )(transaction.fromTransactionType);
+
+    return {
+      formattedAmount: formatNumber(transaction.amount, {
+        currencyCode: transaction.currencyCode,
+      }),
+      ...omit(transaction, [
+        'allocatedFromBillEntry',
+        'allocatedFromExpenseEntry',
+      ]),
+      name: getTransactionName(transaction),
+      description: getTransactionDesc(transaction),
+      formattedLocalAmount: formatNumber(transaction.localAmount, {
+        currencyCode: 'USD',
+      }),
+    };
+  };
+
+  /**
+   * Retrieve bill landed cost tranaction name based on the given transaction type.
+   * @param transactionType
+   * @param transaction
+   * @returns
+   */
+  private condBillLandedTransactionName = (
+    transactionType: string,
+    transaction
+  ) => {
+    return R.cond([
+      [
+        R.always(R.equals(transactionType, 'Bill')),
+        this.getLandedBillTransactionName,
+      ],
+      [
+        R.always(R.equals(transactionType, 'Expense')),
+        this.getLandedExpenseTransactionName,
+      ],
+    ])(transaction);
+  };
+
+  /**
+   *
+   * @param transaction
+   * @returns
+   */
+  private getLandedBillTransactionName = (transaction): string => {
+    return transaction.allocatedFromBillEntry.item.name;
+  };
+
+  /**
+   *
+   * @param transaction
+   * @returns
+   */
+  private getLandedExpenseTransactionName = (transaction): string => {
+    return transaction.allocatedFromExpenseEntry.expenseAccount.name;
+  };
+
+  /**
+   * Retrieve landed cost.
+   * @param transaction
+   * @returns
+   */
+  private getLandedBillTransactionDescription = (transaction): string => {
+    return transaction.allocatedFromBillEntry.description;
+  };
+
+  /**
+   *
+   * @param transaction
+   * @returns
+   */
+  private getLandedExpenseTransactionDescription = (transaction): string => {
+    return transaction.allocatedFromExpenseEntry.description;
+  };
+
+  /**
+   * Retrieve the bill landed cost transaction description based on transaction type.
+   * @param {string} tranasctionType
+   * @param transaction
+   * @returns
+   */
+  private condBillLandedTransactionDescription = (
+    tranasctionType: string,
+    transaction
+  ) => {
+    return R.cond([
+      [
+        R.always(R.equals(tranasctionType, 'Bill')),
+        this.getLandedBillTransactionDescription,
+      ],
+      [
+        R.always(R.equals(tranasctionType, 'Expense')),
+        this.getLandedExpenseTransactionDescription,
+      ],
+    ])(transaction);
+  };
+}
diff --git a/packages/server/src/services/Purchases/LandedCost/BillLandedCost.ts b/packages/server/src/services/Purchases/LandedCost/BillLandedCost.ts
new file mode 100644
index 000000000..ebe8b308b
--- /dev/null
+++ b/packages/server/src/services/Purchases/LandedCost/BillLandedCost.ts
@@ -0,0 +1,58 @@
+import { Service } from 'typedi';
+import { isEmpty } from 'lodash';
+import {
+  IBill,
+  IItem,
+  ILandedCostTransactionEntry,
+  ILandedCostTransaction,
+  IItemEntry,
+} from '@/interfaces';
+
+@Service()
+export default class BillLandedCost {
+  /**
+   * Retrieve the landed cost transaction from the given bill transaction.
+   * @param   {IBill} bill - Bill transaction.
+   * @returns {ILandedCostTransaction} - Landed cost transaction.
+   */
+  public transformToLandedCost = (bill: IBill): ILandedCostTransaction => {
+    const name = bill.billNumber || bill.referenceNo;
+
+    return {
+      id: bill.id,
+      name,
+      allocatedCostAmount: bill.allocatedCostAmount,
+      amount: bill.landedCostAmount,
+      unallocatedCostAmount: bill.unallocatedCostAmount,
+      transactionType: 'Bill',
+      currencyCode: bill.currencyCode,
+      exchangeRate: bill.exchangeRate,
+
+      ...(!isEmpty(bill.entries) && {
+        entries: bill.entries.map(this.transformToLandedCostEntry),
+      }),
+    };
+  };
+
+  /**
+   * Transformes bill entry to landed cost entry.
+   * @param {IBill} bill - Bill model.
+   * @param {IItemEntry} billEntry - Bill entry.
+   * @return {ILandedCostTransactionEntry}
+   */
+  public transformToLandedCostEntry(
+    billEntry: IItemEntry & { item: IItem }
+  ): ILandedCostTransactionEntry {
+    return {
+      id: billEntry.id,
+      name: billEntry.item.name,
+      code: billEntry.item.code,
+      amount: billEntry.amount,
+
+      unallocatedCostAmount: billEntry.unallocatedCostAmount,
+      allocatedCostAmount: billEntry.allocatedCostAmount,
+      description: billEntry.description,
+      costAccountId: billEntry.costAccountId || billEntry.item.costAccountId,
+    };
+  }
+}
diff --git a/packages/server/src/services/Purchases/LandedCost/ExpenseLandedCost.ts b/packages/server/src/services/Purchases/LandedCost/ExpenseLandedCost.ts
new file mode 100644
index 000000000..b9d1c3613
--- /dev/null
+++ b/packages/server/src/services/Purchases/LandedCost/ExpenseLandedCost.ts
@@ -0,0 +1,59 @@
+import { Service } from 'typedi';
+import { isEmpty } from 'lodash';
+import * as R from 'ramda';
+import {
+  IExpense,
+  ILandedCostTransactionEntry,
+  IExpenseCategory,
+  IAccount,
+  ILandedCostTransaction,
+} from '@/interfaces';
+
+@Service()
+export default class ExpenseLandedCost {
+  /**
+   * Retrieve the landed cost transaction from the given expense transaction.
+   * @param {IExpense} expense
+   * @returns {ILandedCostTransaction}
+   */
+  public transformToLandedCost = (
+    expense: IExpense
+  ): ILandedCostTransaction => {
+    const name = 'EXP-100';
+
+    return {
+      id: expense.id,
+      name,
+      amount: expense.landedCostAmount,
+      allocatedCostAmount: expense.allocatedCostAmount,
+      unallocatedCostAmount: expense.unallocatedCostAmount,
+      transactionType: 'Expense',
+      currencyCode: expense.currencyCode,
+      exchangeRate: expense.exchangeRate || 1,
+
+      ...(!isEmpty(expense.categories) && {
+        entries: expense.categories.map(this.transformToLandedCostEntry),
+      }),
+    };
+  };
+
+  /**
+   * Transformes expense entry to landed cost entry.
+   * @param {IExpenseCategory & { expenseAccount: IAccount }} expenseEntry -
+   * @return {ILandedCostTransactionEntry}
+   */
+  public transformToLandedCostEntry = (
+    expenseEntry: IExpenseCategory & { expenseAccount: IAccount }
+  ): ILandedCostTransactionEntry => {
+    return {
+      id: expenseEntry.id,
+      name: expenseEntry.expenseAccount.name,
+      code: expenseEntry.expenseAccount.code,
+      amount: expenseEntry.amount,
+      description: expenseEntry.description,
+      allocatedCostAmount: expenseEntry.allocatedCostAmount,
+      unallocatedCostAmount: expenseEntry.unallocatedCostAmount,
+      costAccountId: expenseEntry.expenseAccount.id,
+    };
+  };
+}
diff --git a/packages/server/src/services/Purchases/LandedCost/LandedCostGLEntries.ts b/packages/server/src/services/Purchases/LandedCost/LandedCostGLEntries.ts
new file mode 100644
index 000000000..ec007ff03
--- /dev/null
+++ b/packages/server/src/services/Purchases/LandedCost/LandedCostGLEntries.ts
@@ -0,0 +1,249 @@
+import * as R from 'ramda';
+import { Knex } from 'knex';
+import {
+  AccountNormal,
+  IBill,
+  IBillLandedCost,
+  IBillLandedCostEntry,
+  ILandedCostTransactionEntry,
+  ILedger,
+  ILedgerEntry,
+} from '@/interfaces';
+import JournalPosterService from '@/services/Sales/JournalPosterService';
+import { Service, Inject } from 'typedi';
+import LedgerRepository from '@/services/Ledger/LedgerRepository';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import BaseLandedCostService from './BaseLandedCost';
+import Ledger from '@/services/Accounting/Ledger';
+
+@Service()
+export default class LandedCostGLEntries extends BaseLandedCostService {
+  @Inject()
+  private journalService: JournalPosterService;
+
+  @Inject()
+  private ledgerRepository: LedgerRepository;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Retrieves the landed cost GL common entry.
+   * @param   {IBill} bill
+   * @param   {IBillLandedCost} allocatedLandedCost
+   * @returns
+   */
+  private getLandedCostGLCommonEntry = (
+    bill: IBill,
+    allocatedLandedCost: IBillLandedCost
+  ) => {
+    return {
+      date: bill.billDate,
+      currencyCode: allocatedLandedCost.currencyCode,
+      exchangeRate: allocatedLandedCost.exchangeRate,
+
+      transactionType: 'LandedCost',
+      transactionId: allocatedLandedCost.id,
+      transactionNumber: bill.billNumber,
+
+      referenceNumber: bill.referenceNo,
+
+      credit: 0,
+      debit: 0,
+    };
+  };
+
+  /**
+   * Retrieves the landed cost GL inventory entry.
+   * @param   {IBill} bill
+   * @param   {IBillLandedCost} allocatedLandedCost
+   * @param   {IBillLandedCostEntry} allocatedEntry
+   * @returns {ILedgerEntry}
+   */
+  private getLandedCostGLInventoryEntry = (
+    bill: IBill,
+    allocatedLandedCost: IBillLandedCost,
+    allocatedEntry: IBillLandedCostEntry
+  ): ILedgerEntry => {
+    const commonEntry = this.getLandedCostGLCommonEntry(
+      bill,
+      allocatedLandedCost
+    );
+    return {
+      ...commonEntry,
+      debit: allocatedLandedCost.localAmount,
+      accountId: allocatedEntry.itemEntry.item.inventoryAccountId,
+      index: 1,
+      accountNormal: AccountNormal.DEBIT,
+    };
+  };
+
+  /**
+   * Retrieves the landed cost GL cost entry.
+   * @param   {IBill} bill
+   * @param   {IBillLandedCost} allocatedLandedCost
+   * @param   {ILandedCostTransactionEntry} fromTransactionEntry
+   * @returns {ILedgerEntry}
+   */
+  private getLandedCostGLCostEntry = (
+    bill: IBill,
+    allocatedLandedCost: IBillLandedCost,
+    fromTransactionEntry: ILandedCostTransactionEntry
+  ): ILedgerEntry => {
+    const commonEntry = this.getLandedCostGLCommonEntry(
+      bill,
+      allocatedLandedCost
+    );
+    return {
+      ...commonEntry,
+      credit: allocatedLandedCost.localAmount,
+      accountId: fromTransactionEntry.costAccountId,
+      index: 2,
+      accountNormal: AccountNormal.CREDIT,
+    };
+  };
+
+  /**
+   * Retrieve allocated landed cost entry GL entries.
+   * @param   {IBill} bill
+   * @param   {IBillLandedCost} allocatedLandedCost
+   * @param   {ILandedCostTransactionEntry} fromTransactionEntry
+   * @param   {IBillLandedCostEntry} allocatedEntry
+   * @returns {ILedgerEntry}
+   */
+  private getLandedCostGLAllocateEntry = R.curry(
+    (
+      bill: IBill,
+      allocatedLandedCost: IBillLandedCost,
+      fromTransactionEntry: ILandedCostTransactionEntry,
+      allocatedEntry: IBillLandedCostEntry
+    ): ILedgerEntry[] => {
+      const inventoryEntry = this.getLandedCostGLInventoryEntry(
+        bill,
+        allocatedLandedCost,
+        allocatedEntry
+      );
+      const costEntry = this.getLandedCostGLCostEntry(
+        bill,
+        allocatedLandedCost,
+        fromTransactionEntry
+      );
+      return [inventoryEntry, costEntry];
+    }
+  );
+
+  /**
+   * Compose the landed cost GL entries.
+   * @param   {IBillLandedCost} allocatedLandedCost
+   * @param   {IBill} bill
+   * @param   {ILandedCostTransactionEntry} fromTransactionEntry
+   * @returns {ILedgerEntry[]}
+   */
+  public getLandedCostGLEntries = (
+    allocatedLandedCost: IBillLandedCost,
+    bill: IBill,
+    fromTransactionEntry: ILandedCostTransactionEntry
+  ): ILedgerEntry[] => {
+    const getEntry = this.getLandedCostGLAllocateEntry(
+      bill,
+      allocatedLandedCost,
+      fromTransactionEntry
+    );
+    return allocatedLandedCost.allocateEntries.map(getEntry).flat();
+  };
+
+  /**
+   * Retrieves the landed cost GL ledger.
+   * @param   {IBillLandedCost} allocatedLandedCost
+   * @param   {IBill} bill
+   * @param   {ILandedCostTransactionEntry} fromTransactionEntry
+   * @returns {ILedger}
+   */
+  public getLandedCostLedger = (
+    allocatedLandedCost: IBillLandedCost,
+    bill: IBill,
+    fromTransactionEntry: ILandedCostTransactionEntry
+  ): ILedger => {
+    const entries = this.getLandedCostGLEntries(
+      allocatedLandedCost,
+      bill,
+      fromTransactionEntry
+    );
+    return new Ledger(entries);
+  };
+
+  /**
+   * Writes landed cost GL entries to the storage layer.
+   * @param {number} tenantId -
+   */
+  public writeLandedCostGLEntries = async (
+    tenantId: number,
+    allocatedLandedCost: IBillLandedCost,
+    bill: IBill,
+    fromTransactionEntry: ILandedCostTransactionEntry,
+    trx?: Knex.Transaction
+  ) => {
+    const ledgerEntries = this.getLandedCostGLEntries(
+      allocatedLandedCost,
+      bill,
+      fromTransactionEntry
+    );
+    await this.ledgerRepository.saveLedgerEntries(tenantId, ledgerEntries, trx);
+  };
+
+  /**
+   * Generates and writes GL entries of the given landed cost.
+   * @param {number} tenantId
+   * @param {number} billLandedCostId
+   * @param {Knex.Transaction} trx
+   */
+  public createLandedCostGLEntries = async (
+    tenantId: number,
+    billLandedCostId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { BillLandedCost } = this.tenancy.models(tenantId);
+
+    // Retrieve the bill landed cost transacion with associated
+    // allocated entries and items.
+    const allocatedLandedCost = await BillLandedCost.query(trx)
+      .findById(billLandedCostId)
+      .withGraphFetched('bill')
+      .withGraphFetched('allocateEntries.itemEntry.item');
+
+    // Retrieve the allocated from transactione entry.
+    const transactionEntry = await this.getLandedCostEntry(
+      tenantId,
+      allocatedLandedCost.fromTransactionType,
+      allocatedLandedCost.fromTransactionId,
+      allocatedLandedCost.fromTransactionEntryId
+    );
+    // Writes the given landed cost GL entries to the storage layer.
+    await this.writeLandedCostGLEntries(
+      tenantId,
+      allocatedLandedCost,
+      allocatedLandedCost.bill,
+      transactionEntry,
+      trx
+    );
+  };
+
+  /**
+   * Reverts GL entries of the given allocated landed cost transaction.
+   * @param {number} tenantId
+   * @param {number} landedCostId
+   * @param {Knex.Transaction} trx
+   */
+  public revertLandedCostGLEntries = async (
+    tenantId: number,
+    landedCostId: number,
+    trx: Knex.Transaction
+  ) => {
+    await this.journalService.revertJournalTransactions(
+      tenantId,
+      landedCostId,
+      'LandedCost',
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/LandedCost/LandedCostGLEntriesSubscriber.ts b/packages/server/src/services/Purchases/LandedCost/LandedCostGLEntriesSubscriber.ts
new file mode 100644
index 000000000..1218334bd
--- /dev/null
+++ b/packages/server/src/services/Purchases/LandedCost/LandedCostGLEntriesSubscriber.ts
@@ -0,0 +1,57 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import LandedCostGLEntries from './LandedCostGLEntries';
+import {
+  IAllocatedLandedCostCreatedPayload,
+  IAllocatedLandedCostDeletedPayload,
+} from '@/interfaces';
+
+@Service()
+export default class LandedCostGLEntriesSubscriber {
+  @Inject()
+  billLandedCostGLEntries: LandedCostGLEntries;
+
+  attach(bus) {
+    bus.subscribe(
+      events.billLandedCost.onCreated,
+      this.writeGLEntriesOnceLandedCostCreated
+    );
+    bus.subscribe(
+      events.billLandedCost.onDeleted,
+      this.revertGLEnteriesOnceLandedCostDeleted
+    );
+  }
+
+  /**
+   * Writes GL entries once landed cost transaction created.
+   * @param {IAllocatedLandedCostCreatedPayload} payload -
+   */
+  private writeGLEntriesOnceLandedCostCreated = async ({
+    tenantId,
+    billLandedCost,
+    trx,
+  }: IAllocatedLandedCostCreatedPayload) => {
+    await this.billLandedCostGLEntries.createLandedCostGLEntries(
+      tenantId,
+      billLandedCost.id,
+      trx
+    );
+  };
+
+  /**
+   * Reverts GL entries associated to landed cost transaction once deleted.
+   * @param {IAllocatedLandedCostDeletedPayload} payload -
+   */
+  private revertGLEnteriesOnceLandedCostDeleted = async ({
+    tenantId,
+    oldBillLandedCost,
+    billId,
+    trx,
+  }: IAllocatedLandedCostDeletedPayload) => {
+    await this.billLandedCostGLEntries.revertLandedCostGLEntries(
+      tenantId,
+      oldBillLandedCost.id,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/LandedCost/LandedCostInventoryTransactions.ts b/packages/server/src/services/Purchases/LandedCost/LandedCostInventoryTransactions.ts
new file mode 100644
index 000000000..8fe1b5893
--- /dev/null
+++ b/packages/server/src/services/Purchases/LandedCost/LandedCostInventoryTransactions.ts
@@ -0,0 +1,68 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import { IBill, IBillLandedCostTransaction } from '@/interfaces';
+import InventoryService from '@/services/Inventory/Inventory';
+import { mergeLocatedWithBillEntries } from './utils';
+
+@Service()
+export default class LandedCostInventoryTransactions {
+  @Inject()
+  public inventoryService: InventoryService;
+
+  /**
+   * Records inventory transactions.
+   * @param {number} tenantId
+   * @param {IBillLandedCostTransaction} billLandedCost
+   * @param {IBill} bill -
+   */
+  public recordInventoryTransactions = async (
+    tenantId: number,
+    billLandedCost: IBillLandedCostTransaction,
+    bill: IBill,
+    trx?: Knex.Transaction
+  ) => {
+    // Retrieve the merged allocated entries with bill entries.
+    const allocateEntries = mergeLocatedWithBillEntries(
+      billLandedCost.allocateEntries,
+      bill.entries
+    );
+    // Mappes the allocate cost entries to inventory transactions.
+    const inventoryTransactions = allocateEntries.map((allocateEntry) => ({
+      date: bill.billDate,
+      itemId: allocateEntry.entry.itemId,
+      direction: 'IN',
+      quantity: null,
+      rate: allocateEntry.cost,
+      transactionType: 'LandedCost',
+      transactionId: billLandedCost.id,
+      entryId: allocateEntry.entryId,
+    }));
+    // Writes inventory transactions.
+    return this.inventoryService.recordInventoryTransactions(
+      tenantId,
+      inventoryTransactions,
+      false,
+      trx
+    );
+  };
+
+  /**
+   * Deletes the inventory transaction.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} landedCostId - Landed cost id.
+   * @param {Knex.Transaction} trx - Knex transactions.
+   * @returns
+   */
+  public removeInventoryTransactions = (
+    tenantId: number,
+    landedCostId: number,
+    trx?: Knex.Transaction
+  ) => {
+    return this.inventoryService.deleteInventoryTransactions(
+      tenantId,
+      landedCostId,
+      'LandedCost',
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/LandedCost/LandedCostInventoryTransactionsSubscriber.ts b/packages/server/src/services/Purchases/LandedCost/LandedCostInventoryTransactionsSubscriber.ts
new file mode 100644
index 000000000..4a295e89f
--- /dev/null
+++ b/packages/server/src/services/Purchases/LandedCost/LandedCostInventoryTransactionsSubscriber.ts
@@ -0,0 +1,63 @@
+import { Inject, Service } from 'typedi';
+import {
+  IAllocatedLandedCostCreatedPayload,
+  IAllocatedLandedCostDeletedPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import LandedCostInventoryTransactions from './LandedCostInventoryTransactions';
+
+@Service()
+export default class LandedCostInventoryTransactionsSubscriber {
+  @Inject()
+  landedCostInventory: LandedCostInventoryTransactions;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.billLandedCost.onCreated,
+      this.writeInventoryTransactionsOnceCreated
+    );
+    bus.subscribe(
+      events.billLandedCost.onDeleted,
+      this.revertInventoryTransactionsOnceDeleted
+    );
+  }
+
+  /**
+   * Writes inventory transactions of the landed cost transaction once created.
+   * @param {IAllocatedLandedCostCreatedPayload} payload -
+   */
+  private writeInventoryTransactionsOnceCreated = async ({
+    billLandedCost,
+    tenantId,
+    trx,
+    bill,
+  }: IAllocatedLandedCostCreatedPayload) => {
+    // Records the inventory transactions.
+    await this.landedCostInventory.recordInventoryTransactions(
+      tenantId,
+      billLandedCost,
+      bill,
+      trx
+    );
+  };
+
+  /**
+   * Reverts inventory transactions of the landed cost transaction once deleted.
+   * @param {IAllocatedLandedCostDeletedPayload} payload -
+   */
+  private revertInventoryTransactionsOnceDeleted = async ({
+    tenantId,
+    oldBillLandedCost,
+    trx,
+  }: IAllocatedLandedCostDeletedPayload) => {
+    // Removes the inventory transactions.
+    await this.landedCostInventory.removeInventoryTransactions(
+      tenantId,
+      oldBillLandedCost.id,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/LandedCost/LandedCostSyncCostTransactions.ts b/packages/server/src/services/Purchases/LandedCost/LandedCostSyncCostTransactions.ts
new file mode 100644
index 000000000..55a6fe61c
--- /dev/null
+++ b/packages/server/src/services/Purchases/LandedCost/LandedCostSyncCostTransactions.ts
@@ -0,0 +1,76 @@
+import { Knex } from 'knex';
+import { Inject, Service } from 'typedi';
+import TransactionLandedCost from './TransctionLandedCost';
+import { CONFIG } from './utils';
+
+@Service()
+export default class LandedCostSyncCostTransactions {
+  @Inject()
+  transactionLandedCost: TransactionLandedCost;
+
+  /**
+   * Allocate the landed cost amount to cost transactions.
+   * @param {number} tenantId -
+   * @param {string} transactionType
+   * @param {number} transactionId
+   */
+  public incrementLandedCostAmount = async (
+    tenantId: number,
+    transactionType: string,
+    transactionId: number,
+    transactionEntryId: number,
+    amount: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const Model = this.transactionLandedCost.getModel(
+      tenantId,
+      transactionType
+    );
+    const relation = CONFIG.COST_TYPES[transactionType].entries;
+
+    // Increment the landed cost transaction amount.
+    await Model.query(trx)
+      .where('id', transactionId)
+      .increment('allocatedCostAmount', amount);
+
+    // Increment the landed cost entry.
+    await Model.relatedQuery(relation, trx)
+      .for(transactionId)
+      .where('id', transactionEntryId)
+      .increment('allocatedCostAmount', amount);
+  };
+
+  /**
+   * Reverts the landed cost amount to cost transaction.
+   * @param {number} tenantId - Tenant id.
+   * @param {string} transactionType - Transaction type.
+   * @param {number} transactionId - Transaction id.
+   * @param {number} transactionEntryId - Transaction entry id.
+   * @param {number} amount - Amount
+   */
+  public revertLandedCostAmount = async (
+    tenantId: number,
+    transactionType: string,
+    transactionId: number,
+    transactionEntryId: number,
+    amount: number,
+    trx?: Knex.Transaction
+  ) => {
+    const Model = this.transactionLandedCost.getModel(
+      tenantId,
+      transactionType
+    );
+    const relation = CONFIG.COST_TYPES[transactionType].entries;
+
+    // Decrement the allocate cost amount of cost transaction.
+    await Model.query(trx)
+      .where('id', transactionId)
+      .decrement('allocatedCostAmount', amount);
+
+    // Decrement the allocated cost amount cost transaction entry.
+    await Model.relatedQuery(relation, trx)
+      .for(transactionId)
+      .where('id', transactionEntryId)
+      .decrement('allocatedCostAmount', amount);
+  };
+}
diff --git a/packages/server/src/services/Purchases/LandedCost/LandedCostSyncCostTransactionsSubscriber.ts b/packages/server/src/services/Purchases/LandedCost/LandedCostSyncCostTransactionsSubscriber.ts
new file mode 100644
index 000000000..4fa1470b5
--- /dev/null
+++ b/packages/server/src/services/Purchases/LandedCost/LandedCostSyncCostTransactionsSubscriber.ts
@@ -0,0 +1,67 @@
+import { Service, Inject } from 'typedi';
+import {
+  IAllocatedLandedCostCreatedPayload,
+  IAllocatedLandedCostDeletedPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import LandedCostSyncCostTransactions from './LandedCostSyncCostTransactions';
+
+@Service()
+export default class LandedCostSyncCostTransactionsSubscriber {
+  @Inject()
+  landedCostSyncCostTransaction: LandedCostSyncCostTransactions;
+
+  /**
+   * Attaches events with handlers.
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.billLandedCost.onCreated,
+      this.incrementCostTransactionsOnceCreated
+    );
+    bus.subscribe(
+      events.billLandedCost.onDeleted,
+      this.decrementCostTransactionsOnceDeleted
+    );
+  }
+
+  /**
+   * Increment cost transactions once the landed cost allocated.
+   * @param {IAllocatedLandedCostCreatedPayload} payload -
+   */
+  private incrementCostTransactionsOnceCreated = async ({
+    tenantId,
+    billLandedCost,
+    trx,
+  }: IAllocatedLandedCostCreatedPayload) => {
+    // Increment landed cost amount on transaction and entry.
+    await this.landedCostSyncCostTransaction.incrementLandedCostAmount(
+      tenantId,
+      billLandedCost.fromTransactionType,
+      billLandedCost.fromTransactionId,
+      billLandedCost.fromTransactionEntryId,
+      billLandedCost.amount,
+      trx
+    );
+  };
+
+  /**
+   * Decrement cost transactions once the allocated landed cost reverted.
+   * @param {IAllocatedLandedCostDeletedPayload} payload -
+   */
+  private decrementCostTransactionsOnceDeleted = async ({
+    oldBillLandedCost,
+    tenantId,
+    trx,
+  }: IAllocatedLandedCostDeletedPayload) => {
+    // Reverts the landed cost amount to the cost transaction.
+    await this.landedCostSyncCostTransaction.revertLandedCostAmount(
+      tenantId,
+      oldBillLandedCost.fromTransactionType,
+      oldBillLandedCost.fromTransactionId,
+      oldBillLandedCost.fromTransactionEntryId,
+      oldBillLandedCost.amount,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/LandedCost/LandedCostTransactions.ts b/packages/server/src/services/Purchases/LandedCost/LandedCostTransactions.ts
new file mode 100644
index 000000000..041ffce32
--- /dev/null
+++ b/packages/server/src/services/Purchases/LandedCost/LandedCostTransactions.ts
@@ -0,0 +1,140 @@
+import { Inject, Service } from 'typedi';
+import { ref } from 'objection';
+import * as R from 'ramda';
+import {
+  ILandedCostTransactionsQueryDTO,
+  ILandedCostTransaction,
+  ILandedCostTransactionDOJO,
+  ILandedCostTransactionEntry,
+  ILandedCostTransactionEntryDOJO,
+} from '@/interfaces';
+import TransactionLandedCost from './TransctionLandedCost';
+import BillsService from '../Bills';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { formatNumber } from 'utils';
+
+@Service()
+export default class LandedCostTranasctions {
+  @Inject()
+  transactionLandedCost: TransactionLandedCost;
+
+  @Inject()
+  billsService: BillsService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve the landed costs based on the given query.
+   * @param {number} tenantId
+   * @param {ILandedCostTransactionsQueryDTO} query
+   * @returns {Promise<ILandedCostTransaction[]>}
+   */
+  public getLandedCostTransactions = async (
+    tenantId: number,
+    query: ILandedCostTransactionsQueryDTO
+  ): Promise<ILandedCostTransaction[]> => {
+    const { transactionType } = query;
+    const Model = this.transactionLandedCost.getModel(
+      tenantId,
+      query.transactionType
+    );
+    // Retrieve the model entities.
+    const transactions = await Model.query().onBuild((q) => {
+      q.where('allocated_cost_amount', '<', ref('landed_cost_amount'));
+
+      if (query.transactionType === 'Bill') {
+        q.withGraphFetched('entries.item');
+      } else if (query.transactionType === 'Expense') {
+        q.withGraphFetched('categories.expenseAccount');
+      }
+    });
+    const transformLandedCost =
+      this.transactionLandedCost.transformToLandedCost(transactionType);
+
+    return R.compose(
+      this.transformLandedCostTransactions,
+      R.map(transformLandedCost)
+    )(transactions);
+  };
+
+  /**
+   *
+   * @param transactions
+   * @returns
+   */
+  public transformLandedCostTransactions = (
+    transactions: ILandedCostTransaction[]
+  ) => {
+    return R.map(this.transformLandedCostTransaction)(transactions);
+  };
+
+  /**
+   * Transformes the landed cost transaction.
+   * @param {ILandedCostTransaction} transaction
+   */
+  public transformLandedCostTransaction = (
+    transaction: ILandedCostTransaction
+  ): ILandedCostTransactionDOJO => {
+    const { currencyCode } = transaction;
+
+    // Formatted transaction amount.
+    const formattedAmount = formatNumber(transaction.amount, { currencyCode });
+
+    // Formatted transaction unallocated cost amount.
+    const formattedUnallocatedCostAmount = formatNumber(
+      transaction.unallocatedCostAmount,
+      { currencyCode }
+    );
+    // Formatted transaction allocated cost amount.
+    const formattedAllocatedCostAmount = formatNumber(
+      transaction.allocatedCostAmount,
+      { currencyCode }
+    );
+
+    return {
+      ...transaction,
+      formattedAmount,
+      formattedUnallocatedCostAmount,
+      formattedAllocatedCostAmount,
+      entries: R.map(this.transformLandedCostEntry(transaction))(
+        transaction.entries
+      ),
+    };
+  };
+
+  /**
+   *
+   * @param {ILandedCostTransaction} transaction
+   * @param {ILandedCostTransactionEntry} entry
+   * @returns {ILandedCostTransactionEntryDOJO}
+   */
+  public transformLandedCostEntry = R.curry(
+    (
+      transaction: ILandedCostTransaction,
+      entry: ILandedCostTransactionEntry
+    ): ILandedCostTransactionEntryDOJO => {
+      const { currencyCode } = transaction;
+
+      // Formatted entry amount.
+      const formattedAmount = formatNumber(entry.amount, { currencyCode });
+
+      // Formatted entry unallocated cost amount.
+      const formattedUnallocatedCostAmount = formatNumber(
+        entry.unallocatedCostAmount,
+        { currencyCode }
+      );
+      // Formatted entry allocated cost amount.
+      const formattedAllocatedCostAmount = formatNumber(
+        entry.allocatedCostAmount,
+        { currencyCode }
+      );
+      return {
+        ...entry,
+        formattedAmount,
+        formattedUnallocatedCostAmount,
+        formattedAllocatedCostAmount,
+      };
+    }
+  );
+}
diff --git a/packages/server/src/services/Purchases/LandedCost/RevertAllocatedLandedCost.ts b/packages/server/src/services/Purchases/LandedCost/RevertAllocatedLandedCost.ts
new file mode 100644
index 000000000..75d4a4399
--- /dev/null
+++ b/packages/server/src/services/Purchases/LandedCost/RevertAllocatedLandedCost.ts
@@ -0,0 +1,78 @@
+import Knex from 'knex';
+import { Service, Inject } from 'typedi';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import BaseLandedCost from './BaseLandedCost';
+import { IAllocatedLandedCostDeletedPayload } from '@/interfaces';
+
+@Service()
+export default class RevertAllocatedLandedCost extends BaseLandedCost {
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  /**
+   * Deletes the allocated landed cost.
+   * ==================================
+   * - Delete bill landed cost transaction with associated allocate entries.
+   * - Delete the associated inventory transactions.
+   * - Decrement allocated amount of landed cost transaction and entry.
+   * - Revert journal entries.
+   * ----------------------------------
+   * @param  {number} tenantId - Tenant id.
+   * @param  {number} landedCostId - Landed cost id.
+   * @return {Promise<void>}
+   */
+  public deleteAllocatedLandedCost = async (
+    tenantId: number,
+    landedCostId: number
+  ): Promise<{
+    landedCostId: number;
+  }> => {
+    // Retrieves the bill landed cost.
+    const oldBillLandedCost = await this.getBillLandedCostOrThrowError(
+      tenantId,
+      landedCostId
+    );
+    //  Deletes landed cost with associated transactions.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Delete landed cost transaction with assocaited locate entries.
+      await this.deleteLandedCost(tenantId, landedCostId, trx);
+
+      // Triggers the event `onBillLandedCostCreated`.
+      await this.eventPublisher.emitAsync(events.billLandedCost.onDeleted, {
+        tenantId,
+        oldBillLandedCost: oldBillLandedCost,
+        billId: oldBillLandedCost.billId,
+        trx,
+      } as IAllocatedLandedCostDeletedPayload);
+
+      return { landedCostId };
+    });
+  };
+
+  /**
+   * Deletes the landed cost transaction with assocaited allocate entries.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} landedCostId - Landed cost id.
+   */
+  public deleteLandedCost = async (
+    tenantId: number,
+    landedCostId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { BillLandedCost, BillLandedCostEntry } =
+      this.tenancy.models(tenantId);
+
+    // Deletes the bill landed cost allocated entries associated to landed cost.
+    await BillLandedCostEntry.query(trx)
+      .where('bill_located_cost_id', landedCostId)
+      .delete();
+
+    // Delete the bill landed cost from the storage.
+    await BillLandedCost.query(trx).where('id', landedCostId).delete();
+  };
+}
diff --git a/packages/server/src/services/Purchases/LandedCost/TransctionLandedCost.ts b/packages/server/src/services/Purchases/LandedCost/TransctionLandedCost.ts
new file mode 100644
index 000000000..dc9350175
--- /dev/null
+++ b/packages/server/src/services/Purchases/LandedCost/TransctionLandedCost.ts
@@ -0,0 +1,88 @@
+import { Inject, Service } from 'typedi';
+import * as R from 'ramda';
+import { Model } from 'objection';
+import {
+  IBill,
+  IExpense,
+  ILandedCostTransaction,
+  ILandedCostTransactionEntry,
+} from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import BillLandedCost from './BillLandedCost';
+import ExpenseLandedCost from './ExpenseLandedCost';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ERRORS } from './utils';
+
+@Service()
+export default class TransactionLandedCost {
+  @Inject()
+  billLandedCost: BillLandedCost;
+
+  @Inject()
+  expenseLandedCost: ExpenseLandedCost;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve the cost transaction code model.
+   * @param {number} tenantId - Tenant id.
+   * @param {string} transactionType - Transaction type.
+   * @returns
+   */
+  public getModel = (tenantId: number, transactionType: string): Model => {
+    const Models = this.tenancy.models(tenantId);
+    const Model = Models[transactionType];
+
+    if (!Model) {
+      throw new ServiceError(ERRORS.COST_TYPE_UNDEFINED);
+    }
+    return Model;
+  };
+
+  /**
+   * Mappes the given expense or bill transaction to landed cost transaction.
+   * @param {string} transactionType - Transaction type.
+   * @param {IBill|IExpense} transaction - Expense or bill transaction.
+   * @returns {ILandedCostTransaction}
+   */
+  public transformToLandedCost = R.curry(
+    (
+      transactionType: string,
+      transaction: IBill | IExpense
+    ): ILandedCostTransaction => {
+      return R.compose(
+        R.when(
+          R.always(transactionType === 'Bill'),
+          this.billLandedCost.transformToLandedCost
+        ),
+        R.when(
+          R.always(transactionType === 'Expense'),
+          this.expenseLandedCost.transformToLandedCost
+        )
+      )(transaction);
+    }
+  );
+
+  /**
+   * Transformes the given expense or bill entry to landed cost transaction entry.
+   * @param {string} transactionType
+   * @param {} transactionEntry
+   * @returns {ILandedCostTransactionEntry}
+   */
+  public transformToLandedCostEntry = (
+    transactionType: 'Bill' | 'Expense',
+    transactionEntry
+  ): ILandedCostTransactionEntry => {
+    return R.compose(
+      R.when(
+        R.always(transactionType === 'Bill'),
+        this.billLandedCost.transformToLandedCostEntry
+      ),
+      R.when(
+        R.always(transactionType === 'Expense'),
+        this.expenseLandedCost.transformToLandedCostEntry
+      )
+    )(transactionEntry);
+  };
+}
diff --git a/packages/server/src/services/Purchases/LandedCost/utils.ts b/packages/server/src/services/Purchases/LandedCost/utils.ts
new file mode 100644
index 000000000..f7ea7da07
--- /dev/null
+++ b/packages/server/src/services/Purchases/LandedCost/utils.ts
@@ -0,0 +1,46 @@
+import { IItemEntry, IBillLandedCostTransactionEntry } from '@/interfaces';
+import { transformToMap } from 'utils';
+
+export const ERRORS = {
+  COST_TYPE_UNDEFINED: 'COST_TYPE_UNDEFINED',
+  LANDED_COST_ITEMS_IDS_NOT_FOUND: 'LANDED_COST_ITEMS_IDS_NOT_FOUND',
+  COST_TRANSACTION_HAS_NO_ENOUGH_TO_LOCATE:
+    'COST_TRANSACTION_HAS_NO_ENOUGH_TO_LOCATE',
+  BILL_LANDED_COST_NOT_FOUND: 'BILL_LANDED_COST_NOT_FOUND',
+  COST_ENTRY_ID_NOT_FOUND: 'COST_ENTRY_ID_NOT_FOUND',
+  LANDED_COST_TRANSACTION_NOT_FOUND: 'LANDED_COST_TRANSACTION_NOT_FOUND',
+  LANDED_COST_ENTRY_NOT_FOUND: 'LANDED_COST_ENTRY_NOT_FOUND',
+  COST_AMOUNT_BIGGER_THAN_UNALLOCATED_AMOUNT:
+    'COST_AMOUNT_BIGGER_THAN_UNALLOCATED_AMOUNT',
+  ALLOCATE_COST_SHOULD_NOT_BE_BILL: 'ALLOCATE_COST_SHOULD_NOT_BE_BILL',
+};
+
+/**
+ * Merges item entry to bill located landed cost entry.
+ * @param {IBillLandedCostTransactionEntry[]} locatedEntries -
+ * @param {IItemEntry[]} billEntries -
+ * @returns {(IBillLandedCostTransactionEntry & { entry: IItemEntry })[]}
+ */
+export const mergeLocatedWithBillEntries = (
+  locatedEntries: IBillLandedCostTransactionEntry[],
+  billEntries: IItemEntry[]
+): (IBillLandedCostTransactionEntry & { entry: IItemEntry })[] => {
+  const billEntriesByEntryId = transformToMap(billEntries, 'id');
+
+  return locatedEntries.map((entry) => ({
+    ...entry,
+    entry: billEntriesByEntryId.get(entry.entryId),
+  }));
+};
+
+
+export const CONFIG = {
+  COST_TYPES: {
+    Expense: {
+      entries: 'categories',
+    },
+    Bill: {
+      entries: 'entries',
+    },
+  },
+};
\ No newline at end of file
diff --git a/packages/server/src/services/Purchases/PurchaseInvoices/PurchaseInvoiceTransformer.ts b/packages/server/src/services/Purchases/PurchaseInvoices/PurchaseInvoiceTransformer.ts
new file mode 100644
index 000000000..7918a3643
--- /dev/null
+++ b/packages/server/src/services/Purchases/PurchaseInvoices/PurchaseInvoiceTransformer.ts
@@ -0,0 +1,86 @@
+import { IBill } from '@/interfaces';
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class PurchaseInvoiceTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedBillDate',
+      'formattedDueDate',
+      'formattedAmount',
+      'formattedPaymentAmount',
+      'formattedBalance',
+      'formattedDueAmount',
+      'formattedExchangeRate',
+    ];
+  };
+
+  /**
+   * Retrieve formatted invoice date.
+   * @param {IBill} invoice
+   * @returns {String}
+   */
+  protected formattedBillDate = (bill: IBill): string => {
+    return this.formatDate(bill.billDate);
+  };
+
+  /**
+   * Retrieve formatted invoice date.
+   * @param {IBill} invoice
+   * @returns {String}
+   */
+  protected formattedDueDate = (bill: IBill): string => {
+    return this.formatDate(bill.dueDate);
+  };
+
+  /**
+   * Retrieve formatted bill amount.
+   * @param {IBill} invoice
+   * @returns {string}
+   */
+  protected formattedAmount = (bill): string => {
+    return formatNumber(bill.amount, { currencyCode: bill.currencyCode });
+  };
+
+  /**
+   * Retrieve formatted bill amount.
+   * @param {IBill} invoice
+   * @returns {string}
+   */
+  protected formattedPaymentAmount = (bill): string => {
+    return formatNumber(bill.paymentAmount, {
+      currencyCode: bill.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve formatted bill amount.
+   * @param {IBill} invoice
+   * @returns {string}
+   */
+  protected formattedDueAmount = (bill): string => {
+    return formatNumber(bill.dueAmount, { currencyCode: bill.currencyCode });
+  };
+
+  /**
+   * Retrieve formatted bill balance.
+   * @param {IBill} bill
+   * @returns {string}
+   */
+  protected formattedBalance = (bill): string => {
+    return formatNumber(bill.balance, { currencyCode: bill.currencyCode });
+  };
+
+  /**
+   * Retrieve the formatted exchange rate.
+   * @param {ISaleInvoice} invoice
+   * @returns {string}
+   */
+  protected formattedExchangeRate = (invoice): string => {
+    return formatNumber(invoice.exchangeRate, { money: false });
+  };
+}
diff --git a/packages/server/src/services/Purchases/PurchasesTransactionsLocking.ts b/packages/server/src/services/Purchases/PurchasesTransactionsLocking.ts
new file mode 100644
index 000000000..6dc8b029d
--- /dev/null
+++ b/packages/server/src/services/Purchases/PurchasesTransactionsLocking.ts
@@ -0,0 +1,27 @@
+import { Service, Inject } from 'typedi';
+import TransactionsLockingValidator from '@/services/TransactionsLocking/TransactionsLockingGuard';
+import { TransactionsLockingGroup } from '@/interfaces';
+
+@Service()
+export default class PurchasesTransactionsLocking {
+  @Inject()
+  transactionLockingValidator: TransactionsLockingValidator;
+
+  /**
+   * Validates the all and partial purchases transactions locking.
+   * @param {number} tenantId
+   * @param {Date} transactionDate
+   * @throws {ServiceError(TRANSACTIONS_DATE_LOCKED)}
+   */
+  public transactionLockingGuard = (
+    tenantId: number,
+    transactionDate: Date
+  ) => {
+    // Validates the all transcation locking.
+    this.transactionLockingValidator.validateTransactionsLocking(
+      tenantId,
+      transactionDate,
+      TransactionsLockingGroup.Purchases
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditSyncBills.ts b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditSyncBills.ts
new file mode 100644
index 000000000..f9a86c663
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditSyncBills.ts
@@ -0,0 +1,52 @@
+import { Service, Inject } from 'typedi';
+import Knex from 'knex';
+import { IVendorCreditAppliedBill } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import Bluebird from 'bluebird';
+
+@Service()
+export default class ApplyVendorCreditSyncBills {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Increment bills credited amount.
+   * @param {number} tenantId
+   * @param {IVendorCreditAppliedBill[]} vendorCreditAppliedBills
+   * @param {Knex.Transaction} trx
+   */
+  public incrementBillsCreditedAmount = async (
+    tenantId: number,
+    vendorCreditAppliedBills: IVendorCreditAppliedBill[],
+    trx?: Knex.Transaction
+  ) => {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    await Bluebird.each(
+      vendorCreditAppliedBills,
+      (vendorCreditAppliedBill: IVendorCreditAppliedBill) => {
+        return Bill.query(trx)
+          .where('id', vendorCreditAppliedBill.billId)
+          .increment('creditedAmount', vendorCreditAppliedBill.amount);
+      }
+    );
+  };
+
+  /**
+   * Decrement bill credited amount.
+   * @param {number} tenantId
+   * @param {IVendorCreditAppliedBill} vendorCreditAppliedBill
+   * @param {Knex.Transaction} trx
+   */
+  public decrementBillCreditedAmount = async (
+    tenantId: number,
+    vendorCreditAppliedBill: IVendorCreditAppliedBill,
+    trx?: Knex.Transaction
+  ) => {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    await Bill.query(trx)
+      .findById(vendorCreditAppliedBill.billId)
+      .decrement('creditedAmount', vendorCreditAppliedBill.amount);
+  };
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditSyncBillsSubscriber.ts b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditSyncBillsSubscriber.ts
new file mode 100644
index 000000000..7ef32860b
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditSyncBillsSubscriber.ts
@@ -0,0 +1,65 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  IVendorCreditApplyToBillDeletedPayload,
+  IVendorCreditApplyToBillsCreatedPayload,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import ApplyVendorCreditSyncBills from './ApplyVendorCreditSyncBills';
+
+@Service()
+export default class ApplyVendorCreditSyncBillsSubscriber {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  syncBillsWithVendorCredit: ApplyVendorCreditSyncBills;
+
+  /**
+   * Attaches events with handlers.
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.vendorCredit.onApplyToInvoicesCreated,
+      this.incrementAppliedBillsOnceCreditCreated
+    );
+    bus.subscribe(
+      events.vendorCredit.onApplyToInvoicesDeleted,
+      this.decrementAppliedBillsOnceCreditDeleted
+    );
+  }
+
+  /**
+   * Increment credited amount of applied bills once the vendor credit
+   * transaction created.
+   * @param {IVendorCreditApplyToBillsCreatedPayload}  paylaod -
+   */
+  private incrementAppliedBillsOnceCreditCreated = async ({
+    tenantId,
+    vendorCreditAppliedBills,
+    trx,
+  }: IVendorCreditApplyToBillsCreatedPayload) => {
+    await this.syncBillsWithVendorCredit.incrementBillsCreditedAmount(
+      tenantId,
+      vendorCreditAppliedBills,
+      trx
+    );
+  };
+
+  /**
+   * Decrement credited amount of applied bills once the vendor credit
+   * transaction delted.
+   * @param {IVendorCreditApplyToBillDeletedPayload} payload
+   */
+  private decrementAppliedBillsOnceCreditDeleted = async ({
+    oldCreditAppliedToBill,
+    tenantId,
+    trx,
+  }: IVendorCreditApplyToBillDeletedPayload) => {
+    await this.syncBillsWithVendorCredit.decrementBillCreditedAmount(
+      tenantId,
+      oldCreditAppliedToBill,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditSyncInvoiced.ts b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditSyncInvoiced.ts
new file mode 100644
index 000000000..0b720b407
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditSyncInvoiced.ts
@@ -0,0 +1,48 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export default class ApplyVendorCreditSyncInvoiced {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Increment vendor credit invoiced amount.
+   * @param {number} tenantId
+   * @param {number} vendorCreditId
+   * @param {number} amount
+   * @param {Knex.Transaction} trx
+   */
+  public incrementVendorCreditInvoicedAmount = async (
+    tenantId: number,
+    vendorCreditId: number,
+    amount: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { VendorCredit } = this.tenancy.models(tenantId);
+
+    await VendorCredit.query(trx)
+      .findById(vendorCreditId)
+      .increment('invoicedAmount', amount);
+  };
+
+  /**
+   * Decrement credit note invoiced amount.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @param {number} invoicesAppliedAmount
+   */
+  public decrementVendorCreditInvoicedAmount = async (
+    tenantId: number,
+    vendorCreditId: number,
+    amount: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { VendorCredit } = this.tenancy.models(tenantId);
+
+    await VendorCredit.query(trx)
+      .findById(vendorCreditId)
+      .decrement('invoicedAmount', amount);
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditSyncInvoicedSubscriber.ts b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditSyncInvoicedSubscriber.ts
new file mode 100644
index 000000000..c0b834255
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditSyncInvoicedSubscriber.ts
@@ -0,0 +1,70 @@
+import { Service, Inject } from 'typedi';
+import { sumBy } from 'lodash';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import ApplyVendorCreditSyncInvoiced from './ApplyVendorCreditSyncInvoiced';
+import events from '@/subscribers/events';
+import {
+  IVendorCreditApplyToBillDeletedPayload,
+  IVendorCreditApplyToBillsCreatedPayload,
+} from '@/interfaces';
+
+@Service()
+export default class ApplyVendorCreditSyncInvoicedSubscriber {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  syncCreditWithInvoiced: ApplyVendorCreditSyncInvoiced;
+
+  /**
+   * Attaches events with handlers.
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.vendorCredit.onApplyToInvoicesCreated,
+      this.incrementBillInvoicedOnceCreditApplied
+    );
+    bus.subscribe(
+      events.vendorCredit.onApplyToInvoicesDeleted,
+      this.decrementBillInvoicedOnceCreditApplyDeleted
+    );
+  }
+
+  /**
+   * Increment vendor credit invoiced amount once the apply transaction created.
+   * @param {IVendorCreditApplyToBillsCreatedPayload} payload -
+   */
+  private incrementBillInvoicedOnceCreditApplied = async ({
+    vendorCredit,
+    tenantId,
+    vendorCreditAppliedBills,
+    trx,
+  }: IVendorCreditApplyToBillsCreatedPayload) => {
+    const amount = sumBy(vendorCreditAppliedBills, 'amount');
+
+    await this.syncCreditWithInvoiced.incrementVendorCreditInvoicedAmount(
+      tenantId,
+      vendorCredit.id,
+      amount,
+      trx
+    );
+  };
+
+  /**
+   * Decrement vendor credit invoiced amount once the apply transaction deleted.
+   * @param {IVendorCreditApplyToBillDeletedPayload} payload -
+   */
+  private decrementBillInvoicedOnceCreditApplyDeleted = async ({
+    tenantId,
+    vendorCredit,
+    oldCreditAppliedToBill,
+    trx,
+  }: IVendorCreditApplyToBillDeletedPayload) => {
+    await this.syncCreditWithInvoiced.decrementVendorCreditInvoicedAmount(
+      tenantId,
+      oldCreditAppliedToBill.vendorCreditId,
+      oldCreditAppliedToBill.amount,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditToBills.ts b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditToBills.ts
new file mode 100644
index 000000000..6e326bcdd
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/ApplyVendorCreditToBills.ts
@@ -0,0 +1,127 @@
+import { Service, Inject } from 'typedi';
+import Knex from 'knex';
+import { sumBy } from 'lodash';
+import {
+  IVendorCredit,
+  IVendorCreditApplyToBillsCreatedPayload,
+  IVendorCreditApplyToInvoicesDTO,
+  IVendorCreditApplyToInvoicesModel,
+  IBill,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import PaymentReceiveService from '@/services/Sales/PaymentReceives/PaymentsReceives';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import VendorCredit from '../BaseVendorCredit';
+import BillPaymentsService from '@/services/Purchases/BillPayments/BillPayments';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from '../constants';
+
+@Service()
+export default class ApplyVendorCreditToBills extends VendorCredit {
+  @Inject('PaymentReceives')
+  paymentReceive: PaymentReceiveService;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  billPayment: BillPaymentsService;
+
+  /**
+   * Apply credit note to the given invoices.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @param {IApplyCreditToInvoicesDTO} applyCreditToInvoicesDTO
+   */
+  public applyVendorCreditToBills = async (
+    tenantId: number,
+    vendorCreditId: number,
+    applyCreditToBillsDTO: IVendorCreditApplyToInvoicesDTO
+  ): Promise<void> => {
+    const { VendorCreditAppliedBill } = this.tenancy.models(tenantId);
+
+    // Retrieves the vendor credit or throw not found service error.
+    const vendorCredit = await this.getVendorCreditOrThrowError(
+      tenantId,
+      vendorCreditId
+    );
+    // Transfomes credit apply to bills DTO to model object.
+    const vendorCreditAppliedModel = this.transformApplyDTOToModel(
+      applyCreditToBillsDTO,
+      vendorCredit
+    );
+    // Validate bills entries existance.
+    const appliedBills = await this.billPayment.validateBillsExistance(
+      tenantId,
+      vendorCreditAppliedModel.entries,
+      vendorCredit.vendorId
+    );
+    // Validate bills has remaining amount to apply.
+    this.validateBillsRemainingAmount(
+      appliedBills,
+      vendorCreditAppliedModel.amount
+    );
+    // Validate vendor credit remaining credit amount.
+    this.validateCreditRemainingAmount(
+      vendorCredit,
+      vendorCreditAppliedModel.amount
+    );
+    // Saves vendor credit applied to bills under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Inserts vendor credit applied to bills graph to the storage layer.
+      const vendorCreditAppliedBills =
+        await VendorCreditAppliedBill.query().insertGraph(
+          vendorCreditAppliedModel.entries
+        );
+      // Triggers `IVendorCreditApplyToBillsCreatedPayload` event.
+      await this.eventPublisher.emitAsync(
+        events.vendorCredit.onApplyToInvoicesCreated,
+        {
+          trx,
+          tenantId,
+          vendorCredit,
+          vendorCreditAppliedBills,
+        } as IVendorCreditApplyToBillsCreatedPayload
+      );
+    });
+  };
+
+  /**
+   * Transformes apply DTO to model.
+   * @param {IApplyCreditToInvoicesDTO} applyDTO
+   * @param {ICreditNote} creditNote
+   * @returns {IVendorCreditApplyToInvoicesModel}
+   */
+  private transformApplyDTOToModel = (
+    applyDTO: IVendorCreditApplyToInvoicesDTO,
+    vendorCredit: IVendorCredit
+  ): IVendorCreditApplyToInvoicesModel => {
+    const entries = applyDTO.entries.map((entry) => ({
+      billId: entry.billId,
+      amount: entry.amount,
+      vendorCreditId: vendorCredit.id,
+    }));
+    const amount = sumBy(applyDTO.entries, 'amount');
+
+    return {
+      amount,
+      entries,
+    };
+  };
+
+  /**
+   * Validate bills remaining amount.
+   * @param {IBill[]} bills
+   * @param {number} amount
+   */
+  private validateBillsRemainingAmount = (bills: IBill[], amount: number) => {
+    const invalidBills = bills.filter((bill) => bill.dueAmount < amount);
+    if (invalidBills.length > 0) {
+      throw new ServiceError(ERRORS.BILLS_HAS_NO_REMAINING_AMOUNT);
+    }
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/DeleteApplyVendorCreditToBill.ts b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/DeleteApplyVendorCreditToBill.ts
new file mode 100644
index 000000000..2216845c5
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/DeleteApplyVendorCreditToBill.ts
@@ -0,0 +1,61 @@
+import { ServiceError } from '@/exceptions';
+import { IVendorCreditApplyToBillDeletedPayload } from '@/interfaces';
+import Knex from 'knex';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import { Service, Inject } from 'typedi';
+import BaseVendorCredit from '../BaseVendorCredit';
+import { ERRORS } from '../constants';
+
+@Service()
+export default class DeleteApplyVendorCreditToBill extends BaseVendorCredit {
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  /**
+   * Delete apply vendor credit to bill transaction.
+   * @param {number} tenantId
+   * @param {number} appliedCreditToBillId
+   * @returns {Promise<void>}
+   */
+  public deleteApplyVendorCreditToBills = async (
+    tenantId: number,
+    appliedCreditToBillId: number
+  ) => {
+    const { VendorCreditAppliedBill } = this.tenancy.models(tenantId);
+
+    const oldCreditAppliedToBill =
+      await VendorCreditAppliedBill.query().findById(appliedCreditToBillId);
+
+    if (!oldCreditAppliedToBill) {
+      throw new ServiceError(ERRORS.VENDOR_CREDIT_APPLY_TO_BILLS_NOT_FOUND);
+    }
+    // Retrieve the vendor credit or throw not found service error.
+    const vendorCredit = await this.getVendorCreditOrThrowError(
+      tenantId,
+      oldCreditAppliedToBill.vendorCreditId
+    );
+    // Deletes vendor credit apply under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Delete vendor credit applied to bill transaction.
+      await VendorCreditAppliedBill.query(trx)
+        .findById(appliedCreditToBillId)
+        .delete();
+
+      // Triggers `onVendorCreditApplyToInvoiceDeleted` event.
+      await this.eventPublisher.emitAsync(
+        events.vendorCredit.onApplyToInvoicesDeleted,
+        {
+          tenantId,
+          vendorCredit,
+          oldCreditAppliedToBill,
+          trx,
+        } as IVendorCreditApplyToBillDeletedPayload
+      );
+    });
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/GetAppliedBillsToVendorCredit.ts b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/GetAppliedBillsToVendorCredit.ts
new file mode 100644
index 000000000..44b1bdc8a
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/GetAppliedBillsToVendorCredit.ts
@@ -0,0 +1,36 @@
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import { Service, Inject } from 'typedi';
+import BaseVendorCredit from '../BaseVendorCredit';
+import { VendorCreditAppliedBillTransformer } from './VendorCreditAppliedBillTransformer';
+
+@Service()
+export default class GetAppliedBillsToVendorCredit extends BaseVendorCredit {
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {number} vendorCreditId
+   * @returns
+   */
+  public getAppliedBills = async (tenantId: number, vendorCreditId: number) => {
+    const { VendorCreditAppliedBill } = this.tenancy.models(tenantId);
+
+    const vendorCredit = await this.getVendorCreditOrThrowError(
+      tenantId,
+      vendorCreditId
+    );
+    const appliedToBills = await VendorCreditAppliedBill.query()
+      .where('vendorCreditId', vendorCreditId)
+      .withGraphFetched('bill')
+      .withGraphFetched('vendorCredit');
+
+    // Transformes the models to POJO.
+    return this.transformer.transform(
+      tenantId,
+      appliedToBills,
+      new VendorCreditAppliedBillTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/GetVendorCreditToApplyBills.ts b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/GetVendorCreditToApplyBills.ts
new file mode 100644
index 000000000..8dfb02a75
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/GetVendorCreditToApplyBills.ts
@@ -0,0 +1,41 @@
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import { Service, Inject } from 'typedi';
+import BaseVendorCredit from '../BaseVendorCredit';
+import { VendorCreditToApplyBillTransformer } from './VendorCreditToApplyBillTransformer';
+
+@Service()
+export default class GetVendorCreditToApplyBills extends BaseVendorCredit {
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve bills that valid apply to the given vendor credit.
+   * @param {number} tenantId
+   * @param {number} vendorCreditId
+   * @returns
+   */
+  public getCreditToApplyBills = async (
+    tenantId: number,
+    vendorCreditId: number
+  ) => {
+    const { Bill } = this.tenancy.models(tenantId);
+
+    // Retrieve vendor credit or throw not found service error.
+    const vendorCredit = await this.getVendorCreditOrThrowError(
+      tenantId,
+      vendorCreditId
+    );
+    // Retrieive open bills associated to the given vendor.
+    const openBills = await Bill.query()
+      .where('vendor_id', vendorCredit.vendorId)
+      .modify('dueBills')
+      .modify('published');
+
+    // Transformes the bills to POJO.
+    return this.transformer.transform(
+      tenantId,
+      openBills,
+      new VendorCreditToApplyBillTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/VendorCreditAppliedBillTransformer.ts b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/VendorCreditAppliedBillTransformer.ts
new file mode 100644
index 000000000..72b42a8e8
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/VendorCreditAppliedBillTransformer.ts
@@ -0,0 +1,62 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class VendorCreditAppliedBillTransformer extends Transformer {
+  /**
+   * Includeded attributes.
+   * @returns {string[]}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedAmount',
+      'vendorCreditNumber',
+      'vendorCreditDate',
+      'billNumber',
+      'billReferenceNo',
+      'formattedVendorCreditDate',
+      'formattedBillDate',
+    ];
+  };
+
+  /**
+   * Exclude attributes.
+   * @returns {string[]}
+   */
+  public excludeAttributes = (): string[] => {
+    return ['bill', 'vendorCredit'];
+  };
+
+  protected formattedAmount = (item) => {
+    return formatNumber(item.amount, {
+      currencyCode: item.vendorCredit.currencyCode,
+    });
+  };
+
+  protected vendorCreditNumber = (item) => {
+    return item.vendorCredit.vendorCreditNumber;
+  };
+
+  protected vendorCreditDate = (item) => {
+    return item.vendorCredit.vendorCreditDate;
+  };
+
+  protected formattedVendorCreditDate = (item) => {
+    return this.formatDate(item.vendorCredit.vendorCreditDate);
+  };
+
+  protected billNumber = (item) => {
+    return item.bill.billNo;
+  };
+
+  protected billReferenceNo = (item) => {
+    return item.bill.referenceNo;
+  };
+
+  protected BillDate = (item) => {
+    return item.bill.billDate;
+  };
+
+  protected formattedBillDate = (item) => {
+    return this.formatDate(item.bill.billDate);
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/VendorCreditToApplyBillTransformer.ts b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/VendorCreditToApplyBillTransformer.ts
new file mode 100644
index 000000000..b4f8ebe06
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/ApplyVendorCreditToBills/VendorCreditToApplyBillTransformer.ts
@@ -0,0 +1,70 @@
+import { IBill } from '@/interfaces';
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class VendorCreditToApplyBillTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedBillDate',
+      'formattedDueDate',
+      'formattedAmount',
+      'formattedDueAmount',
+      'formattedPaymentAmount',
+    ];
+  };
+
+  /**
+   * Retrieve formatted bill date.
+   * @param {IBill} bill
+   * @returns {String}
+   */
+  protected formattedBillDate = (bill: IBill): string => {
+    return this.formatDate(bill.billDate);
+  };
+
+  /**
+   * Retrieve formatted due date.
+   * @param {IBill} bill
+   * @returns {string}
+   */
+  protected formattedDueDate = (bill: IBill): string => {
+    return this.formatDate(bill.dueDate);
+  };
+
+  /**
+   * Retrieve formatted bill amount.
+   * @param {IBill} bill
+   * @returns {string}
+   */
+  protected formattedAmount = (bill: IBill): string => {
+    return formatNumber(bill.amount, {
+      currencyCode: bill.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve formatted bill due amount.
+   * @param {IBill} bill
+   * @returns {string}
+   */
+  protected formattedDueAmount = (bill: IBill): string => {
+    return formatNumber(bill.dueAmount, {
+      currencyCode: bill.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve formatted payment amount.
+   * @param {IBill} bill
+   * @returns {string}
+   */
+  protected formattedPaymentAmount = (bill: IBill): string => {
+    return formatNumber(bill.paymentAmount, {
+      currencyCode: bill.currencyCode,
+    });
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/BaseVendorCredit.ts b/packages/server/src/services/Purchases/VendorCredits/BaseVendorCredit.ts
new file mode 100644
index 000000000..3782562f7
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/BaseVendorCredit.ts
@@ -0,0 +1,139 @@
+import { Inject, Service } from 'typedi';
+import moment from 'moment';
+import { omit } from 'lodash';
+import * as R from 'ramda';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ERRORS } from './constants';
+import { ServiceError } from '@/exceptions';
+import {
+  IVendorCredit,
+  IVendorCreditCreateDTO,
+  IVendorCreditEditDTO,
+} from '@/interfaces';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+import AutoIncrementOrdersService from '@/services/Sales/AutoIncrementOrdersService';
+import { BranchTransactionDTOTransform } from '@/services/Branches/Integrations/BranchTransactionDTOTransform';
+import { WarehouseTransactionDTOTransform } from '@/services/Warehouses/Integrations/WarehouseTransactionDTOTransform';
+
+@Service()
+export default class BaseVendorCredit {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private itemsEntriesService: ItemsEntriesService;
+
+  @Inject()
+  private autoIncrementOrdersService: AutoIncrementOrdersService;
+
+  @Inject()
+  private branchDTOTransform: BranchTransactionDTOTransform;
+
+  @Inject()
+  private warehouseDTOTransform: WarehouseTransactionDTOTransform;
+
+  /**
+   * Transformes the credit/edit vendor credit DTO to model.
+   * @param   {number} tenantId -
+   * @param   {IVendorCreditCreateDTO | IVendorCreditEditDTO} vendorCreditDTO
+   * @param   {string} vendorCurrencyCode -
+   * @param   {IVendorCredit} oldVendorCredit -
+   * @returns {IVendorCredit}
+   */
+  public transformCreateEditDTOToModel = (
+    tenantId: number,
+    vendorCreditDTO: IVendorCreditCreateDTO | IVendorCreditEditDTO,
+    vendorCurrencyCode: string,
+    oldVendorCredit?: IVendorCredit
+  ): IVendorCredit => {
+    // Calculates the total amount of items entries.
+    const amount = this.itemsEntriesService.getTotalItemsEntries(
+      vendorCreditDTO.entries
+    );
+    const entries = vendorCreditDTO.entries.map((entry) => ({
+      ...entry,
+      referenceType: 'VendorCredit',
+    }));
+    // Retreive the next vendor credit number.
+    const autoNextNumber = this.getNextCreditNumber(tenantId);
+
+    // Detarmines the credit note number.
+    const vendorCreditNumber =
+      vendorCreditDTO.vendorCreditNumber ||
+      oldVendorCredit?.vendorCreditNumber ||
+      autoNextNumber;
+
+    const initialDTO = {
+      ...omit(vendorCreditDTO, ['open']),
+      amount,
+      currencyCode: vendorCurrencyCode,
+      exchangeRate: vendorCreditDTO.exchangeRate || 1,
+      vendorCreditNumber,
+      entries,
+      ...(vendorCreditDTO.open &&
+        !oldVendorCredit?.openedAt && {
+          openedAt: moment().toMySqlDateTime(),
+        }),
+    };
+    return R.compose(
+      this.branchDTOTransform.transformDTO<IVendorCredit>(tenantId),
+      this.warehouseDTOTransform.transformDTO<IVendorCredit>(tenantId)
+    )(initialDTO);
+  };
+
+  /**
+   * Retrieve the vendor credit or throw not found service error.
+   * @param {number} tenantId
+   * @param {number} vendorCreditId
+   */
+  public getVendorCreditOrThrowError = async (
+    tenantId: number,
+    vendorCreditId: number
+  ): Promise<IVendorCredit> => {
+    const { VendorCredit } = this.tenancy.models(tenantId);
+
+    const vendorCredit = await VendorCredit.query().findById(vendorCreditId);
+
+    if (!vendorCredit) {
+      throw new ServiceError(ERRORS.VENDOR_CREDIT_NOT_FOUND);
+    }
+    return vendorCredit;
+  };
+
+  /**
+   * Retrieve the next unique credit number.
+   * @param  {number} tenantId - Tenant id.
+   * @return {string}
+   */
+  private getNextCreditNumber = (tenantId: number): string => {
+    return this.autoIncrementOrdersService.getNextTransactionNumber(
+      tenantId,
+      'vendor_credit'
+    );
+  };
+
+  /**
+   * Increment the vendor credit serial next number.
+   * @param {number} tenantId -
+   */
+  public incrementSerialNumber = (tenantId: number) => {
+    return this.autoIncrementOrdersService.incrementSettingsNextNumber(
+      tenantId,
+      'vendor_credit'
+    );
+  };
+
+  /**
+   * Validate the credit note remaining amount.
+   * @param {ICreditNote} creditNote
+   * @param {number} amount
+   */
+  public validateCreditRemainingAmount = (
+    vendorCredit: IVendorCredit,
+    amount: number
+  ) => {
+    if (vendorCredit.creditsRemaining < amount) {
+      throw new ServiceError(ERRORS.VENDOR_CREDIT_HAS_NO_REMAINING_AMOUNT);
+    }
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/CreateVendorCredit.ts b/packages/server/src/services/Purchases/VendorCredits/CreateVendorCredit.ts
new file mode 100644
index 000000000..255718fe8
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/CreateVendorCredit.ts
@@ -0,0 +1,85 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import {
+  IVendorCreditCreatedPayload,
+  IVendorCreditCreateDTO,
+  IVendorCreditCreatingPayload,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import BaseVendorCredit from './BaseVendorCredit';
+
+@Service()
+export default class CreateVendorCredit extends BaseVendorCredit {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private itemsEntriesService: ItemsEntriesService;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Creates a new vendor credit.
+   * @param {number} tenantId -
+   * @param {IVendorCreditCreateDTO} vendorCreditCreateDTO -
+   */
+  public newVendorCredit = async (
+    tenantId: number,
+    vendorCreditCreateDTO: IVendorCreditCreateDTO
+  ) => {
+    const { VendorCredit, Vendor } = this.tenancy.models(tenantId);
+
+    // Triggers `onVendorCreditCreate` event.
+    await this.eventPublisher.emitAsync(events.vendorCredit.onCreate, {
+      tenantId,
+      vendorCreditCreateDTO,
+    });
+    // Retrieve the given vendor or throw not found service error.
+    const vendor = await Vendor.query()
+      .findById(vendorCreditCreateDTO.vendorId)
+      .throwIfNotFound();
+
+    // Validate items should be sellable items.
+    await this.itemsEntriesService.validateNonSellableEntriesItems(
+      tenantId,
+      vendorCreditCreateDTO.entries
+    );
+    // Transformes the credit DTO to storage layer.
+    const vendorCreditModel = this.transformCreateEditDTOToModel(
+      tenantId,
+      vendorCreditCreateDTO,
+      vendor.currencyCode
+    );
+    // Saves the vendor credit transactions under UOW envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onVendorCreditCreating` event.
+      await this.eventPublisher.emitAsync(events.vendorCredit.onCreating, {
+        tenantId,
+        vendorCreditCreateDTO,
+        trx,
+      } as IVendorCreditCreatingPayload);
+
+      // Saves the vendor credit graph.
+      const vendorCredit = await VendorCredit.query(trx).upsertGraphAndFetch({
+        ...vendorCreditModel,
+      });
+      // Triggers `onVendorCreditCreated` event.
+      await this.eventPublisher.emitAsync(events.vendorCredit.onCreated, {
+        tenantId,
+        vendorCredit,
+        vendorCreditCreateDTO,
+        trx,
+      } as IVendorCreditCreatedPayload);
+
+      return vendorCredit;
+    });
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/DeleteVendorAssociatedVendorCredit.ts b/packages/server/src/services/Purchases/VendorCredits/DeleteVendorAssociatedVendorCredit.ts
new file mode 100644
index 000000000..63ad79d8d
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/DeleteVendorAssociatedVendorCredit.ts
@@ -0,0 +1,57 @@
+import { Inject, Service } from 'typedi';
+import { ServiceError } from '@/exceptions';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import { IVendorEventDeletingPayload } from '@/interfaces';
+
+const ERRORS = {
+  VENDOR_HAS_TRANSACTIONS: 'VENDOR_HAS_TRANSACTIONS',
+};
+
+@Service()
+export default class DeleteVendorAssociatedVendorCredit {
+  @Inject()
+  tenancy: TenancyService;
+
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.vendors.onDeleting,
+      this.validateVendorHasNoCreditsTransactionsOnceDeleting
+    );
+  };
+
+  /**
+   * Validate vendor has no assocaited credit transaction once the vendor deleting.
+   * @param {IVendorEventDeletingPayload} payload -
+   */
+  public validateVendorHasNoCreditsTransactionsOnceDeleting = async ({
+    tenantId,
+    vendorId,
+  }: IVendorEventDeletingPayload) => {
+    await this.validateVendorHasNoCreditsTransactions(tenantId, vendorId);
+  };
+
+  /**
+   * Validate the given vendor has no associated vendor credit transactions.
+   * @param {number} tenantId
+   * @param {number} vendorId
+   */
+  public validateVendorHasNoCreditsTransactions = async (
+    tenantId: number,
+    vendorId: number
+  ): Promise<void> => {
+    const { VendorCredit } = this.tenancy.models(tenantId);
+
+    const associatedVendors = await VendorCredit.query().where(
+      'vendorId',
+      vendorId
+    );
+    if (associatedVendors.length > 0) {
+      throw new ServiceError(ERRORS.VENDOR_HAS_TRANSACTIONS);
+    }
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/DeleteVendorCredit.ts b/packages/server/src/services/Purchases/VendorCredits/DeleteVendorCredit.ts
new file mode 100644
index 000000000..479527687
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/DeleteVendorCredit.ts
@@ -0,0 +1,119 @@
+import { Service, Inject } from 'typedi';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+import BaseVendorCredit from './BaseVendorCredit';
+import { Knex } from 'knex';
+import events from '@/subscribers/events';
+import {
+  IVendorCreditDeletedPayload,
+  IVendorCreditDeletingPayload,
+} from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export default class DeleteVendorCredit extends BaseVendorCredit {
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Deletes the given vendor credit.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} vendorCreditId - Vendor credit id.
+   */
+  public deleteVendorCredit = async (
+    tenantId: number,
+    vendorCreditId: number
+  ) => {
+    const { VendorCredit, ItemEntry } = this.tenancy.models(tenantId);
+
+    // Retrieve the old vendor credit.
+    const oldVendorCredit = await this.getVendorCreditOrThrowError(
+      tenantId,
+      vendorCreditId
+    );
+    // Validates vendor credit has no associate refund transactions.
+    await this.validateVendorCreditHasNoRefundTransactions(
+      tenantId,
+      vendorCreditId
+    );
+    // Validates vendor credit has no associated applied to bills transactions.
+    await this.validateVendorCreditHasNoApplyBillsTransactions(
+      tenantId,
+      vendorCreditId
+    );
+    // Deletes the vendor credit transactions under UOW envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onVendorCreditEditing` event.
+      await this.eventPublisher.emitAsync(events.vendorCredit.onDeleting, {
+        tenantId,
+        oldVendorCredit,
+        trx,
+      } as IVendorCreditDeletingPayload);
+
+      // Deletes the associated credit note entries.
+      await ItemEntry.query(trx)
+        .where('reference_id', vendorCreditId)
+        .where('reference_type', 'VendorCredit')
+        .delete();
+
+      // Deletes the credit note transaction.
+      await VendorCredit.query(trx).findById(vendorCreditId).delete();
+
+      // Triggers `onVendorCreditDeleted` event.
+      await this.eventPublisher.emitAsync(events.vendorCredit.onDeleted, {
+        tenantId,
+        vendorCreditId,
+        oldVendorCredit,
+        trx,
+      } as IVendorCreditDeletedPayload);
+    });
+  };
+
+  /**
+   * Validates vendor credit has no refund transactions.
+   * @param {number} tenantId
+   * @param {number} vendorCreditId
+   */
+  private validateVendorCreditHasNoRefundTransactions = async (
+    tenantId: number,
+    vendorCreditId: number
+  ): Promise<void> => {
+    const { RefundVendorCredit } = this.tenancy.models(tenantId);
+
+    const refundCredits = await RefundVendorCredit.query().where(
+      'vendorCreditId',
+      vendorCreditId
+    );
+    if (refundCredits.length > 0) {
+      throw new ServiceError(ERRORS.VENDOR_CREDIT_HAS_REFUND_TRANSACTIONS);
+    }
+  };
+
+  /**
+   * Validate vendor credit has no applied transactions to bills.
+   * @param {number} tenantId
+   * @param {number} vendorCreditId
+   */
+  private validateVendorCreditHasNoApplyBillsTransactions = async (
+    tenantId: number,
+    vendorCreditId: number
+  ): Promise<void> => {
+    const { VendorCreditAppliedBill } = this.tenancy.models(tenantId);
+
+    const appliedTransactions = await VendorCreditAppliedBill.query().where(
+      'vendorCreditId',
+      vendorCreditId
+    );
+    if (appliedTransactions.length > 0) {
+      throw new ServiceError(ERRORS.VENDOR_CREDIT_HAS_APPLIED_BILLS);
+    }
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/EditVendorCredit.ts b/packages/server/src/services/Purchases/VendorCredits/EditVendorCredit.ts
new file mode 100644
index 000000000..d76dd3690
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/EditVendorCredit.ts
@@ -0,0 +1,98 @@
+import { Service, Inject } from 'typedi';
+import {
+  IVendorCreditEditDTO,
+  IVendorCreditEditedPayload,
+  IVendorCreditEditingPayload,
+} from '@/interfaces';
+import BaseVendorCredit from './BaseVendorCredit';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+import events from '@/subscribers/events';
+
+@Service()
+export default class EditVendorCredit extends BaseVendorCredit {
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private itemsEntriesService: ItemsEntriesService;
+
+  /**
+   * Deletes the given vendor credit.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} vendorCreditId - Vendor credit id.
+   */
+  public editVendorCredit = async (
+    tenantId: number,
+    vendorCreditId: number,
+    vendorCreditDTO: IVendorCreditEditDTO
+  ) => {
+    const { VendorCredit } = this.tenancy.models(tenantId);
+
+    // Retrieve the vendor credit or throw not found service error.
+    const oldVendorCredit = await this.getVendorCreditOrThrowError(
+      tenantId,
+      vendorCreditId
+    );
+    // Validate customer existance.
+    const vendor = await Contact.query()
+      .modify('vendor')
+      .findById(vendorCreditDTO.vendorId)
+      .throwIfNotFound();
+
+    // Validate items ids existance.
+    await this.itemsEntriesService.validateItemsIdsExistance(
+      tenantId,
+      vendorCreditDTO.entries
+    );
+    // Validate non-sellable entries items.
+    await this.itemsEntriesService.validateNonSellableEntriesItems(
+      tenantId,
+      vendorCreditDTO.entries
+    );
+    // Validate the items entries existance.
+    await this.itemsEntriesService.validateEntriesIdsExistance(
+      tenantId,
+      vendorCreditId,
+      'VendorCredit',
+      vendorCreditDTO.entries
+    );
+    // Transformes edit DTO to model storage layer.
+    const vendorCreditModel = this.transformCreateEditDTOToModel(
+      tenantId,
+      vendorCreditDTO,
+      vendor.currencyCode,
+      oldVendorCredit
+    );
+    // Edits the vendor credit graph under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx) => {
+      // Triggers `onVendorCreditEditing` event.
+      await this.eventPublisher.emitAsync(events.vendorCredit.onEditing, {
+        tenantId,
+        oldVendorCredit,
+        vendorCreditDTO,
+        trx,
+      } as IVendorCreditEditingPayload);
+
+      // Saves the vendor credit graph to the storage.
+      const vendorCredit = await VendorCredit.query(trx).upsertGraphAndFetch({
+        id: vendorCreditId,
+        ...vendorCreditModel,
+      });
+      // Triggers `onVendorCreditEdited event.
+      await this.eventPublisher.emitAsync(events.vendorCredit.onEdited, {
+        tenantId,
+        oldVendorCredit,
+        vendorCredit,
+        vendorCreditId,
+        trx,
+      } as IVendorCreditEditedPayload);
+
+      return vendorCredit;
+    });
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/GetVendorCredit.ts b/packages/server/src/services/Purchases/VendorCredits/GetVendorCredit.ts
new file mode 100644
index 000000000..19a437976
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/GetVendorCredit.ts
@@ -0,0 +1,40 @@
+import { ServiceError } from '@/exceptions';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { VendorCreditTransformer } from './VendorCreditTransformer';
+import { Inject, Service } from 'typedi';
+import { ERRORS } from './constants';
+
+@Service()
+export default class GetVendorCredit {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the given vendor credit.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} vendorCreditId - Vendor credit id.
+   */
+  public getVendorCredit = async (tenantId: number, vendorCreditId: number) => {
+    const { VendorCredit } = this.tenancy.models(tenantId);
+
+    // Retrieve the vendor credit model graph.
+    const vendorCredit = await VendorCredit.query()
+      .findById(vendorCreditId)
+      .withGraphFetched('entries.item')
+      .withGraphFetched('vendor')
+      .withGraphFetched('branch');
+
+    if (!vendorCredit) {
+      throw new ServiceError(ERRORS.VENDOR_CREDIT_NOT_FOUND);
+    }
+    return this.transformer.transform(
+      tenantId,
+      vendorCredit,
+      new VendorCreditTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/ListVendorCredits.ts b/packages/server/src/services/Purchases/VendorCredits/ListVendorCredits.ts
new file mode 100644
index 000000000..ff1be92fc
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/ListVendorCredits.ts
@@ -0,0 +1,66 @@
+import * as R from 'ramda';
+import { Service, Inject } from 'typedi';
+import BaseVendorCredit from './BaseVendorCredit';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { IVendorCreditsQueryDTO } from '@/interfaces';
+import { VendorCreditTransformer } from './VendorCreditTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export default class ListVendorCredits extends BaseVendorCredit {
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Parses the sale invoice list filter DTO.
+   * @param {IVendorCreditsQueryDTO} filterDTO
+   * @returns
+   */
+  private parseListFilterDTO = (filterDTO: IVendorCreditsQueryDTO) => {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  };
+
+  /**
+   * Retrieve the vendor credits list.
+   * @param {number} tenantId - Tenant id.
+   * @param {IVendorCreditsQueryDTO} vendorCreditQuery -
+   */
+  public getVendorCredits = async (
+    tenantId: number,
+    vendorCreditQuery: IVendorCreditsQueryDTO
+  ) => {
+    const { VendorCredit } = this.tenancy.models(tenantId);
+
+    // Parses stringified filter roles.
+    const filter = this.parseListFilterDTO(vendorCreditQuery);
+
+    // Dynamic list service.
+    const dynamicFilter = await this.dynamicListService.dynamicList(
+      tenantId,
+      VendorCredit,
+      filter
+    );
+    const { results, pagination } = await VendorCredit.query()
+      .onBuild((builder) => {
+        builder.withGraphFetched('entries');
+        builder.withGraphFetched('vendor');
+        dynamicFilter.buildQuery()(builder);
+      })
+      .pagination(filter.page - 1, filter.pageSize);
+
+    // Transformes the vendor credits models to POJO.
+    const vendorCredits = await this.transformer.transform(
+      tenantId,
+      results,
+      new VendorCreditTransformer()
+    );
+    return {
+      vendorCredits,
+      pagination,
+      filterMeta: dynamicFilter.getResponseMeta(),
+    };
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/OpenVendorCredit.ts b/packages/server/src/services/Purchases/VendorCredits/OpenVendorCredit.ts
new file mode 100644
index 000000000..f60350ccc
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/OpenVendorCredit.ts
@@ -0,0 +1,90 @@
+import { ServiceError } from '@/exceptions';
+import {
+  IVendorCredit,
+  IVendorCreditOpenedPayload,
+  IVendorCreditOpeningPayload,
+  IVendorCreditOpenPayload,
+} from '@/interfaces';
+import Knex from 'knex';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import { Inject, Service } from 'typedi';
+import BaseVendorCredit from './BaseVendorCredit';
+import { ERRORS } from './constants';
+
+@Service()
+export default class OpenVendorCredit extends BaseVendorCredit {
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  /**
+   * Opens the given credit note.
+   * @param {number} tenantId -
+   * @param {ICreditNoteEditDTO} creditNoteEditDTO -
+   * @returns {Promise<ICreditNote>}
+   */
+  public openVendorCredit = async (
+    tenantId: number,
+    vendorCreditId: number
+  ): Promise<IVendorCredit> => {
+    const { VendorCredit } = this.tenancy.models(tenantId);
+
+    // Retrieve the vendor credit or throw not found service error.
+    const oldVendorCredit = await this.getVendorCreditOrThrowError(
+      tenantId,
+      vendorCreditId
+    );
+    // Throw service error if the credit note is already open.
+    this.throwErrorIfAlreadyOpen(oldVendorCredit);
+
+    // Triggers `onVendorCreditOpen` event.
+    await this.eventPublisher.emitAsync(events.vendorCredit.onOpen, {
+      tenantId,
+      vendorCreditId,
+      oldVendorCredit,
+    } as IVendorCreditOpenPayload);
+
+    // Sales the credit note transactions with associated entries.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      const eventPayload = {
+        tenantId,
+        vendorCreditId,
+        oldVendorCredit,
+        trx,
+      } as IVendorCreditOpeningPayload;
+
+      // Triggers `onCreditNoteOpening` event.
+      await this.eventPublisher.emitAsync(
+        events.creditNote.onOpening,
+        eventPayload as IVendorCreditOpeningPayload
+      );
+      // Saves the vendor credit graph to the storage.
+      const vendorCredit = await VendorCredit.query(trx)
+        .findById(vendorCreditId)
+        .update({
+          openedAt: new Date(),
+        });
+      // Triggers `onVendorCreditOpened` event.
+      await this.eventPublisher.emitAsync(events.vendorCredit.onOpened, {
+        ...eventPayload,
+        vendorCredit,
+      } as IVendorCreditOpenedPayload);
+
+      return vendorCredit;
+    });
+  };
+
+  /**
+   * Throw error if the vendor credit is already open.
+   * @param {IVendorCredit} vendorCredit
+   */
+  public throwErrorIfAlreadyOpen = (vendorCredit: IVendorCredit) => {
+    if (vendorCredit.openedAt) {
+      throw new ServiceError(ERRORS.VENDOR_CREDIT_ALREADY_OPENED);
+    }
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/CreateRefundVendorCredit.ts b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/CreateRefundVendorCredit.ts
new file mode 100644
index 000000000..3a6ef0451
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/CreateRefundVendorCredit.ts
@@ -0,0 +1,128 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import * as R from 'ramda';
+import {
+  IRefundVendorCredit,
+  IRefundVendorCreditCreatedPayload,
+  IRefundVendorCreditCreatingPayload,
+  IRefundVendorCreditDTO,
+  IVendorCredit,
+  IVendorCreditCreatePayload,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import RefundVendorCredit from './RefundVendorCredit';
+import events from '@/subscribers/events';
+import { BranchTransactionDTOTransform } from '@/services/Branches/Integrations/BranchTransactionDTOTransform';
+
+@Service()
+export default class CreateRefundVendorCredit extends RefundVendorCredit {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  private branchDTOTransform: BranchTransactionDTOTransform;
+
+  /**
+   * Creates a refund vendor credit.
+   * @param {number} tenantId
+   * @param {number} vendorCreditId
+   * @param {IRefundVendorCreditDTO} refundVendorCreditDTO
+   * @returns {Promise<IRefundVendorCredit>}
+   */
+  public createRefund = async (
+    tenantId: number,
+    vendorCreditId: number,
+    refundVendorCreditDTO: IRefundVendorCreditDTO
+  ): Promise<IRefundVendorCredit> => {
+    const { RefundVendorCredit, Account, VendorCredit } =
+      this.tenancy.models(tenantId);
+
+    // Retrieve the vendor credit or throw not found service error.
+    const vendorCredit = await VendorCredit.query()
+      .findById(vendorCreditId)
+      .throwIfNotFound();
+
+    // Retrieve the deposit account or throw not found service error.
+    const depositAccount = await Account.query()
+      .findById(refundVendorCreditDTO.depositAccountId)
+      .throwIfNotFound();
+
+    // Validate vendor credit has remaining credit.
+    this.validateVendorCreditRemainingCredit(
+      vendorCredit,
+      refundVendorCreditDTO.amount
+    );
+    // Validate refund deposit account type.
+    this.validateRefundDepositAccountType(depositAccount);
+
+    // Triggers `onVendorCreditRefundCreate` event.
+    await this.eventPublisher.emitAsync(events.vendorCredit.onRefundCreate, {
+      tenantId,
+      vendorCreditId,
+      refundVendorCreditDTO,
+    } as IVendorCreditCreatePayload);
+
+    const refundCreditObj = this.transformDTOToModel(
+      tenantId,
+      vendorCredit,
+      refundVendorCreditDTO
+    );
+    // Saves refund vendor credit with associated transactions.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      const eventPayload = {
+        vendorCredit,
+        trx,
+        tenantId,
+        refundVendorCreditDTO,
+      } as IRefundVendorCreditCreatingPayload;
+
+      // Triggers `onVendorCreditRefundCreating` event.
+      await this.eventPublisher.emitAsync(
+        events.vendorCredit.onRefundCreating,
+        eventPayload as IRefundVendorCreditCreatingPayload
+      );
+      // Inserts refund vendor credit to the storage layer.
+      const refundVendorCredit =
+        await RefundVendorCredit.query().insertAndFetch({
+          ...refundCreditObj,
+        });
+      // Triggers `onVendorCreditCreated` event.
+      await this.eventPublisher.emitAsync(events.vendorCredit.onRefundCreated, {
+        ...eventPayload,
+        refundVendorCredit,
+      } as IRefundVendorCreditCreatedPayload);
+
+      return refundVendorCredit;
+    });
+  };
+
+  /**
+   * Transformes the refund DTO to refund vendor credit model.
+   * @param   {IVendorCredit} vendorCredit -
+   * @param   {IRefundVendorCreditDTO} vendorCreditDTO
+   * @returns {IRefundVendorCredit}
+   */
+  public transformDTOToModel = (
+    tenantId: number,
+    vendorCredit: IVendorCredit,
+    vendorCreditDTO: IRefundVendorCreditDTO
+  ) => {
+    const initialDTO = {
+      vendorCreditId: vendorCredit.id,
+      ...vendorCreditDTO,
+      currencyCode: vendorCredit.currencyCode,
+      exchangeRate: vendorCreditDTO.exchangeRate || 1,
+    };
+    return R.compose(this.branchDTOTransform.transformDTO(tenantId))(
+      initialDTO
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/DeleteRefundVendorCredit.ts b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/DeleteRefundVendorCredit.ts
new file mode 100644
index 000000000..76ea7ff1c
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/DeleteRefundVendorCredit.ts
@@ -0,0 +1,73 @@
+import { Knex } from 'knex';
+import {
+  IRefundVendorCreditDeletedPayload,
+  IRefundVendorCreditDeletePayload,
+  IRefundVendorCreditDeletingPayload,
+} from '@/interfaces';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import { Inject, Service } from 'typedi';
+import RefundVendorCredit from './RefundVendorCredit';
+
+@Service()
+export default class DeleteRefundVendorCredit extends RefundVendorCredit {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  /**
+   * Retrieve the credit note graph.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} creditNoteId - Credit note id.
+   * @returns {Promise<void>}
+   */
+  public deleteRefundVendorCreditRefund = async (
+    tenantId: number,
+    refundCreditId: number
+  ): Promise<void> => {
+    const { RefundVendorCredit } = this.tenancy.models(tenantId);
+
+    // Retrieve the old credit note or throw not found service error.
+    const oldRefundCredit = await this.getRefundVendorCreditOrThrowError(
+      tenantId,
+      refundCreditId
+    );
+    // Triggers `onVendorCreditRefundDelete` event.
+    await this.eventPublisher.emitAsync(events.vendorCredit.onRefundDelete, {
+      refundCreditId,
+      oldRefundCredit,
+      tenantId,
+    } as IRefundVendorCreditDeletePayload);
+
+    // Deletes the refund vendor credit under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      const eventPayload = {
+        trx,
+        refundCreditId,
+        oldRefundCredit,
+        tenantId,
+      } as IRefundVendorCreditDeletingPayload;
+
+      // Triggers `onVendorCreditRefundDeleting` event.
+      await this.eventPublisher.emitAsync(
+        events.vendorCredit.onRefundDeleting,
+        eventPayload
+      );
+      // Deletes the refund vendor credit graph from the storage.
+      await RefundVendorCredit.query(trx).findById(refundCreditId).delete();
+
+      // Triggers `onVendorCreditRefundDeleted` event.
+      await this.eventPublisher.emitAsync(
+        events.vendorCredit.onRefundDeleted,
+        eventPayload as IRefundVendorCreditDeletedPayload
+      );
+    });
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/GetRefundVendorCredit.ts b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/GetRefundVendorCredit.ts
new file mode 100644
index 000000000..2e891781c
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/GetRefundVendorCredit.ts
@@ -0,0 +1,43 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { RefundVendorCreditTransformer } from './RefundVendorCreditTransformer';
+import RefundVendorCredit from './RefundVendorCredit';
+import { IRefundVendorCredit } from '@/interfaces';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export default class GetRefundVendorCredit extends RefundVendorCredit {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve refund vendor credit transaction.
+   * @param {number} tenantId
+   * @param {number} refundId
+   * @returns {Promise<IRefundVendorCredit>}
+   */
+  public getRefundCreditTransaction = async (
+    tenantId: number,
+    refundId: number
+  ): Promise<IRefundVendorCredit> => {
+    const { RefundVendorCredit } = this.tenancy.models(tenantId);
+
+    await this.getRefundVendorCreditOrThrowError(tenantId, refundId);
+
+    // Retrieve refund transactions associated to the given vendor credit.
+    const refundVendorTransactions = await RefundVendorCredit.query()
+      .findById(refundId)
+      .withGraphFetched('vendorCredit')
+      .withGraphFetched('depositAccount');
+
+    // Transformes refund vendor credit models to POJO objects.
+    return this.transformer.transform(
+      tenantId,
+      refundVendorTransactions,
+      new RefundVendorCreditTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/ListRefundVendorCredits.ts b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/ListRefundVendorCredits.ts
new file mode 100644
index 000000000..ebca28fca
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/ListRefundVendorCredits.ts
@@ -0,0 +1,41 @@
+import { IRefundVendorCreditPOJO } from '@/interfaces';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+import RefundVendorCredit from './RefundVendorCredit';
+import { RefundVendorCreditTransformer } from './RefundVendorCreditTransformer';
+
+@Service()
+export default class ListVendorCreditRefunds extends RefundVendorCredit {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the credit note graph.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @returns {Promise<IRefundCreditNotePOJO[]>}
+   */
+  public getVendorCreditRefunds = async (
+    tenantId: number,
+    vendorCreditId: number
+  ): Promise<IRefundVendorCreditPOJO[]> => {
+    const { RefundVendorCredit } = this.tenancy.models(tenantId);
+
+    // Retrieve refund transactions associated to the given vendor credit.
+    const refundVendorTransactions = await RefundVendorCredit.query()
+      .where('vendorCreditId', vendorCreditId)
+      .withGraphFetched('vendorCredit')
+      .withGraphFetched('depositAccount');
+
+    // Transformes refund vendor credit models to POJO objects.
+    return this.transformer.transform(
+      tenantId,
+      refundVendorTransactions,
+      new RefundVendorCreditTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundCreditSyncBills.ts b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundCreditSyncBills.ts
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundSyncCreditRefundedAmount.ts b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundSyncCreditRefundedAmount.ts
new file mode 100644
index 000000000..2ff7abcfb
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundSyncCreditRefundedAmount.ts
@@ -0,0 +1,47 @@
+import Knex from 'knex';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+
+@Service()
+export default class RefundSyncCreditRefundedAmount {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Increment vendor credit refunded amount.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} amount - Amount.
+   * @param {Knex.Transaction} trx - Knex transaction.
+   */
+  public incrementCreditRefundedAmount = async (
+    tenantId: number,
+    vendorCreditId: number,
+    amount: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { VendorCredit } = this.tenancy.models(tenantId);
+
+    await VendorCredit.query(trx)
+      .findById(vendorCreditId)
+      .increment('refundedAmount', amount);
+  };
+
+  /**
+   * Decrement vendor credit refunded amount.
+   * @param {number} tenantId
+   * @param {number} amount
+   * @param {Knex.Transaction} trx
+   */
+  public decrementCreditNoteRefundAmount = async (
+    tenantId: number,
+    vendorCreditId: number,
+    amount: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { VendorCredit } = this.tenancy.models(tenantId);
+
+    await VendorCredit.query(trx)
+      .findById(vendorCreditId)
+      .decrement('refundedAmount', amount);
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundSyncVendorCreditBalance.ts b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundSyncVendorCreditBalance.ts
new file mode 100644
index 000000000..0d09fd59b
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundSyncVendorCreditBalance.ts
@@ -0,0 +1,48 @@
+import Knex from 'knex';
+import { IRefundVendorCredit } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+
+@Service()
+export default class RefundSyncVendorCreditBalance {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Increment vendor credit refunded amount.
+   * @param {number} tenantId -
+   * @param {IRefundVendorCredit} refundCreditNote -
+   * @param {Knex.Transaction} trx -
+   */
+  public incrementVendorCreditRefundAmount = async (
+    tenantId: number,
+    refundVendorCredit: IRefundVendorCredit,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { VendorCredit } = this.tenancy.models(tenantId);
+
+    await VendorCredit.query(trx).increment(
+      'refundedAmount',
+      refundVendorCredit.amount
+    );
+  };
+
+  /**
+   * Decrement vendor credit refunded amount.
+   * @param {number} tenantId
+   * @param {IRefundVendorCredit} refundCreditNote
+   * @param {Knex.Transaction} trx
+   */
+  public decrementVendorCreditRefundAmount = async (
+    tenantId: number,
+    refundVendorCredit: IRefundVendorCredit,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { VendorCredit } = this.tenancy.models(tenantId);
+
+    await VendorCredit.query(trx).decrement(
+      'refundedAmount',
+      refundVendorCredit.amount
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundSyncVendorCreditBalanceSubscriber.ts b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundSyncVendorCreditBalanceSubscriber.ts
new file mode 100644
index 000000000..dbce1c3dc
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundSyncVendorCreditBalanceSubscriber.ts
@@ -0,0 +1,62 @@
+import { Service, Inject } from 'typedi';
+import {
+  IRefundVendorCreditCreatedPayload,
+  IRefundVendorCreditDeletedPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import RefundSyncCreditRefundedAmount from './RefundSyncCreditRefundedAmount';
+
+@Service()
+export default class RefundSyncVendorCreditBalanceSubscriber {
+  @Inject()
+  refundSyncCreditRefunded: RefundSyncCreditRefundedAmount;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.vendorCredit.onRefundCreated,
+      this.incrementRefundedAmountOnceRefundCreated
+    );
+    bus.subscribe(
+      events.vendorCredit.onRefundDeleted,
+      this.decrementRefundedAmountOnceRefundDeleted
+    );
+  };
+
+  /**
+   * Increment refunded vendor credit amount once refund transaction created.
+   * @param {IRefundVendorCreditCreatedPayload} payload -
+   */
+  private incrementRefundedAmountOnceRefundCreated = async ({
+    refundVendorCredit,
+    vendorCredit,
+    tenantId,
+    trx,
+  }: IRefundVendorCreditCreatedPayload) => {
+    await this.refundSyncCreditRefunded.incrementCreditRefundedAmount(
+      tenantId,
+      refundVendorCredit.vendorCreditId,
+      refundVendorCredit.amount,
+      trx
+    );
+  };
+
+  /**
+   * Decrement refunded vendor credit amount once refund transaction deleted.
+   * @param {IRefundVendorCreditDeletedPayload} payload -
+   */
+  private decrementRefundedAmountOnceRefundDeleted = async ({
+    trx,
+    oldRefundCredit,
+    tenantId,
+  }: IRefundVendorCreditDeletedPayload) => {
+    await this.refundSyncCreditRefunded.decrementCreditNoteRefundAmount(
+      tenantId,
+      oldRefundCredit.vendorCreditId,
+      oldRefundCredit.amount,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundVendorCredit.ts b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundVendorCredit.ts
new file mode 100644
index 000000000..d5e372f9c
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundVendorCredit.ts
@@ -0,0 +1,55 @@
+import { ServiceError } from '@/exceptions';
+import { IAccount, IVendorCredit } from '@/interfaces';
+import { Service, Inject } from 'typedi';
+import BaseVendorCredit from '../BaseVendorCredit';
+import { ERRORS } from './constants';
+
+@Service()
+export default class RefundVendorCredit extends BaseVendorCredit {
+  /**
+   * Retrieve the vendor credit refund or throw not found service error.
+   * @param {number} tenantId
+   * @param {number} vendorCreditId
+   * @returns
+   */
+  public getRefundVendorCreditOrThrowError = async (
+    tenantId: number,
+    refundVendorCreditId: number
+  ) => {
+    const { RefundVendorCredit } = this.tenancy.models(tenantId);
+
+    const refundCredit = await RefundVendorCredit.query().findById(
+      refundVendorCreditId
+    );
+    if (!refundCredit) {
+      throw new ServiceError(ERRORS.REFUND_VENDOR_CREDIT_NOT_FOUND);
+    }
+    return refundCredit;
+  };
+
+  /**
+   * Validate the deposit refund account type.
+   * @param {IAccount} account
+   */
+  public validateRefundDepositAccountType = (account: IAccount): void => {
+    const supportedTypes = ['bank', 'cash', 'fixed-asset'];
+
+    if (supportedTypes.indexOf(account.accountType) === -1) {
+      throw new ServiceError(ERRORS.DEPOSIT_ACCOUNT_INVALID_TYPE);
+    }
+  };
+
+  /**
+   * Validate vendor credit has remaining credits.
+   * @param {IVendorCredit} vendorCredit
+   * @param {number} amount
+   */
+  public validateVendorCreditRemainingCredit = (
+    vendorCredit: IVendorCredit,
+    amount: number
+  ) => {
+    if (vendorCredit.creditsRemaining < amount) {
+      throw new ServiceError(ERRORS.VENDOR_CREDIT_HAS_NO_CREDITS_REMAINING);
+    }
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundVendorCreditGLEntries.ts b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundVendorCreditGLEntries.ts
new file mode 100644
index 000000000..05dd7f319
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundVendorCreditGLEntries.ts
@@ -0,0 +1,159 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import { AccountNormal, ILedgerEntry } from '@/interfaces';
+import { IRefundVendorCredit } from '@/interfaces';
+import JournalPosterService from '@/services/Sales/JournalPosterService';
+import LedgerRepository from '@/services/Ledger/LedgerRepository';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export default class RefundVendorCreditGLEntries {
+  @Inject()
+  private journalService: JournalPosterService;
+
+  @Inject()
+  private ledgerRepository: LedgerRepository;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Retrieves the refund credit common GL entry.
+   * @param   {IRefundVendorCredit} refundCredit
+   */
+  private getRefundCreditGLCommonEntry = (
+    refundCredit: IRefundVendorCredit
+  ) => {
+    return {
+      exchangeRate: refundCredit.exchangeRate,
+      currencyCode: refundCredit.currencyCode,
+
+      transactionType: 'RefundVendorCredit',
+      transactionId: refundCredit.id,
+
+      date: refundCredit.date,
+      userId: refundCredit.userId,
+      referenceNumber: refundCredit.referenceNo,
+      createdAt: refundCredit.createdAt,
+      indexGroup: 10,
+
+      credit: 0,
+      debit: 0,
+
+      note: refundCredit.description,
+      branchId: refundCredit.branchId,
+    };
+  };
+
+  /**
+   * Retrieves the refund credit payable GL entry.
+   * @param   {IRefundVendorCredit} refundCredit
+   * @param   {number} APAccountId
+   * @returns {ILedgerEntry}
+   */
+  private getRefundCreditGLPayableEntry = (
+    refundCredit: IRefundVendorCredit,
+    APAccountId: number
+  ): ILedgerEntry => {
+    const commonEntry = this.getRefundCreditGLCommonEntry(refundCredit);
+
+    return {
+      ...commonEntry,
+      credit: refundCredit.amount,
+      accountId: APAccountId,
+      contactId: refundCredit.vendorCredit.vendorId,
+      index: 1,
+      accountNormal: AccountNormal.CREDIT,
+    };
+  };
+
+  /**
+   * Retrieves the refund credit deposit GL entry.
+   * @param   {IRefundVendorCredit} refundCredit
+   * @returns {ILedgerEntry}
+   */
+  private getRefundCreditGLDepositEntry = (
+    refundCredit: IRefundVendorCredit
+  ): ILedgerEntry => {
+    const commonEntry = this.getRefundCreditGLCommonEntry(refundCredit);
+
+    return {
+      ...commonEntry,
+      debit: refundCredit.amount,
+      accountId: refundCredit.depositAccountId,
+      index: 2,
+      accountNormal: AccountNormal.DEBIT,
+    };
+  };
+
+  /**
+   * Retrieve refund vendor credit GL entries.
+   * @param {IRefundVendorCredit} refundCredit
+   * @param {number} APAccountId
+   * @returns {ILedgerEntry[]}
+   */
+  public getRefundCreditGLEntries = (
+    refundCredit: IRefundVendorCredit,
+    APAccountId: number
+  ): ILedgerEntry[] => {
+    const payableEntry = this.getRefundCreditGLPayableEntry(
+      refundCredit,
+      APAccountId
+    );
+    const depositEntry = this.getRefundCreditGLDepositEntry(refundCredit);
+
+    return [payableEntry, depositEntry];
+  };
+
+  /**
+   * Saves refund credit note GL entries.
+   * @param {number} tenantId
+   * @param {IRefundVendorCredit} refundCredit -
+   * @param {Knex.Transaction} trx -
+   * @return {Promise<void>}
+   */
+  public saveRefundCreditGLEntries = async (
+    tenantId: number,
+    refundCreditId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { Account, RefundVendorCredit } = this.tenancy.models(tenantId);
+
+    // Retireve refund with associated vendor credit entity.
+    const refundCredit = await RefundVendorCredit.query()
+      .findById(refundCreditId)
+      .withGraphFetched('vendorCredit');
+
+    const payableAccount = await Account.query().findOne(
+      'slug',
+      'accounts-payable'
+    );
+    // Generates the GL entries of the given refund credit.
+    const entries = this.getRefundCreditGLEntries(
+      refundCredit,
+      payableAccount.id
+    );
+    // Saves the ledegr to the storage.
+    await this.ledgerRepository.saveLedgerEntries(tenantId, entries, trx);
+  };
+
+  /**
+   * Reverts refund credit note GL entries.
+   * @param {number} tenantId
+   * @param {number} refundCreditId
+   * @param {Knex.Transaction} trx
+   * @return {Promise<void>}
+   */
+  public revertRefundCreditGLEntries = async (
+    tenantId: number,
+    refundCreditId: number,
+    trx?: Knex.Transaction
+  ) => {
+    await this.journalService.revertJournalTransactions(
+      tenantId,
+      refundCreditId,
+      'RefundVendorCredit',
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundVendorCreditGLEntriesSubscriber.ts b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundVendorCreditGLEntriesSubscriber.ts
new file mode 100644
index 000000000..1b973035c
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundVendorCreditGLEntriesSubscriber.ts
@@ -0,0 +1,59 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import RefundVendorCreditGLEntries from './RefundVendorCreditGLEntries';
+import {
+  IRefundCreditNoteDeletedPayload,
+  IRefundVendorCreditCreatedPayload,
+} from '@/interfaces';
+
+@Service()
+export default class RefundVendorCreditGLEntriesSubscriber {
+  @Inject()
+  refundVendorGLEntries: RefundVendorCreditGLEntries;
+
+  /**
+   * Attaches events with handlers.
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.vendorCredit.onRefundCreated,
+      this.writeRefundVendorCreditGLEntriesOnceCreated
+    );
+    bus.subscribe(
+      events.vendorCredit.onRefundDeleted,
+      this.revertRefundVendorCreditOnceDeleted
+    );
+  }
+
+  /**
+   * Writes refund vendor credit GL entries once the transaction created.
+   * @param {IRefundCreditNoteCreatedPayload} payload -
+   */
+  private writeRefundVendorCreditGLEntriesOnceCreated = async ({
+    tenantId,
+    trx,
+    refundVendorCredit,
+  }: IRefundVendorCreditCreatedPayload) => {
+    await this.refundVendorGLEntries.saveRefundCreditGLEntries(
+      tenantId,
+      refundVendorCredit.id,
+      trx
+    );
+  };
+
+  /**
+   * Reverts refund vendor credit GL entries once the transaction deleted.
+   * @param {IRefundCreditNoteDeletedPayload} payload -
+   */
+  private revertRefundVendorCreditOnceDeleted = async ({
+    tenantId,
+    trx,
+    refundCreditId,
+  }: IRefundCreditNoteDeletedPayload) => {
+    await this.refundVendorGLEntries.revertRefundCreditGLEntries(
+      tenantId,
+      refundCreditId,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundVendorCreditTransformer.ts b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundVendorCreditTransformer.ts
new file mode 100644
index 000000000..3ee54b737
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/RefundVendorCreditTransformer.ts
@@ -0,0 +1,30 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class RefundVendorCreditTransformer extends Transformer {
+  /**
+   * Includeded attributes.
+   * @returns {string[]}
+   */
+  public includeAttributes = (): string[] => {
+    return ['formttedAmount', 'formattedDate'];
+  };
+
+  /**
+   * Formatted amount.
+   * @returns {string}
+   */
+  protected formttedAmount = (item) => {
+    return formatNumber(item.amount, {
+      currencyCode: item.currencyCode,
+    });
+  };
+
+  /**
+   * Formatted date.
+   * @returns {string}
+   */
+  protected formattedDate = (item) => {
+    return this.formatDate(item.date);
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/constants.ts b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/constants.ts
new file mode 100644
index 000000000..21f355ed3
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/RefundVendorCredits/constants.ts
@@ -0,0 +1,5 @@
+export const ERRORS = {
+  REFUND_VENDOR_CREDIT_NOT_FOUND: 'REFUND_VENDOR_CREDIT_NOT_FOUND',
+  DEPOSIT_ACCOUNT_INVALID_TYPE: 'DEPOSIT_ACCOUNT_INVALID_TYPE',
+  VENDOR_CREDIT_HAS_NO_CREDITS_REMAINING: 'VENDOR_CREDIT_HAS_NO_CREDITS_REMAINING'
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Purchases/VendorCredits/VendorCreditAutoSerialSubscriber.ts b/packages/server/src/services/Purchases/VendorCredits/VendorCreditAutoSerialSubscriber.ts
new file mode 100644
index 000000000..ba4c34578
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/VendorCreditAutoSerialSubscriber.ts
@@ -0,0 +1,27 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import BaseVendorCredit from './BaseVendorCredit';
+import { IVendorCreditCreatedPayload } from '@/interfaces';
+
+@Service()
+export default class VendorCreditAutoSerialSubscriber {
+  @Inject()
+  vendorCreditService: BaseVendorCredit;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(events.vendorCredit.onCreated, this.autoIncrementOnceCreated);
+  }
+
+  /**
+   * Auto serial increment once the vendor credit created.
+   * @param {IVendorCreditCreatedPayload} payload
+   */
+  private autoIncrementOnceCreated = ({
+    tenantId,
+  }: IVendorCreditCreatedPayload) => {
+    this.vendorCreditService.incrementSerialNumber(tenantId);
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/VendorCreditGLEntries.ts b/packages/server/src/services/Purchases/VendorCredits/VendorCreditGLEntries.ts
new file mode 100644
index 000000000..fe269cef5
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/VendorCreditGLEntries.ts
@@ -0,0 +1,189 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import * as R from 'ramda';
+import {
+  IVendorCredit,
+  ILedgerEntry,
+  AccountNormal,
+  IItemEntry,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import Ledger from '@/services/Accounting/Ledger';
+
+@Service()
+export default class VendorCreditGLEntries {
+  @Inject()
+  private ledgerStorage: LedgerStorageService;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Retrieve the vendor credit GL common entry.
+   * @param   {IVendorCredit} vendorCredit
+   * @returns {}
+   */
+  public getVendorCreditGLCommonEntry = (vendorCredit: IVendorCredit) => {
+    return {
+      date: vendorCredit.vendorCreditDate,
+      currencyCode: vendorCredit.currencyCode,
+      exchangeRate: vendorCredit.exchangeRate,
+
+      transactionId: vendorCredit.id,
+      transactionType: 'VendorCredit',
+      transactionNumber: vendorCredit.vendorCreditNumber,
+      referenceNumber: vendorCredit.referenceNo,
+
+      credit: 0,
+      debit: 0,
+
+      branchId: vendorCredit.branchId,
+    };
+  };
+
+  /**
+   * Retrieves the vendor credit payable GL entry.
+   * @param   {IVendorCredit} vendorCredit
+   * @param   {number} APAccountId
+   * @returns {ILedgerEntry}
+   */
+  public getVendorCreditPayableGLEntry = (
+    vendorCredit: IVendorCredit,
+    APAccountId: number
+  ): ILedgerEntry => {
+    const commonEntity = this.getVendorCreditGLCommonEntry(vendorCredit);
+
+    return {
+      ...commonEntity,
+      debit: vendorCredit.localAmount,
+      accountId: APAccountId,
+      contactId: vendorCredit.vendorId,
+      accountNormal: AccountNormal.CREDIT,
+      index: 1,
+    };
+  };
+
+  /**
+   * Retrieves the vendor credit item GL entry.
+   * @param   {IVendorCredit} vendorCredit
+   * @param   {IItemEntry} entry
+   * @returns {ILedgerEntry}
+   */
+  public getVendorCreditGLItemEntry = R.curry(
+    (
+      vendorCredit: IVendorCredit,
+      entry: IItemEntry,
+      index: number
+    ): ILedgerEntry => {
+      const commonEntity = this.getVendorCreditGLCommonEntry(vendorCredit);
+      const localAmount = entry.amount * vendorCredit.exchangeRate;
+
+      return {
+        ...commonEntity,
+        credit: localAmount,
+        index: index + 2,
+        itemId: entry.itemId,
+        itemQuantity: entry.quantity,
+        accountId:
+          'inventory' === entry.item.type
+            ? entry.item.inventoryAccountId
+            : entry.costAccountId || entry.item.costAccountId,
+        accountNormal: AccountNormal.DEBIT,
+      };
+    }
+  );
+
+  /**
+   * Retrieve the vendor credit GL entries.
+   * @param  {IVendorCredit} vendorCredit -
+   * @param  {number} receivableAccount -
+   * @return {ILedgerEntry[]}
+   */
+  public getVendorCreditGLEntries = (
+    vendorCredit: IVendorCredit,
+    payableAccountId: number
+  ): ILedgerEntry[] => {
+    const payableEntry = this.getVendorCreditPayableGLEntry(
+      vendorCredit,
+      payableAccountId
+    );
+    const getItemEntry = this.getVendorCreditGLItemEntry(vendorCredit);
+    const itemsEntries = vendorCredit.entries.map(getItemEntry);
+
+    return [payableEntry, ...itemsEntries];
+  };
+
+  /**
+   * Reverts the vendor credit associated GL entries.
+   * @param {number} tenantId
+   * @param {number} vendorCreditId
+   * @param {Knex.Transaction} trx
+   */
+  public revertVendorCreditGLEntries = async (
+    tenantId: number,
+    vendorCreditId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    await this.ledgerStorage.deleteByReference(
+      tenantId,
+      vendorCreditId,
+      'VendorCredit',
+      trx
+    );
+  };
+
+  /**
+   * Creates vendor credit associated GL entries.
+   * @param {number} tenantId
+   * @param {number} vendorCreditId
+   * @param {Knex.Transaction} trx
+   */
+  public writeVendorCreditGLEntries = async (
+    tenantId: number,
+    vendorCreditId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+    const { VendorCredit } = this.tenancy.models(tenantId);
+
+    // Vendor credit with entries items.
+    const vendorCredit = await VendorCredit.query(trx)
+      .findById(vendorCreditId)
+      .withGraphFetched('entries.item');
+
+    // Retrieve the payable account (A/P) account.
+    const APAccount = await accountRepository.findOrCreateAccountsPayable(
+      vendorCredit.currencyCode,
+      {},
+      trx
+    );
+    // Saves the vendor credit GL entries.
+    const ledgerEntries = this.getVendorCreditGLEntries(
+      vendorCredit,
+      APAccount.id
+    );
+    const ledger = new Ledger(ledgerEntries);
+
+    // Commits the ledger entries to the storage.
+    await this.ledgerStorage.commit(tenantId, ledger, trx);
+  };
+
+  /**
+   * Edits vendor credit associated GL entries.
+   * @param {number} tenantId
+   * @param {number} vendorCreditId
+   * @param {Knex.Transaction} trx
+   */
+  public rewriteVendorCreditGLEntries = async (
+    tenantId: number,
+    vendorCreditId: number,
+    trx?: Knex.Transaction
+  ) => {
+    // Reverts the GL entries.
+    await this.revertVendorCreditGLEntries(tenantId, vendorCreditId, trx);
+
+    // Re-write the GL entries.
+    await this.writeVendorCreditGLEntries(tenantId, vendorCreditId, trx);
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/VendorCreditGLEntriesSubscriber.ts b/packages/server/src/services/Purchases/VendorCredits/VendorCreditGLEntriesSubscriber.ts
new file mode 100644
index 000000000..5bfccf190
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/VendorCreditGLEntriesSubscriber.ts
@@ -0,0 +1,110 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  IVendorCreditCreatedPayload,
+  IVendorCreditDeletedPayload,
+  IVendorCreditEditedPayload,
+  IVendorCreditOpenedPayload,
+} from '@/interfaces';
+import VendorCreditGLEntries from './VendorCreditGLEntries';
+
+@Service()
+export default class VendorCreditGlEntriesSubscriber {
+  @Inject()
+  private vendorCreditGLEntries: VendorCreditGLEntries;
+
+  /***
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.vendorCredit.onCreated,
+      this.writeGLEntriesOnceVendorCreditCreated
+    );
+    bus.subscribe(
+      events.vendorCredit.onOpened,
+      this.writeGLEntgriesOnceVendorCreditOpened
+    );
+    bus.subscribe(
+      events.vendorCredit.onEdited,
+      this.editGLEntriesOnceVendorCreditEdited
+    );
+    bus.subscribe(
+      events.vendorCredit.onDeleted,
+      this.revertGLEntriesOnceDeleted
+    );
+  }
+
+  /**
+   * Writes GL entries of vendor credit once the transaction created.
+   * @param {IVendorCreditCreatedPayload} payload -
+   */
+  private writeGLEntriesOnceVendorCreditCreated = async ({
+    tenantId,
+    vendorCredit,
+    trx,
+  }: IVendorCreditCreatedPayload): Promise<void> => {
+    // Can't continue if the vendor credit is not open yet.
+    if (!vendorCredit.isPublished) return;
+
+    await this.vendorCreditGLEntries.writeVendorCreditGLEntries(
+      tenantId,
+      vendorCredit.id,
+      trx
+    );
+  };
+
+  /**
+   * Writes Gl entries of vendor credit once the transaction opened.
+   * @param {IVendorCreditOpenedPayload} payload -
+   */
+  private writeGLEntgriesOnceVendorCreditOpened = async ({
+    tenantId,
+    vendorCreditId,
+    trx,
+  }: IVendorCreditOpenedPayload) => {
+    await this.vendorCreditGLEntries.writeVendorCreditGLEntries(
+      tenantId,
+      vendorCreditId,
+      trx
+    );
+  };
+
+  /**
+   * Edits assocaited GL entries once vendor credit edited.
+   * @param {IVendorCreditEditedPayload} payload
+   */
+  private editGLEntriesOnceVendorCreditEdited = async ({
+    tenantId,
+    vendorCreditId,
+    vendorCredit,
+    trx,
+  }: IVendorCreditEditedPayload) => {
+    // Can't continue if the vendor credit is not open yet.
+    if (!vendorCredit.isPublished) return;
+
+    await this.vendorCreditGLEntries.rewriteVendorCreditGLEntries(
+      tenantId,
+      vendorCreditId,
+      trx
+    );
+  };
+
+  /**
+   * Reverts the GL entries once vendor credit deleted.
+   * @param {IVendorCreditDeletedPayload} payload -
+   */
+  private revertGLEntriesOnceDeleted = async ({
+    vendorCreditId,
+    tenantId,
+    oldVendorCredit,
+  }: IVendorCreditDeletedPayload): Promise<void> => {
+    // Can't continue of the vendor credit is not open yet.
+    if (!oldVendorCredit.isPublished) return;
+
+    await this.vendorCreditGLEntries.revertVendorCreditGLEntries(
+      tenantId,
+      vendorCreditId
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/VendorCreditInventoryTransactions.ts b/packages/server/src/services/Purchases/VendorCredits/VendorCreditInventoryTransactions.ts
new file mode 100644
index 000000000..ed58daa1b
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/VendorCreditInventoryTransactions.ts
@@ -0,0 +1,92 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import { IVendorCredit } from '@/interfaces';
+import InventoryService from '@/services/Inventory/Inventory';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+
+@Service()
+export default class VendorCreditInventoryTransactions {
+  @Inject()
+  inventoryService: InventoryService;
+
+  @Inject()
+  itemsEntriesService: ItemsEntriesService;
+
+  /**
+   * Creates vendor credit associated inventory transactions.
+   * @param {number} tenantId
+   * @param {IVnedorCredit} vendorCredit
+   * @param {Knex.Transaction} trx
+   */
+  public createInventoryTransactions = async (
+    tenantId: number,
+    vendorCredit: IVendorCredit,
+    trx: Knex.Transaction
+  ): Promise<void> => {
+    // Loads the inventory items entries of the given sale invoice.
+    const inventoryEntries =
+      await this.itemsEntriesService.filterInventoryEntries(
+        tenantId,
+        vendorCredit.entries
+      );
+
+    const transaction = {
+      transactionId: vendorCredit.id,
+      transactionType: 'VendorCredit',
+      transactionNumber: vendorCredit.vendorCreditNumber,
+      exchangeRate: vendorCredit.exchangeRate,
+      date: vendorCredit.vendorCreditDate,
+      direction: 'OUT',
+      entries: inventoryEntries,
+      warehouseId: vendorCredit.warehouseId,
+      createdAt: vendorCredit.createdAt,
+    };
+    // Writes inventory tranactions.
+    await this.inventoryService.recordInventoryTransactionsFromItemsEntries(
+      tenantId,
+      transaction,
+      false,
+      trx
+    );
+  };
+
+  /**
+   * Edits vendor credit assocaited inventory transactions.
+   * @param {number} tenantId
+   * @param {number} creditNoteId
+   * @param {ICreditNote} creditNote
+   * @param {Knex.Transactions} trx
+   */
+  public editInventoryTransactions = async (
+    tenantId: number,
+    vendorCreditId: number,
+    vendorCredit: IVendorCredit,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    // Deletes inventory transactions.
+    await this.deleteInventoryTransactions(tenantId, vendorCreditId, trx);
+
+    // Re-write inventory transactions.
+    await this.createInventoryTransactions(tenantId, vendorCredit, trx);
+  };
+
+  /**
+   * Deletes credit note associated inventory transactions.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} creditNoteId - Credit note id.
+   * @param {Knex.Transaction} trx -
+   */
+  public deleteInventoryTransactions = async (
+    tenantId: number,
+    vendorCreditId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    // Deletes the inventory transactions by the given reference id and type.
+    await this.inventoryService.deleteInventoryTransactions(
+      tenantId,
+      vendorCreditId,
+      'VendorCredit',
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/VendorCreditInventoryTransactionsSusbcriber.ts b/packages/server/src/services/Purchases/VendorCredits/VendorCreditInventoryTransactionsSusbcriber.ts
new file mode 100644
index 000000000..c9b24a4f7
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/VendorCreditInventoryTransactionsSusbcriber.ts
@@ -0,0 +1,83 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  IVendorCreditCreatedPayload,
+  IVendorCreditDeletedPayload,
+  IVendorCreditEditedPayload,
+} from '@/interfaces';
+import VendorCreditInventoryTransactions from './VendorCreditInventoryTransactions';
+
+@Service()
+export default class VendorCreditInventoryTransactionsSubscriber {
+  @Inject()
+  inventoryTransactions: VendorCreditInventoryTransactions;
+
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.vendorCredit.onCreated,
+      this.writeInventoryTransactionsOnceCreated
+    );
+    bus.subscribe(
+      events.vendorCredit.onEdited,
+      this.rewriteInventroyTransactionsOnceEdited
+    );
+    bus.subscribe(
+      events.vendorCredit.onDeleted,
+      this.revertInventoryTransactionsOnceDeleted
+    );
+  }
+
+  /**
+   * Writes inventory transactions once vendor created created.
+   * @param {IVendorCreditCreatedPayload} payload -
+   */
+  private writeInventoryTransactionsOnceCreated = async ({
+    tenantId,
+    vendorCredit,
+    trx,
+  }: IVendorCreditCreatedPayload) => {
+    await this.inventoryTransactions.createInventoryTransactions(
+      tenantId,
+      vendorCredit,
+      trx
+    );
+  };
+
+  /**
+   * Rewrites inventory transactions once vendor credit edited.
+   * @param {IVendorCreditEditedPayload} payload -
+   */
+  private rewriteInventroyTransactionsOnceEdited = async ({
+    tenantId,
+    vendorCreditId,
+    vendorCredit,
+    trx,
+  }: IVendorCreditEditedPayload) => {
+    await this.inventoryTransactions.editInventoryTransactions(
+      tenantId,
+      vendorCreditId,
+      vendorCredit,
+      trx
+    );
+  };
+
+  /**
+   * Reverts inventory transactions once vendor credit deleted.
+   * @param {IVendorCreditDeletedPayload} payload -
+   */
+  private revertInventoryTransactionsOnceDeleted = async ({
+    tenantId,
+    vendorCreditId,
+    trx,
+  }: IVendorCreditDeletedPayload) => {
+    await this.inventoryTransactions.deleteInventoryTransactions(
+      tenantId,
+      vendorCreditId,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/VendorCreditTransformer.ts b/packages/server/src/services/Purchases/VendorCredits/VendorCreditTransformer.ts
new file mode 100644
index 000000000..f4d75409e
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/VendorCreditTransformer.ts
@@ -0,0 +1,47 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class VendorCreditTransformer extends Transformer {
+  /**
+   * Include these attributes to vendor credit object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedVendorCreditDate',
+      'formattedAmount',
+      'formattedCreditsRemaining',
+    ];
+  };
+
+  /**
+   * Retrieve formatted vendor credit date.
+   * @param {IVendorCredit} credit
+   * @returns {String}
+   */
+  protected formattedVendorCreditDate = (vendorCredit): string => {
+    return this.formatDate(vendorCredit.vendorCreditDate);
+  };
+
+  /**
+   * Retrieve formatted vendor credit amount.
+   * @param {IVendorCredit} credit
+   * @returns {string}
+   */
+  protected formattedAmount = (vendorCredit): string => {
+    return formatNumber(vendorCredit.amount, {
+      currencyCode: vendorCredit.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve formatted credits remaining.
+   * @param {IVendorCredit} credit
+   * @returns {string}
+   */
+  protected formattedCreditsRemaining = (credit) => {
+    return formatNumber(credit.creditsRemaining, {
+      currencyCode: credit.currencyCode,
+    });
+  };
+}
diff --git a/packages/server/src/services/Purchases/VendorCredits/constants.ts b/packages/server/src/services/Purchases/VendorCredits/constants.ts
new file mode 100644
index 000000000..76a7e1b88
--- /dev/null
+++ b/packages/server/src/services/Purchases/VendorCredits/constants.ts
@@ -0,0 +1,64 @@
+export const ERRORS = {
+  VENDOR_CREDIT_NOT_FOUND: 'VENDOR_CREDIT_NOT_FOUND',
+  VENDOR_CREDIT_ALREADY_OPENED: 'VENDOR_CREDIT_ALREADY_OPENED',
+  VENDOR_CREDIT_HAS_NO_REMAINING_AMOUNT: 'VENDOR_CREDIT_HAS_NO_REMAINING_AMOUNT',
+  VENDOR_CREDIT_APPLY_TO_BILLS_NOT_FOUND: 'VENDOR_CREDIT_APPLY_TO_BILLS_NOT_FOUND',
+  BILLS_HAS_NO_REMAINING_AMOUNT: 'BILLS_HAS_NO_REMAINING_AMOUNT',
+  VENDOR_CREDIT_HAS_REFUND_TRANSACTIONS: 'VENDOR_CREDIT_HAS_REFUND_TRANSACTIONS',
+  VENDOR_CREDIT_HAS_APPLIED_BILLS: 'VENDOR_CREDIT_HAS_APPLIED_BILLS'
+};
+
+export const DEFAULT_VIEW_COLUMNS = [];
+export const DEFAULT_VIEWS = [
+  {
+    name: 'vendor_credit.view.draft',
+    slug: 'draft',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'draft' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'vendor_credit.view.published',
+    slug: 'published',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'published',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'vendor_credit.view.open',
+    slug: 'open',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'open',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'vendor_credit.view.closed',
+    slug: 'closed',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'closed',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+];
diff --git a/packages/server/src/services/Purchases/constants.ts b/packages/server/src/services/Purchases/constants.ts
new file mode 100644
index 000000000..12afad4c7
--- /dev/null
+++ b/packages/server/src/services/Purchases/constants.ts
@@ -0,0 +1,76 @@
+export const ERRORS = {
+  BILL_NOT_FOUND: 'BILL_NOT_FOUND',
+  BILL_VENDOR_NOT_FOUND: 'BILL_VENDOR_NOT_FOUND',
+  BILL_ITEMS_NOT_PURCHASABLE: 'BILL_ITEMS_NOT_PURCHASABLE',
+  BILL_NUMBER_EXISTS: 'BILL_NUMBER_EXISTS',
+  BILL_ITEMS_NOT_FOUND: 'BILL_ITEMS_NOT_FOUND',
+  BILL_ENTRIES_IDS_NOT_FOUND: 'BILL_ENTRIES_IDS_NOT_FOUND',
+  NOT_PURCHASE_ABLE_ITEMS: 'NOT_PURCHASE_ABLE_ITEMS',
+  BILL_ALREADY_OPEN: 'BILL_ALREADY_OPEN',
+  BILL_NO_IS_REQUIRED: 'BILL_NO_IS_REQUIRED',
+  BILL_HAS_ASSOCIATED_PAYMENT_ENTRIES: 'BILL_HAS_ASSOCIATED_PAYMENT_ENTRIES',
+  VENDOR_HAS_BILLS: 'VENDOR_HAS_BILLS',
+  BILL_HAS_ASSOCIATED_LANDED_COSTS: 'BILL_HAS_ASSOCIATED_LANDED_COSTS',
+  BILL_ENTRIES_ALLOCATED_COST_COULD_DELETED:
+    'BILL_ENTRIES_ALLOCATED_COST_COULD_DELETED',
+  LOCATED_COST_ENTRIES_SHOULD_BIGGE_THAN_NEW_ENTRIES:
+    'LOCATED_COST_ENTRIES_SHOULD_BIGGE_THAN_NEW_ENTRIES',
+  LANDED_COST_ENTRIES_SHOULD_BE_INVENTORY_ITEMS:
+    'LANDED_COST_ENTRIES_SHOULD_BE_INVENTORY_ITEMS',
+  BILL_HAS_APPLIED_TO_VENDOR_CREDIT: 'BILL_HAS_APPLIED_TO_VENDOR_CREDIT',
+};
+
+export const DEFAULT_VIEW_COLUMNS = [];
+
+export const DEFAULT_VIEWS = [
+  {
+    name: 'Draft',
+    slug: 'draft',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'draft' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Opened',
+    slug: 'opened',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'opened' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Unpaid',
+    slug: 'unpaid',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'unpaid' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Overdue',
+    slug: 'overdue',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'overdue' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Partially paid',
+    slug: 'partially-paid',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'partially-paid',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+];
diff --git a/packages/server/src/services/Resource/ResourceService.ts b/packages/server/src/services/Resource/ResourceService.ts
new file mode 100644
index 000000000..79887851a
--- /dev/null
+++ b/packages/server/src/services/Resource/ResourceService.ts
@@ -0,0 +1,79 @@
+import { Service, Inject } from 'typedi';
+import { camelCase, upperFirst } from 'lodash';
+import * as qim from 'qim';
+import pluralize from 'pluralize';
+import { IModelMeta } from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import { ServiceError } from '@/exceptions';
+import I18nService from '@/services/I18n/I18nService';
+import { tenantKnexConfig } from 'config/knexConfig';
+
+const ERRORS = {
+  RESOURCE_MODEL_NOT_FOUND: 'RESOURCE_MODEL_NOT_FOUND',
+};
+
+@Service()
+export default class ResourceService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  i18nService: I18nService;
+
+  /**
+   * Transform resource to model name.
+   * @param {string} resourceName
+   */
+  private resourceToModelName(resourceName: string): string {
+    return upperFirst(camelCase(pluralize.singular(resourceName)));
+  }
+
+  /**
+   * Retrieve resource model object.
+   * @param {number} tenantId -
+   * @param {string} inputModelName -
+   */
+  public getResourceModel(tenantId: number, inputModelName: string) {
+    const modelName = this.resourceToModelName(inputModelName);
+    const Models = this.tenancy.models(tenantId);
+
+    if (!Models[modelName]) {
+      throw new ServiceError(ERRORS.RESOURCE_MODEL_NOT_FOUND);
+    }
+    return Models[modelName];
+  }
+
+  /**
+   * Retrieve the resource meta.
+   * @param {number} tenantId
+   * @param {string} modelName
+   * @returns {IModelMeta}
+   */
+  public getResourceMeta(
+    tenantId: number,
+    modelName: string,
+    metakey?: string
+  ): IModelMeta {
+    const resourceModel = this.getResourceModel(tenantId, modelName);
+
+    // Retrieve the resource meta.
+    const resourceMeta = resourceModel.getMeta(metakey);
+
+    // Localization the fields names.
+    return this.getResourceMetaLocalized(resourceMeta, tenantId);
+  }
+
+  /**
+   * Retrieve the resource meta localized based on the current user language.
+   */
+  public getResourceMetaLocalized(meta, tenantId) {
+    const $enumerationType = (field) =>
+      field.fieldType === 'enumeration' ? field : undefined;
+
+    const naviagations = [
+      ['fields', qim.$each, 'name'],
+      ['fields', qim.$each, $enumerationType, 'options', qim.$each, 'label'],
+    ];
+    return this.i18nService.i18nApply(naviagations, meta, tenantId);
+  }
+}
diff --git a/packages/server/src/services/Roles/AbilitySchema.ts b/packages/server/src/services/Roles/AbilitySchema.ts
new file mode 100644
index 000000000..ec3de5363
--- /dev/null
+++ b/packages/server/src/services/Roles/AbilitySchema.ts
@@ -0,0 +1,339 @@
+import {
+  ReportsAction,
+  ISubjectAbilitiesSchema,
+  ISubjectAbilitySchema,
+  AbilitySubject,
+  ManualJournalAction,
+  AccountAction,
+  SaleInvoiceAction,
+  ItemAction,
+  VendorAction,
+  CustomerAction,
+  ExpenseAction,
+  PaymentReceiveAction,
+  InventoryAdjustmentAction,
+  SaleEstimateAction,
+  BillAction,
+  SaleReceiptAction,
+  IPaymentMadeAction,
+  CashflowAction,
+  PreferencesAction,
+  CreditNoteAction,
+  VendorCreditAction,
+} from '@/interfaces';
+
+export const AbilitySchema: ISubjectAbilitiesSchema[] = [
+  {
+    subject: AbilitySubject.Account,
+    subjectLabel: 'ability.accounts',
+    abilities: [
+      { key: AccountAction.VIEW, label: 'ability.view' },
+      { key: AccountAction.CREATE, label: 'ability.create' },
+      { key: AccountAction.EDIT, label: 'ability.edit' },
+      { key: AccountAction.DELETE, label: 'ability.delete' },
+    ],
+    extraAbilities: [
+      {
+        key: AccountAction.TransactionsLocking,
+        label: 'ability.transactions_locking',
+      },
+    ],
+  },
+  {
+    subject: AbilitySubject.ManualJournal,
+    subjectLabel: 'ability.manual_journal',
+    abilities: [
+      { key: ManualJournalAction.View, label: 'ability.view' },
+      { key: ManualJournalAction.Create, label: 'ability.create' },
+      { key: ManualJournalAction.Edit, label: 'ability.edit' },
+      { key: ManualJournalAction.Delete, label: 'ability.delete' },
+    ],
+  },
+  {
+    subject: AbilitySubject.Cashflow,
+    subjectLabel: 'ability.cashflow',
+    abilities: [
+      { key: CashflowAction.View, label: 'ability.view' },
+      { key: CashflowAction.Create, label: 'ability.create' },
+      { key: CashflowAction.Delete, label: 'ability.delete' },
+    ],
+  },
+  {
+    subject: AbilitySubject.Item,
+    subjectLabel: 'ability.items',
+    abilities: [
+      { key: ItemAction.VIEW, label: 'ability.view', default: true },
+      { key: ItemAction.CREATE, label: 'ability.create', default: true },
+      { key: ItemAction.EDIT, label: 'ability.edit', default: true },
+      { key: ItemAction.DELETE, label: 'ability.delete', default: true },
+    ],
+  },
+  {
+    subject: AbilitySubject.InventoryAdjustment,
+    subjectLabel: 'ability.inventory_adjustment',
+    abilities: [
+      {
+        key: InventoryAdjustmentAction.VIEW,
+        label: 'ability.view',
+        default: true,
+      },
+      {
+        key: InventoryAdjustmentAction.CREATE,
+        label: 'ability.create',
+        default: true,
+      },
+      {
+        key: InventoryAdjustmentAction.EDIT,
+        label: 'ability.edit',
+        default: true,
+      },
+      { key: InventoryAdjustmentAction.DELETE, label: 'ability.delete' },
+    ],
+  },
+  {
+    subject: AbilitySubject.Customer,
+    subjectLabel: 'ability.customers',
+    // description: 'Description is here',
+    abilities: [
+      { key: CustomerAction.View, label: 'ability.view', default: true },
+      { key: CustomerAction.Create, label: 'ability.create', default: true },
+      { key: CustomerAction.Edit, label: 'ability.edit', default: true },
+      { key: CustomerAction.Delete, label: 'ability.delete', default: true },
+    ],
+  },
+  {
+    subject: AbilitySubject.Vendor,
+    subjectLabel: 'ability.vendors',
+    abilities: [
+      { key: VendorAction.View, label: 'ability.view', default: true },
+      { key: VendorAction.Create, label: 'ability.create', default: true },
+      { key: VendorAction.Edit, label: 'ability.edit', default: true },
+      { key: VendorAction.Delete, label: 'ability.delete', default: true },
+    ],
+  },
+  {
+    subject: AbilitySubject.SaleEstimate,
+    subjectLabel: 'ability.sale_estimates',
+    abilities: [
+      { key: SaleEstimateAction.View, label: 'ability.view', default: true },
+      {
+        key: SaleEstimateAction.Create,
+        label: 'ability.create',
+        default: true,
+      },
+      { key: SaleEstimateAction.Edit, label: 'ability.edit', default: true },
+      {
+        key: SaleEstimateAction.Delete,
+        label: 'ability.delete',
+        default: true,
+      },
+    ],
+  },
+  {
+    subject: AbilitySubject.SaleInvoice,
+    subjectLabel: 'ability.sale_invoices',
+    abilities: [
+      { key: SaleInvoiceAction.View, label: 'ability.view', default: true },
+      { key: SaleInvoiceAction.Create, label: 'ability.create', default: true },
+      { key: SaleInvoiceAction.Edit, label: 'ability.edit', default: true },
+      { key: SaleInvoiceAction.Delete, label: 'ability.delete', default: true },
+    ],
+    extraAbilities: [{ key: 'bad-debt', label: 'Due amount to bad debit' }],
+  },
+  {
+    subject: AbilitySubject.SaleReceipt,
+    subjectLabel: 'ability.sale_receipts',
+    abilities: [
+      { key: SaleReceiptAction.View, label: 'ability.view', default: true },
+      { key: SaleReceiptAction.Create, label: 'ability.create', default: true },
+      { key: SaleReceiptAction.Edit, label: 'ability.edit', default: true },
+      { key: SaleReceiptAction.Delete, label: 'ability.delete', default: true },
+    ],
+  },
+  {
+    subject: AbilitySubject.CreditNote,
+    subjectLabel: 'ability.credit_note',
+    abilities: [
+      { key: CreditNoteAction.View, label: 'ability.view', default: true },
+      { key: CreditNoteAction.Create, label: 'ability.create', default: true },
+      { key: CreditNoteAction.Edit, label: 'ability.edit', default: true },
+      { key: CreditNoteAction.Delete, label: 'ability.delete', default: true },
+      { key: CreditNoteAction.Refund, label: 'ability.refund', default: true },
+    ],
+  },
+  {
+    subject: AbilitySubject.PaymentReceive,
+    subjectLabel: 'ability.payments_receive',
+    abilities: [
+      { key: PaymentReceiveAction.View, label: 'ability.view', default: true },
+      {
+        key: PaymentReceiveAction.Create,
+        label: 'ability.create',
+        default: true,
+      },
+      { key: PaymentReceiveAction.Edit, label: 'ability.edit', default: true },
+      {
+        key: PaymentReceiveAction.Delete,
+        label: 'ability.delete',
+        default: true,
+      },
+    ],
+  },
+  {
+    subject: AbilitySubject.Bill,
+    subjectLabel: 'ability.purchase_invoices',
+    abilities: [
+      { key: BillAction.View, label: 'ability.view', default: true },
+      { key: BillAction.Create, label: 'ability.create', default: true },
+      { key: BillAction.Edit, label: 'ability.edit', default: true },
+      { key: BillAction.Delete, label: 'ability.delete', default: true },
+    ],
+  },
+  {
+    subject: AbilitySubject.VendorCredit,
+    subjectLabel: 'ability.vendor_credit',
+    abilities: [
+      { key: VendorCreditAction.View, label: 'ability.view', default: true },
+      {
+        key: VendorCreditAction.Create,
+        label: 'ability.create',
+        default: true,
+      },
+      { key: VendorCreditAction.Edit, label: 'ability.edit', default: true },
+      {
+        key: VendorCreditAction.Delete,
+        label: 'ability.delete',
+        default: true,
+      },
+      {
+        key: VendorCreditAction.Refund,
+        label: 'ability.refund',
+        default: true,
+      },
+    ],
+  },
+  {
+    subject: AbilitySubject.PaymentMade,
+    subjectLabel: 'ability.payments_made',
+    abilities: [
+      { key: IPaymentMadeAction.View, label: 'ability.view', default: true },
+      {
+        key: IPaymentMadeAction.Create,
+        label: 'ability.create',
+        default: true,
+      },
+      { key: IPaymentMadeAction.Edit, label: 'ability.edit', default: true },
+      {
+        key: IPaymentMadeAction.Delete,
+        label: 'ability.delete',
+        default: true,
+      },
+    ],
+  },
+  {
+    subject: AbilitySubject.Expense,
+    subjectLabel: 'ability.expenses',
+    abilities: [
+      { key: ExpenseAction.View, label: 'ability.view', default: true },
+      { key: ExpenseAction.Create, label: 'ability.create', default: true },
+      { key: ExpenseAction.Edit, label: 'ability.edit', default: true },
+      { key: ExpenseAction.Delete, label: 'ability.delete', default: true },
+    ],
+  },
+  {
+    subject: AbilitySubject.Report,
+    subjectLabel: 'ability.all_reports',
+    extraAbilities: [
+      {
+        key: ReportsAction.READ_BALANCE_SHEET,
+        label: 'ability.balance_sheet_report',
+      },
+      {
+        key: ReportsAction.READ_PROFIT_LOSS,
+        label: 'ability.profit_loss_sheet',
+      },
+      { key: ReportsAction.READ_JOURNAL, label: 'ability.journal' },
+      {
+        key: ReportsAction.READ_GENERAL_LEDGET,
+        label: 'ability.general_ledger',
+      },
+      { key: ReportsAction.READ_CASHFLOW, label: 'ability.cashflow_report' },
+      {
+        key: ReportsAction.READ_AR_AGING_SUMMARY,
+        label: 'ability.AR_aging_summary_report',
+      },
+      {
+        key: ReportsAction.READ_AP_AGING_SUMMARY,
+        label: 'ability.AP_aging_summary_report',
+      },
+      {
+        key: ReportsAction.READ_PURCHASES_BY_ITEMS,
+        label: 'ability.purchases_by_items',
+      },
+      {
+        key: ReportsAction.READ_SALES_BY_ITEMS,
+        label: 'ability.sales_by_items_report',
+      },
+      {
+        key: ReportsAction.READ_CUSTOMERS_TRANSACTIONS,
+        label: 'ability.customers_transactions_report',
+      },
+      {
+        key: ReportsAction.READ_VENDORS_TRANSACTIONS,
+        label: 'ability.vendors_transactions_report',
+      },
+      {
+        key: ReportsAction.READ_CUSTOMERS_SUMMARY_BALANCE,
+        label: 'ability.customers_summary_balance_report',
+      },
+      {
+        key: ReportsAction.READ_VENDORS_SUMMARY_BALANCE,
+        label: 'ability.vendors_summary_balance_report',
+      },
+      {
+        key: ReportsAction.READ_INVENTORY_VALUATION_SUMMARY,
+        label: 'ability.inventory_valuation_summary',
+      },
+      {
+        key: ReportsAction.READ_INVENTORY_ITEM_DETAILS,
+        label: 'ability.inventory_items_details',
+      },
+    ],
+  },
+  {
+    subject: AbilitySubject.Preferences,
+    subjectLabel: 'ability.preferences',
+    extraAbilities: [
+      {
+        key: PreferencesAction.Mutate,
+        label: 'ability.mutate_system_preferences',
+      },
+    ],
+  },
+];
+
+/**
+ * Retrieve the permissions subject.
+ * @param {string} key
+ * @returns {ISubjectAbilitiesSchema | null}
+ */
+export const getPermissionsSubject = (
+  key: string
+): ISubjectAbilitiesSchema | null => {
+  return AbilitySchema.find((subject) => subject.subject === key);
+};
+
+/**
+ * Retrieve the permission subject ability.
+ * @param {String} subjectKey
+ * @param {string} abilityKey
+ * @returns
+ */
+export const getPermissionAbility = (
+  subjectKey: string,
+  abilityKey: string
+): ISubjectAbilitySchema | null => {
+  const subject = getPermissionsSubject(subjectKey);
+
+  return subject?.abilities.find((ability) => ability.key === abilityKey);
+};
diff --git a/packages/server/src/services/Roles/PurgeAuthorizedUser.ts b/packages/server/src/services/Roles/PurgeAuthorizedUser.ts
new file mode 100644
index 000000000..0c1370f4b
--- /dev/null
+++ b/packages/server/src/services/Roles/PurgeAuthorizedUser.ts
@@ -0,0 +1,22 @@
+import { Service } from 'typedi';
+import events from '@/subscribers/events';
+import { ABILITIES_CACHE } from '../../api/middleware/AuthorizationMiddleware';
+
+@Service()
+export default class PurgeAuthorizedUserOnceRoleMutate {
+  /**
+   * Attaches events with handlers.
+   * @param bus 
+   */
+  attach(bus) {
+    bus.subscribe(events.roles.onEdited, this.purgeAuthedUserOnceRoleMutated);
+    bus.subscribe(events.roles.onDeleted, this.purgeAuthedUserOnceRoleMutated);
+  }
+
+  /**
+   * Purges authorized user once role edited or deleted.
+   */
+  purgeAuthedUserOnceRoleMutated({}) {
+    ABILITIES_CACHE.reset();
+  }
+}
diff --git a/packages/server/src/services/Roles/RolePermissionsSchema.ts b/packages/server/src/services/Roles/RolePermissionsSchema.ts
new file mode 100644
index 000000000..81ca73f2f
--- /dev/null
+++ b/packages/server/src/services/Roles/RolePermissionsSchema.ts
@@ -0,0 +1,31 @@
+import { Service, Inject } from 'typedi';
+import * as qim from 'qim';
+
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { AbilitySchema } from './AbilitySchema';
+import I18nService from '@/services/I18n/I18nService';
+
+@Service()
+export default class RolePermissionsSchema {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  i18nService: I18nService;
+
+  /**
+   * Retrieve the role permissions schema.
+   * @param {number} tenantId
+   */
+  getRolePermissionsSchema(tenantId: number) {
+    const $abilities = (f) => (f.abilities ? f : undefined);
+    const $extraAbilities = (f) => (f.extraAbilities ? f : undefined);
+
+    const naviagations = [
+      [qim.$each, 'subjectLabel'],
+      [qim.$each, $abilities, 'abilities', qim.$each, 'label'],
+      [qim.$each, $extraAbilities, 'extraAbilities', qim.$each, 'label'],
+    ];
+    return this.i18nService.i18nApply(naviagations, AbilitySchema, tenantId);
+  }
+}
diff --git a/packages/server/src/services/Roles/RoleTransformer.ts b/packages/server/src/services/Roles/RoleTransformer.ts
new file mode 100644
index 000000000..087b672d2
--- /dev/null
+++ b/packages/server/src/services/Roles/RoleTransformer.ts
@@ -0,0 +1,31 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+
+export class RoleTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return ['name', 'description'];
+  };
+
+  /**
+   * 
+   * @param role 
+   * @returns 
+   */
+  public name(role) {
+    return role.predefined ? this.context.i18n.__(role.name) : role.name;
+  }
+
+  /**
+   * 
+   * @param role 
+   * @returns 
+   */
+  public description(role) {
+    return role.predefined
+      ? this.context.i18n.__(role.description)
+      : role.description;
+  }
+}
diff --git a/packages/server/src/services/Roles/RolesService.ts b/packages/server/src/services/Roles/RolesService.ts
new file mode 100644
index 000000000..7296af53c
--- /dev/null
+++ b/packages/server/src/services/Roles/RolesService.ts
@@ -0,0 +1,291 @@
+import { Service, Inject } from 'typedi';
+import Knex from 'knex';
+import {
+  ICreateRoleDTO,
+  ICreateRolePermissionDTO,
+  IEditRoleDTO,
+  IEditRolePermissionDTO,
+  IRole,
+  IRoleCreatedPayload,
+  IRoleDeletedPayload,
+  IRoleEditedPayload,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ServiceError } from '@/exceptions';
+import { AbilitySchema } from './AbilitySchema';
+import { getInvalidPermissions } from './utils';
+import UnitOfWork from '@/services/UnitOfWork';
+import { ERRORS } from './constants';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import { RoleTransformer } from './RoleTransformer';
+
+@Service()
+export default class RolesService {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Creates a new role and store it to the storage.
+   * @param {number} tenantId
+   * @param {ICreateRoleDTO} createRoleDTO
+   * @returns
+   */
+  public createRole = async (
+    tenantId: number,
+    createRoleDTO: ICreateRoleDTO
+  ) => {
+    const { Role } = this.tenancy.models(tenantId);
+
+    // Validates the invalid permissions.
+    this.validateInvalidPermissions(createRoleDTO.permissions);
+
+    // Transformes the permissions DTO.
+    const permissions = this.tranaformPermissionsDTO(createRoleDTO.permissions);
+
+    // Creates a new role with associated entries under unit-of-work.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Creates a new role to the storage.
+      const role = await Role.query(trx).upsertGraph({
+        name: createRoleDTO.roleName,
+        description: createRoleDTO.roleDescription,
+        permissions,
+      });
+      // Triggers `onRoleCreated` event.
+      await this.eventPublisher.emitAsync(events.roles.onCreated, {
+        tenantId,
+        createRoleDTO,
+        role,
+        trx,
+      } as IRoleCreatedPayload);
+      return role;
+    });
+  };
+
+  /**
+   * Edits details of the given role on the storage.
+   * @param {number} tenantId -
+   * @param {number} roleId -
+   * @param {IEditRoleDTO} editRoleDTO - Edit role DTO.
+   */
+  public editRole = async (
+    tenantId: number,
+    roleId: number,
+    editRoleDTO: IEditRoleDTO
+  ) => {
+    const { Role } = this.tenancy.models(tenantId);
+
+    // Validates the invalid permissions.
+    this.validateInvalidPermissions(editRoleDTO.permissions);
+
+    // Retrieve the given role or throw not found serice error.
+    const oldRole = await this.getRoleOrThrowError(tenantId, roleId);
+
+    const permissions = this.tranaformEditPermissionsDTO(
+      editRoleDTO.permissions
+    );
+    // Updates the role on the storage.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Updates the given role to the storage.
+      const role = await Role.query(trx).upsertGraph({
+        id: roleId,
+        name: editRoleDTO.roleName,
+        description: editRoleDTO.roleDescription,
+        permissions,
+      });
+      // Triggers `onRoleEdited` event.
+      await this.eventPublisher.emitAsync(events.roles.onEdited, {
+        editRoleDTO,
+        oldRole,
+        role,
+        trx,
+      } as IRoleEditedPayload);
+
+      return role;
+    });
+  };
+
+  /**
+   * Retrieve the role or throw not found service error.
+   * @param {number} tenantId
+   * @param {number} roleId
+   * @returns {Promise<IRole>}
+   */
+  public getRoleOrThrowError = async (
+    tenantId: number,
+    roleId: number
+  ): Promise<IRole> => {
+    const { Role } = this.tenancy.models(tenantId);
+
+    const role = await Role.query().findById(roleId);
+
+    this.throwRoleNotFound(role);
+
+    return role;
+  };
+
+  /**
+   * Throw role not found service error if the role is not found.
+   * @param {IRole|null} role
+   */
+  private throwRoleNotFound(role: IRole | null) {
+    if (!role) {
+      throw new ServiceError(ERRORS.ROLE_NOT_FOUND);
+    }
+  }
+
+  /**
+   * Deletes the given role from the storage.
+   * @param {number} tenantId -
+   * @param {number} roleId - Role id.
+   */
+  public deleteRole = async (
+    tenantId: number,
+    roleId: number
+  ): Promise<void> => {
+    const { Role, RolePermission } = this.tenancy.models(tenantId);
+
+    // Retrieve the given role or throw not found serice error.
+    const oldRole = await this.getRoleOrThrowError(tenantId, roleId);
+
+    // Validate role is not predefined.
+    this.validateRoleNotPredefined(oldRole);
+
+    // Validates the given role is not associated to any user.
+    await this.validateRoleNotAssociatedToUser(tenantId, roleId);
+
+    // Deletes the given role and associated models under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Deletes the role associated permissions from the storage.
+      await RolePermission.query(trx).where('roleId', roleId).delete();
+
+      // Deletes the role object form the storage.
+      await Role.query(trx).findById(roleId).delete();
+
+      // Triggers `onRoleDeleted` event.
+      await this.eventPublisher.emitAsync(events.roles.onDeleted, {
+        oldRole,
+        roleId,
+        tenantId,
+        trx,
+      } as IRoleDeletedPayload);
+    });
+  };
+
+  /**
+   * Retrieve the roles list.
+   * @param {number} tenantId
+   * @param {Promise<IRole[]>}
+   */
+  public listRoles = async (tenantId: number): Promise<IRole[]> => {
+    const { Role } = this.tenancy.models(tenantId);
+
+    const roles = await Role.query().withGraphFetched('permissions');
+
+    return this.transformer.transform(tenantId, roles, new RoleTransformer());
+  };
+
+  /**
+   * Retrieve the given role metadata.
+   * @param {number} tenantId
+   * @param {number} roleId - Role id.
+   * @returns {Promise<IRole>}
+   */
+  public getRole = async (tenantId: number, roleId: number): Promise<IRole> => {
+    const { Role } = this.tenancy.models(tenantId);
+
+    const role = await Role.query()
+      .findById(roleId)
+      .withGraphFetched('permissions');
+
+    this.throwRoleNotFound(role);
+
+    return this.transformer.transform(tenantId, role, new RoleTransformer());
+  };
+
+  /**
+   * Valdiates role is not predefined.
+   * @param {IRole} role - Role object.
+   */
+  private validateRoleNotPredefined(role: IRole) {
+    if (role.predefined) {
+      throw new ServiceError(ERRORS.ROLE_PREFINED);
+    }
+  }
+
+  /**
+   * Validates the invalid given permissions.
+   * @param {ICreateRolePermissionDTO[]} permissions -
+   */
+  public validateInvalidPermissions = (
+    permissions: ICreateRolePermissionDTO[]
+  ) => {
+    const invalidPerms = getInvalidPermissions(AbilitySchema, permissions);
+
+    if (invalidPerms.length > 0) {
+      throw new ServiceError(ERRORS.INVALIDATE_PERMISSIONS, null, {
+        invalidPermissions: invalidPerms,
+      });
+    }
+  };
+
+  /**
+   * Transformes new permissions DTO.
+   * @param {ICreateRolePermissionDTO[]} permissions
+   * @returns {ICreateRolePermissionDTO[]}
+   */
+  private tranaformPermissionsDTO = (
+    permissions: ICreateRolePermissionDTO[]
+  ) => {
+    return permissions.map((permission: ICreateRolePermissionDTO) => ({
+      subject: permission.subject,
+      ability: permission.ability,
+      value: permission.value,
+    }));
+  };
+
+  /**
+   * Transformes edit permissions DTO.
+   * @param {ICreateRolePermissionDTO[]} permissions
+   * @returns {IEditRolePermissionDTO[]}
+   */
+  private tranaformEditPermissionsDTO = (
+    permissions: IEditRolePermissionDTO[]
+  ) => {
+    return permissions.map((permission: IEditRolePermissionDTO) => ({
+      permissionId: permission.permissionId,
+      subject: permission.subject,
+      ability: permission.ability,
+      value: permission.value,
+    }));
+  };
+
+  /**
+   * Validates the given role is not associated to any tenant users.
+   * @param {number} tenantId
+   * @param {number} roleId
+   */
+  private validateRoleNotAssociatedToUser = async (
+    tenantId: number,
+    roleId: number
+  ) => {
+    const { User } = this.tenancy.models(tenantId);
+
+    const userAssociatedRole = await User.query().where('roleId', roleId);
+
+    // Throw service error if the role has associated users.
+    if (userAssociatedRole.length > 0) {
+      throw new ServiceError(ERRORS.CANNT_DELETE_ROLE_ASSOCIATED_TO_USERS);
+    }
+  };
+}
diff --git a/packages/server/src/services/Roles/constants.ts b/packages/server/src/services/Roles/constants.ts
new file mode 100644
index 000000000..39d1d768f
--- /dev/null
+++ b/packages/server/src/services/Roles/constants.ts
@@ -0,0 +1,6 @@
+export const ERRORS = {
+  ROLE_NOT_FOUND: 'ROLE_NOT_FOUND',
+  ROLE_PREFINED: 'ROLE_PREFINED',
+  INVALIDATE_PERMISSIONS: 'INVALIDATE_PERMISSIONS',
+  CANNT_DELETE_ROLE_ASSOCIATED_TO_USERS: 'CANNT_DELETE_ROLE_ASSOCIATED_TO_USERS'
+};
diff --git a/packages/server/src/services/Roles/utils.ts b/packages/server/src/services/Roles/utils.ts
new file mode 100644
index 000000000..e391d68e2
--- /dev/null
+++ b/packages/server/src/services/Roles/utils.ts
@@ -0,0 +1,42 @@
+import { keyBy } from 'lodash';
+import { ISubjectAbilitiesSchema } from '@/interfaces';
+
+/**
+ * Transformes ability schema to map.
+ */
+export function transformAbilitySchemaToMap(schema: ISubjectAbilitiesSchema[]) {
+  return keyBy(
+    schema.map((item) => ({
+      ...item,
+      abilities: keyBy(item.abilities, 'key'),
+      extraAbilities: keyBy(item.extraAbilities, 'key'),
+    })),
+    'subject'
+  );
+}
+
+/**
+ * Retrieve the invalid permissions from the given defined schema.
+ * @param {ISubjectAbilitiesSchema[]} schema 
+ * @param permissions 
+ * @returns 
+ */
+export function getInvalidPermissions(
+  schema: ISubjectAbilitiesSchema[],
+  permissions
+) {
+  const schemaMap = transformAbilitySchemaToMap(schema);
+
+  return permissions.filter((permission) => {
+    const { subject, ability } = permission;
+
+    if (
+      !schemaMap[subject] ||
+      (!schemaMap[subject].abilities[ability] &&
+        !schemaMap[subject].extraAbilities[ability])
+    ) {
+      return true;
+    }
+    return false;
+  });
+}
diff --git a/packages/server/src/services/SMSClient/EasySmsClient.ts b/packages/server/src/services/SMSClient/EasySmsClient.ts
new file mode 100644
index 000000000..6081ac0da
--- /dev/null
+++ b/packages/server/src/services/SMSClient/EasySmsClient.ts
@@ -0,0 +1,60 @@
+import axios from 'axios';
+import SMSClientInterface from '@/services/SMSClient/SMSClientInterfaces';
+import config from '@/config';
+
+export default class EasySMSClient implements SMSClientInterface {
+  token: string;
+  clientName: string = 'easysms';
+
+  /**
+   *
+   * @param {string} token
+   */
+  constructor(token: string) {
+    this.token = token;
+  }
+
+  /**
+   * Normalizes the phone number string.
+   * @param {string} phoneNumber
+   * @returns {string}
+   */
+  normlizePhoneNumber = (phoneNumber: string) => {
+    let normalized = phoneNumber;
+
+    normalized = normalized.replace(/^00/, '');
+    normalized = normalized.replace(/^0/, '');
+    normalized = normalized.replace(/^218/, '');
+
+    return normalized;
+  };
+
+  /**
+   * Send message to given phone number via easy SMS client.
+   * @param {string} to
+   * @param {string} message
+   */
+  send = (to: string, message: string) => {
+    const API_KEY = this.token;
+    const parsedTo = this.normlizePhoneNumber(to);
+    const encodedMessage = encodeURIComponent(message);
+    const encodeTo = encodeURIComponent(parsedTo);
+
+    const params = `action=send-sms&api_key=${API_KEY}&to=${encodeTo}&sms=${encodedMessage}&unicode=1`;
+
+    return new Promise((resolve, reject) => {
+      axios
+        .get(`https://easysms.devs.ly/sms/api?${params}`)
+        .then((response) => {
+          if (response.data.code === 'ok') {
+            resolve(response);
+          } else {
+            reject(response.data);
+          }
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  };
+}
diff --git a/packages/server/src/services/SMSClient/SMSAPI.ts b/packages/server/src/services/SMSClient/SMSAPI.ts
new file mode 100644
index 000000000..152cc7d36
--- /dev/null
+++ b/packages/server/src/services/SMSClient/SMSAPI.ts
@@ -0,0 +1,39 @@
+import { Container } from 'typedi';
+import SMSClientInterface from '@/services/SMSClient/SMSClientInterface';
+import { thomsonCrossSectionDependencies } from 'mathjs';
+
+export default class SMSAPI {
+  smsClient: SMSClientInterface;
+
+  constructor(smsClient: SMSClientInterface) {
+    this.smsClient = smsClient;
+  }
+
+  /**
+   * Sends the message to the target via the client.
+   * @param {string} to
+   * @param {string} message
+   * @param {array} extraParams
+   * @param {array} extraHeaders
+   */
+  sendMessage(
+    to: string,
+    message: string,
+    extraParams?: [],
+    extraHeaders?: []
+  ) {
+    return this.smsClient.send(to, message);
+  }
+
+  /**
+   * 
+   * @param to 
+   * @param message 
+   * @returns 
+   */
+  sendMessageJob(to: string, message: string) {
+    const agenda = Container.get('agenda');
+
+    return agenda.now('sms-notification', { to, message });
+  }
+}
diff --git a/packages/server/src/services/SMSClient/SMSClientInterface.ts b/packages/server/src/services/SMSClient/SMSClientInterface.ts
new file mode 100644
index 000000000..8e1c0978b
--- /dev/null
+++ b/packages/server/src/services/SMSClient/SMSClientInterface.ts
@@ -0,0 +1,5 @@
+
+export default interface SMSClientInterface {
+  clientName: string;
+  send(to: string, message: string): boolean;
+}
\ No newline at end of file
diff --git a/packages/server/src/services/SMSClient/index.ts b/packages/server/src/services/SMSClient/index.ts
new file mode 100644
index 000000000..ae92b9bbc
--- /dev/null
+++ b/packages/server/src/services/SMSClient/index.ts
@@ -0,0 +1,3 @@
+import SMSAPI from './SMSAPI';
+
+export default SMSAPI;
\ No newline at end of file
diff --git a/packages/server/src/services/Sales/AutoIncrementOrdersService.ts b/packages/server/src/services/Sales/AutoIncrementOrdersService.ts
new file mode 100644
index 000000000..8141528de
--- /dev/null
+++ b/packages/server/src/services/Sales/AutoIncrementOrdersService.ts
@@ -0,0 +1,64 @@
+import { Service, Inject } from 'typedi';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import { transactionIncrement, parseBoolean } from 'utils';
+
+/**
+ * Auto increment orders service.
+ */
+@Service()
+export default class AutoIncrementOrdersService {
+  @Inject()
+  tenancy: TenancyService;
+
+  autoIncrementEnabled = (tenantId: number, settingsGroup: string): boolean => {
+    const settings = this.tenancy.settings(tenantId);
+    const group = settingsGroup;
+
+    // Settings service transaction number and prefix.
+    const autoIncrement = settings.get({ group, key: 'auto_increment' }, false);
+
+    return parseBoolean(autoIncrement, false);
+  }
+
+  /**
+   * Retrieve the next service transaction number.
+   * @param {number} tenantId
+   * @param {string} settingsGroup
+   * @param {Function} getMaxTransactionNo
+   * @return {Promise<string>}
+   */
+  getNextTransactionNumber(tenantId: number, settingsGroup: string): string {
+    const settings = this.tenancy.settings(tenantId);
+    const group = settingsGroup;
+
+    // Settings service transaction number and prefix.
+    const autoIncrement = settings.get({ group, key: 'auto_increment' }, false);
+
+    const settingNo = settings.get({ group, key: 'next_number' }, '');
+    const settingPrefix = settings.get({ group, key: 'number_prefix' }, '');
+
+    return parseBoolean(autoIncrement, false) ? `${settingPrefix}${settingNo}` : '';
+  }
+
+  /**
+   * Increment setting next number.
+   * @param {number} tenantId -
+   * @param {string} orderGroup - Order group.
+   * @param {string} orderNumber -Order number.
+   */
+  async incrementSettingsNextNumber(tenantId: number, group: string) {
+    const settings = this.tenancy.settings(tenantId);
+
+    const settingNo = settings.get({ group, key: 'next_number' });
+    const autoIncrement = settings.get({ group, key: 'auto_increment' });
+
+    // Can't continue if the auto-increment of the service was disabled.
+    if (!autoIncrement) { return; }
+
+    settings.set(
+      { group, key: 'next_number' },
+      transactionIncrement(settingNo)
+    );
+    await settings.save();
+  }
+}
diff --git a/packages/server/src/services/Sales/Estimates/SaleEstimateSmsNotify.ts b/packages/server/src/services/Sales/Estimates/SaleEstimateSmsNotify.ts
new file mode 100644
index 000000000..037bb0331
--- /dev/null
+++ b/packages/server/src/services/Sales/Estimates/SaleEstimateSmsNotify.ts
@@ -0,0 +1,217 @@
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import events from '@/subscribers/events';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import SaleNotifyBySms from '../SaleNotifyBySms';
+import SmsNotificationsSettingsService from '@/services/Settings/SmsNotificationsSettings';
+import SMSClient from '@/services/SMSClient';
+import {
+  ICustomer,
+  IPaymentReceiveSmsDetails,
+  ISaleEstimate,
+  SMS_NOTIFICATION_KEY,
+} from '@/interfaces';
+import { Tenant, TenantMetadata } from '@/system/models';
+import { formatNumber, formatSmsMessage } from 'utils';
+import { ServiceError } from '@/exceptions';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+const ERRORS = {
+  SALE_ESTIMATE_NOT_FOUND: 'SALE_ESTIMATE_NOT_FOUND',
+};
+
+@Service()
+export default class SaleEstimateNotifyBySms {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  saleSmsNotification: SaleNotifyBySms;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  smsNotificationsSettings: SmsNotificationsSettingsService;
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {number} saleEstimateId
+   * @returns {Promise<ISaleEstimate>}
+   */
+  public notifyBySms = async (
+    tenantId: number,
+    saleEstimateId: number
+  ): Promise<ISaleEstimate> => {
+    const { SaleEstimate } = this.tenancy.models(tenantId);
+
+    // Retrieve the sale invoice or throw not found service error.
+    const saleEstimate = await SaleEstimate.query()
+      .findById(saleEstimateId)
+      .withGraphFetched('customer');
+
+    // Validates the estimate transaction existance.
+    this.validateEstimateExistance(saleEstimate);
+
+    // Validate the customer phone number existance and number validation.
+    this.saleSmsNotification.validateCustomerPhoneNumber(
+      saleEstimate.customer.personalPhone
+    );
+    // Triggers `onSaleEstimateNotifySms` event.
+    await this.eventPublisher.emitAsync(events.saleEstimate.onNotifySms, {
+      tenantId,
+      saleEstimate,
+    });
+    await this.sendSmsNotification(tenantId, saleEstimate);
+
+    // Triggers `onSaleEstimateNotifySms` event.
+    await this.eventPublisher.emitAsync(events.saleEstimate.onNotifiedSms, {
+      tenantId,
+      saleEstimate,
+    });
+    return saleEstimate;
+  };
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {ISaleEstimate} saleEstimate
+   * @returns
+   */
+  private sendSmsNotification = async (
+    tenantId: number,
+    saleEstimate: ISaleEstimate & { customer: ICustomer }
+  ) => {
+    const smsClient = this.tenancy.smsClient(tenantId);
+    const tenantMetadata = await TenantMetadata.query().findOne({ tenantId });
+
+    // Retrieve the formatted sms notification message for estimate details.
+    const formattedSmsMessage = this.formattedEstimateDetailsMessage(
+      tenantId,
+      saleEstimate,
+      tenantMetadata
+    );
+    const phoneNumber = saleEstimate.customer.personalPhone;
+
+    // Runs the send message job.
+    return smsClient.sendMessageJob(phoneNumber, formattedSmsMessage);
+  };
+
+  /**
+   * Notify via SMS message after estimate creation.
+   * @param {number} tenantId
+   * @param {number} saleEstimateId
+   * @returns {Promise<void>}
+   */
+  public notifyViaSmsNotificationAfterCreation = async (
+    tenantId: number,
+    saleEstimateId: number
+  ): Promise<void> => {
+    const notification = this.smsNotificationsSettings.getSmsNotificationMeta(
+      tenantId,
+      SMS_NOTIFICATION_KEY.SALE_ESTIMATE_DETAILS
+    );
+    // Can't continue if the sms auto-notification is not enabled.
+    if (!notification.isNotificationEnabled) return;
+
+    await this.notifyBySms(tenantId, saleEstimateId);
+  };
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {ISaleEstimate} saleEstimate
+   * @param {TenantMetadata} tenantMetadata
+   * @returns {string}
+   */
+  private formattedEstimateDetailsMessage = (
+    tenantId: number,
+    saleEstimate: ISaleEstimate,
+    tenantMetadata: TenantMetadata
+  ): string => {
+    const notification = this.smsNotificationsSettings.getSmsNotificationMeta(
+      tenantId,
+      SMS_NOTIFICATION_KEY.SALE_ESTIMATE_DETAILS
+    );
+    return this.formateEstimateDetailsMessage(
+      notification.smsMessage,
+      saleEstimate,
+      tenantMetadata
+    );
+  };
+
+  /**
+   * Formattes the estimate sms notification details message.
+   * @param {string} smsMessage
+   * @param {ISaleEstimate} saleEstimate
+   * @param {TenantMetadata} tenantMetadata
+   * @returns {string}
+   */
+  private formateEstimateDetailsMessage = (
+    smsMessage: string,
+    saleEstimate: ISaleEstimate & { customer: ICustomer },
+    tenantMetadata: TenantMetadata
+  ) => {
+    const formattedAmount = formatNumber(saleEstimate.amount, {
+      currencyCode: saleEstimate.currencyCode,
+    });
+
+    return formatSmsMessage(smsMessage, {
+      EstimateNumber: saleEstimate.estimateNumber,
+      ReferenceNumber: saleEstimate.reference,
+      EstimateDate: moment(saleEstimate.estimateDate).format('YYYY/MM/DD'),
+      ExpirationDate: saleEstimate.expirationDate
+        ? moment(saleEstimate.expirationDate).format('YYYY/MM/DD')
+        : '',
+      CustomerName: saleEstimate.customer.displayName,
+      Amount: formattedAmount,
+      CompanyName: tenantMetadata.name,
+    });
+  };
+
+  /**
+   * Retrieve the SMS details of the given payment receive transaction.
+   * @param {number} tenantId
+   * @param {number} saleEstimateId
+   * @returns {Promise<IPaymentReceiveSmsDetails>}
+   */
+  public smsDetails = async (
+    tenantId: number,
+    saleEstimateId: number
+  ): Promise<IPaymentReceiveSmsDetails> => {
+    const { SaleEstimate } = this.tenancy.models(tenantId);
+
+    // Retrieve the sale invoice or throw not found service error.
+    const saleEstimate = await SaleEstimate.query()
+      .findById(saleEstimateId)
+      .withGraphFetched('customer');
+
+    this.validateEstimateExistance(saleEstimate);
+
+    // Retrieve the current tenant metadata.
+    const tenantMetadata = await TenantMetadata.query().findOne({ tenantId });
+
+    // Retrieve the formatted sms message from the given estimate model.
+    const formattedSmsMessage = this.formattedEstimateDetailsMessage(
+      tenantId,
+      saleEstimate,
+      tenantMetadata
+    );
+    return {
+      customerName: saleEstimate.customer.displayName,
+      customerPhoneNumber: saleEstimate.customer.personalPhone,
+      smsMessage: formattedSmsMessage,
+    };
+  };
+
+  /**
+   * Validates the sale estimate existance.
+   * @param {ISaleEstimate} saleEstimate -
+   */
+  private validateEstimateExistance(saleEstimate: ISaleEstimate) {
+    if (!saleEstimate) {
+      throw new ServiceError(ERRORS.SALE_ESTIMATE_NOT_FOUND);
+    }
+  }
+}
diff --git a/packages/server/src/services/Sales/Estimates/SaleEstimateTransformer.ts b/packages/server/src/services/Sales/Estimates/SaleEstimateTransformer.ts
new file mode 100644
index 000000000..ad69bf867
--- /dev/null
+++ b/packages/server/src/services/Sales/Estimates/SaleEstimateTransformer.ts
@@ -0,0 +1,77 @@
+import { Service } from 'typedi';
+import { ISaleEstimate } from '@/interfaces';
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export default class SaleEstimateTransfromer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedAmount',
+      'formattedEstimateDate',
+      'formattedExpirationDate',
+      'formattedDeliveredAtDate',
+      'formattedApprovedAtDate',
+      'formattedRejectedAtDate',
+    ];
+  };
+
+  /**
+   * Retrieve formatted estimate date.
+   * @param {ISaleEstimate} invoice
+   * @returns {String}
+   */
+  protected formattedEstimateDate = (estimate: ISaleEstimate): string => {
+    return this.formatDate(estimate.estimateDate);
+  };
+
+  /**
+   * Retrieve formatted estimate date.
+   * @param {ISaleEstimate} invoice
+   * @returns {String}
+   */
+  protected formattedExpirationDate = (estimate: ISaleEstimate): string => {
+    return this.formatDate(estimate.expirationDate);
+  };
+
+  /**
+   * Retrieve formatted estimate date.
+   * @param {ISaleEstimate} invoice
+   * @returns {String}
+   */
+  protected formattedDeliveredAtDate = (estimate: ISaleEstimate): string => {
+    return this.formatDate(estimate.deliveredAt);
+  };
+
+  /**
+   * Retrieve formatted estimate date.
+   * @param {ISaleEstimate} invoice
+   * @returns {String}
+   */
+  protected formattedApprovedAtDate = (estimate: ISaleEstimate): string => {
+    return this.formatDate(estimate.approvedAt);
+  };
+
+  /**
+   * Retrieve formatted estimate date.
+   * @param {ISaleEstimate} invoice
+   * @returns {String}
+   */
+  protected formattedRejectedAtDate = (estimate: ISaleEstimate): string => {
+    return this.formatDate(estimate.rejectedAt);
+  };
+
+  /**
+   * Retrieve formatted invoice amount.
+   * @param {ISaleEstimate} estimate
+   * @returns {string}
+   */
+  protected formattedAmount = (estimate: ISaleEstimate): string => {
+    return formatNumber(estimate.amount, {
+      currencyCode: estimate.currencyCode,
+    });
+  };
+}
diff --git a/packages/server/src/services/Sales/Estimates/SaleEstimatesPdf.ts b/packages/server/src/services/Sales/Estimates/SaleEstimatesPdf.ts
new file mode 100644
index 000000000..f5959cd0a
--- /dev/null
+++ b/packages/server/src/services/Sales/Estimates/SaleEstimatesPdf.ts
@@ -0,0 +1,36 @@
+import { Inject, Service } from 'typedi';
+import PdfService from '@/services/PDF/PdfService';
+import { templateRender } from 'utils';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Tenant } from '@/system/models';
+
+@Service()
+export default class SaleEstimatesPdf {
+  @Inject()
+  pdfService: PdfService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve sale invoice pdf content.
+   * @param {} saleInvoice -
+   */
+  async saleEstimatePdf(tenantId: number, saleEstimate) {
+    const i18n = this.tenancy.i18n(tenantId);
+
+    const organization = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const htmlContent = templateRender('modules/estimate-regular', {
+      saleEstimate,
+      organizationName: organization.metadata.name,
+      organizationEmail: organization.metadata.email,
+      ...i18n,
+    });
+    const pdfContent = await this.pdfService.pdfDocument(htmlContent);
+
+    return pdfContent;
+  }
+}
diff --git a/packages/server/src/services/Sales/Estimates/constants.ts b/packages/server/src/services/Sales/Estimates/constants.ts
new file mode 100644
index 000000000..2b58c74a8
--- /dev/null
+++ b/packages/server/src/services/Sales/Estimates/constants.ts
@@ -0,0 +1,109 @@
+
+export const ERRORS = {
+  SALE_ESTIMATE_NOT_FOUND: 'SALE_ESTIMATE_NOT_FOUND',
+  SALE_ESTIMATE_NUMBER_EXISTANCE: 'SALE_ESTIMATE_NUMBER_EXISTANCE',
+  SALE_ESTIMATE_CONVERTED_TO_INVOICE: 'SALE_ESTIMATE_CONVERTED_TO_INVOICE',
+  SALE_ESTIMATE_NOT_DELIVERED: 'SALE_ESTIMATE_NOT_DELIVERED',
+  SALE_ESTIMATE_ALREADY_REJECTED: 'SALE_ESTIMATE_ALREADY_REJECTED',
+  CUSTOMER_HAS_SALES_ESTIMATES: 'CUSTOMER_HAS_SALES_ESTIMATES',
+  SALE_ESTIMATE_NO_IS_REQUIRED: 'SALE_ESTIMATE_NO_IS_REQUIRED',
+  SALE_ESTIMATE_ALREADY_DELIVERED: 'SALE_ESTIMATE_ALREADY_DELIVERED',
+  SALE_ESTIMATE_ALREADY_APPROVED: 'SALE_ESTIMATE_ALREADY_APPROVED'
+};
+
+export const DEFAULT_VIEW_COLUMNS = [];
+export const DEFAULT_VIEWS = [
+  {
+    name: 'Draft',
+    slug: 'draft',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'draft' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Delivered',
+    slug: 'delivered',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'delivered',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Approved',
+    slug: 'approved',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'approved',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Rejected',
+    slug: 'rejected',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'rejected',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Invoiced',
+    slug: 'invoiced',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'invoiced',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Expired',
+    slug: 'expired',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'expired',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Closed',
+    slug: 'closed',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'closed',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+];
diff --git a/packages/server/src/services/Sales/HasItemsEntries.ts b/packages/server/src/services/Sales/HasItemsEntries.ts
new file mode 100644
index 000000000..9208c893d
--- /dev/null
+++ b/packages/server/src/services/Sales/HasItemsEntries.ts
@@ -0,0 +1,30 @@
+import { difference, omit } from 'lodash';
+import { Service, Inject } from 'typedi';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import { ItemEntry } from 'models';
+
+@Service()
+export default class HasItemEntries {
+  @Inject()
+  tenancy: TenancyService;
+
+  filterNonInventoryEntries(entries: [], items: []) {
+    const nonInventoryItems = items.filter((item: any) => item.type !== 'inventory');
+    const nonInventoryItemsIds = nonInventoryItems.map((i: any) => i.id);
+
+    return entries
+      .filter((entry: any) => (
+        (nonInventoryItemsIds.indexOf(entry.item_id)) !== -1
+      ));
+  }
+  
+  filterInventoryEntries(entries: [], items: []) {
+    const inventoryItems = items.filter((item: any) => item.type === 'inventory');
+    const inventoryItemsIds = inventoryItems.map((i: any) => i.id);
+
+    return entries
+      .filter((entry: any) => (
+        (inventoryItemsIds.indexOf(entry.item_id)) !== -1
+      ));
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Sales/Invoices/InvoiceGLEntries.ts b/packages/server/src/services/Sales/Invoices/InvoiceGLEntries.ts
new file mode 100644
index 000000000..791991b91
--- /dev/null
+++ b/packages/server/src/services/Sales/Invoices/InvoiceGLEntries.ts
@@ -0,0 +1,203 @@
+import * as R from 'ramda';
+import {
+  ISaleInvoice,
+  IItemEntry,
+  ILedgerEntry,
+  AccountNormal,
+  ILedger,
+} from '@/interfaces';
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import Ledger from '@/services/Accounting/Ledger';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class SaleInvoiceGLEntries {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private ledegrRepository: LedgerStorageService;
+
+  /**
+   * Writes a sale invoice GL entries.
+   * @param {number} tenantId
+   * @param {number} saleInvoiceId
+   * @param {Knex.Transaction} trx
+   */
+  public writeInvoiceGLEntries = async (
+    tenantId: number,
+    saleInvoiceId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    const saleInvoice = await SaleInvoice.query(trx)
+      .findById(saleInvoiceId)
+      .withGraphFetched('entries.item');
+
+    // Find or create the A/R account.
+    const ARAccount = await accountRepository.findOrCreateAccountReceivable(
+      saleInvoice.currencyCode
+    );
+    // Retrieves the ledger of the invoice.
+    const ledger = this.getInvoiceGLedger(saleInvoice, ARAccount.id);
+
+    // Commits the ledger entries to the storage as UOW.
+    await this.ledegrRepository.commit(tenantId, ledger, trx);
+  };
+
+  /**
+   * Rewrites the given invoice GL entries.
+   * @param {number} tenantId
+   * @param {number} saleInvoiceId
+   * @param {Knex.Transaction} trx
+   */
+  public rewritesInvoiceGLEntries = async (
+    tenantId: number,
+    saleInvoiceId: number,
+    trx?: Knex.Transaction
+  ) => {
+    // Reverts the invoice GL entries.
+    await this.revertInvoiceGLEntries(tenantId, saleInvoiceId, trx);
+
+    // Writes the invoice GL entries.
+    await this.writeInvoiceGLEntries(tenantId, saleInvoiceId, trx);
+  };
+
+  /**
+   * Reverts the given invoice GL entries.
+   * @param {number} tenantId
+   * @param {number} saleInvoiceId
+   * @param {Knex.Transaction} trx
+   */
+  public revertInvoiceGLEntries = async (
+    tenantId: number,
+    saleInvoiceId: number,
+    trx?: Knex.Transaction
+  ) => {
+    await this.ledegrRepository.deleteByReference(
+      tenantId,
+      saleInvoiceId,
+      'SaleInvoice',
+      trx
+    );
+  };
+
+  /**
+   * Retrieves the given invoice ledger.
+   * @param   {ISaleInvoice} saleInvoice
+   * @param   {number} ARAccountId
+   * @returns {ILedger}
+   */
+  public getInvoiceGLedger = (
+    saleInvoice: ISaleInvoice,
+    ARAccountId: number
+  ): ILedger => {
+    const entries = this.getInvoiceGLEntries(saleInvoice, ARAccountId);
+
+    return new Ledger(entries);
+  };
+
+  /**
+   * Retrieves the invoice GL common entry.
+   * @param   {ISaleInvoice} saleInvoice
+   * @returns {Partial<ILedgerEntry>}
+   */
+  private getInvoiceGLCommonEntry = (
+    saleInvoice: ISaleInvoice
+  ): Partial<ILedgerEntry> => ({
+    credit: 0,
+    debit: 0,
+    currencyCode: saleInvoice.currencyCode,
+    exchangeRate: saleInvoice.exchangeRate,
+
+    transactionType: 'SaleInvoice',
+    transactionId: saleInvoice.id,
+
+    date: saleInvoice.invoiceDate,
+    userId: saleInvoice.userId,
+
+    transactionNumber: saleInvoice.invoiceNo,
+    referenceNumber: saleInvoice.referenceNo,
+
+    createdAt: saleInvoice.createdAt,
+    indexGroup: 10,
+
+    branchId: saleInvoice.branchId,
+  });
+
+  /**
+   * Retrieve receivable entry of the given invoice.
+   * @param   {ISaleInvoice} saleInvoice
+   * @param   {number} ARAccountId
+   * @returns {ILedgerEntry}
+   */
+  private getInvoiceReceivableEntry = (
+    saleInvoice: ISaleInvoice,
+    ARAccountId: number
+  ): ILedgerEntry => {
+    const commonEntry = this.getInvoiceGLCommonEntry(saleInvoice);
+
+    return {
+      ...commonEntry,
+      debit: saleInvoice.localAmount,
+      accountId: ARAccountId,
+      contactId: saleInvoice.customerId,
+      accountNormal: AccountNormal.DEBIT,
+      index: 1,
+    } as ILedgerEntry;
+  };
+
+  /**
+   * Retrieve item income entry of the given invoice.
+   * @param   {ISaleInvoice} saleInvoice -
+   * @param   {IItemEntry} entry -
+   * @param   {number} index -
+   * @returns {ILedgerEntry}
+   */
+  private getInvoiceItemEntry = R.curry(
+    (
+      saleInvoice: ISaleInvoice,
+      entry: IItemEntry,
+      index: number
+    ): ILedgerEntry => {
+      const commonEntry = this.getInvoiceGLCommonEntry(saleInvoice);
+      const localAmount = entry.amount * saleInvoice.exchangeRate;
+
+      return {
+        ...commonEntry,
+        credit: localAmount,
+        accountId: entry.sellAccountId,
+        note: entry.description,
+        index: index + 2,
+        itemId: entry.itemId,
+        itemQuantity: entry.quantity,
+        accountNormal: AccountNormal.CREDIT,
+        projectId: entry.projectId || saleInvoice.projectId
+      };
+    }
+  );
+
+  /**
+   * Retrieves the invoice GL entries.
+   * @param   {ISaleInvoice} saleInvoice
+   * @param   {number} ARAccountId
+   * @returns {ILedgerEntry[]}
+   */
+  public getInvoiceGLEntries = (
+    saleInvoice: ISaleInvoice,
+    ARAccountId: number
+  ): ILedgerEntry[] => {
+    const receivableEntry = this.getInvoiceReceivableEntry(
+      saleInvoice,
+      ARAccountId
+    );
+    const transformItemEntry = this.getInvoiceItemEntry(saleInvoice);
+    const creditEntries = saleInvoice.entries.map(transformItemEntry);
+
+    return [receivableEntry, ...creditEntries];
+  };
+}
diff --git a/packages/server/src/services/Sales/Invoices/InvoicePaymentTransactionTransformer.ts b/packages/server/src/services/Sales/Invoices/InvoicePaymentTransactionTransformer.ts
new file mode 100644
index 000000000..602fc491c
--- /dev/null
+++ b/packages/server/src/services/Sales/Invoices/InvoicePaymentTransactionTransformer.ts
@@ -0,0 +1,56 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class InvoicePaymentTransactionTransformer extends Transformer {
+  /**
+   * Include these attributes to sale credit note object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return ['formattedPaymentAmount', 'formattedPaymentDate'];
+  };
+
+  /**
+   * Retrieve formatted invoice amount.
+   * @param {ICreditNote} credit
+   * @returns {string}
+   */
+  protected formattedPaymentAmount = (entry): string => {
+    return formatNumber(entry.paymentAmount, {
+      currencyCode: entry.payment.currencyCode,
+    });
+  };
+
+  protected formattedPaymentDate = (entry): string => {
+    return this.formatDate(entry.payment.paymentDate);
+  };
+
+  /**
+   *
+   * @param entry
+   * @returns
+   */
+  public transform = (entry) => {
+    return {
+      invoiceId: entry.invoiceId,
+      paymentReceiveId: entry.paymentReceiveId,
+
+      paymentDate: entry.payment.paymentDate,
+      formattedPaymentDate: entry.formattedPaymentDate,
+
+      paymentAmount: entry.paymentAmount,
+      formattedPaymentAmount: entry.formattedPaymentAmount,
+      currencyCode: entry.payment.currencyCode,
+
+      paymentNumber: entry.payment.paymentReceiveNo,
+      paymentReferenceNo: entry.payment.referenceNo,
+
+      invoiceNumber: entry.invoice.invoiceNo,
+      invoiceReferenceNo: entry.invoice.referenceNo,
+
+      depositAccountId: entry.payment.depositAccountId,
+      depositAccountName: entry.payment.depositAccount.name,
+      depositAccountSlug: entry.payment.depositAccount.slug,
+    };
+  };
+}
diff --git a/packages/server/src/services/Sales/Invoices/InvoicePaymentsGLRewrite.ts b/packages/server/src/services/Sales/Invoices/InvoicePaymentsGLRewrite.ts
new file mode 100644
index 000000000..82c61361b
--- /dev/null
+++ b/packages/server/src/services/Sales/Invoices/InvoicePaymentsGLRewrite.ts
@@ -0,0 +1,76 @@
+import { Knex } from 'knex';
+import async from 'async';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+import { PaymentReceiveGLEntries } from '../PaymentReceives/PaymentReceiveGLEntries';
+
+@Service()
+export class InvoicePaymentsGLEntriesRewrite {
+  @Inject()
+  public tenancy: HasTenancyService;
+
+  @Inject()
+  public paymentGLEntries: PaymentReceiveGLEntries;
+
+  /**
+   * Rewrites the payment GL entries task.
+   * @param   {{ tenantId: number, paymentId: number, trx: Knex?.Transaction }}
+   * @returns {Promise<void>}
+   */
+  public rewritePaymentsGLEntriesTask = async ({
+    tenantId,
+    paymentId,
+    trx,
+  }) => {
+    await this.paymentGLEntries.rewritePaymentGLEntries(
+      tenantId,
+      paymentId,
+      trx
+    );
+  };
+
+  /**
+   * Rewrites the payment GL entries of the given payments ids.
+   * @param {number} tenantId
+   * @param {number[]} paymentsIds
+   * @param {Knex.Transaction} trx
+   */
+  public rewritePaymentsGLEntriesQueue = async (
+    tenantId: number,
+    paymentsIds: number[],
+    trx?: Knex.Transaction
+  ) => {
+    // Initiate a new queue for accounts balance mutation.
+    const rewritePaymentGL = async.queue(this.rewritePaymentsGLEntriesTask, 10);
+
+    paymentsIds.forEach((paymentId: number) => {
+      rewritePaymentGL.push({ paymentId, trx, tenantId });
+    });
+    if (paymentsIds.length > 0) {
+      await rewritePaymentGL.drain();
+    }
+  };
+
+  /**
+   * Rewrites the payments GL entries that associated to the given invoice.
+   * @param   {number} tenantId
+   * @param   {number} invoiceId
+   * @param   {Knex.Transaction} trx
+   * @returns {Promise<void>}
+   */
+  public invoicePaymentsGLEntriesRewrite = async (
+    tenantId: number,
+    invoiceId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { PaymentReceiveEntry } = this.tenancy.models(tenantId);
+
+    const invoicePaymentEntries = await PaymentReceiveEntry.query().where(
+      'invoiceId',
+      invoiceId
+    );
+    const paymentsIds = invoicePaymentEntries.map((e) => e.paymentReceiveId);
+
+    await this.rewritePaymentsGLEntriesQueue(tenantId, paymentsIds, trx);
+  };
+}
diff --git a/packages/server/src/services/Sales/Invoices/InvoicePaymentsService.ts b/packages/server/src/services/Sales/Invoices/InvoicePaymentsService.ts
new file mode 100644
index 000000000..7d4dd1115
--- /dev/null
+++ b/packages/server/src/services/Sales/Invoices/InvoicePaymentsService.ts
@@ -0,0 +1,34 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { InvoicePaymentTransactionTransformer } from './InvoicePaymentTransactionTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export default class InvoicePaymentsService {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve the invoice assocaited payments transactions.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} invoiceId - Invoice id.
+   */
+  public getInvoicePayments = async (tenantId: number, invoiceId: number) => {
+    const { PaymentReceiveEntry } = this.tenancy.models(tenantId);
+
+    const paymentsEntries = await PaymentReceiveEntry.query()
+      .where('invoiceId', invoiceId)
+      .withGraphJoined('payment.depositAccount')
+      .withGraphJoined('invoice')
+      .orderBy('payment:paymentDate', 'ASC');
+
+    return this.transformer.transform(
+      tenantId,
+      paymentsEntries,
+      new InvoicePaymentTransactionTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/Sales/Invoices/SaleInvoiceCostGLEntries.ts b/packages/server/src/services/Sales/Invoices/SaleInvoiceCostGLEntries.ts
new file mode 100644
index 000000000..ad5951e4d
--- /dev/null
+++ b/packages/server/src/services/Sales/Invoices/SaleInvoiceCostGLEntries.ts
@@ -0,0 +1,146 @@
+import { Service, Inject } from 'typedi';
+import * as R from 'ramda';
+import { Knex } from 'knex';
+import { AccountNormal, IInventoryLotCost, ILedgerEntry } from '@/interfaces';
+import { increment } from 'utils';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import Ledger from '@/services/Accounting/Ledger';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import { groupInventoryTransactionsByTypeId } from '../../Inventory/utils';
+
+@Service()
+export class SaleInvoiceCostGLEntries {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private ledgerStorage: LedgerStorageService;
+
+  /**
+   * Writes journal entries from sales invoices.
+   * @param {number} tenantId - The tenant id.
+   * @param {Date} startingDate - Starting date.
+   * @param {boolean} override
+   */
+  public writeInventoryCostJournalEntries = async (
+    tenantId: number,
+    startingDate: Date,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { InventoryCostLotTracker } = this.tenancy.models(tenantId);
+
+    const inventoryCostLotTrans = await InventoryCostLotTracker.query()
+      .where('direction', 'OUT')
+      .where('transaction_type', 'SaleInvoice')
+      .where('cost', '>', 0)
+      .modify('filterDateRange', startingDate)
+      .orderBy('date', 'ASC')
+      .withGraphFetched('invoice')
+      .withGraphFetched('item');
+
+    const ledger = this.getInventoryCostLotsLedger(inventoryCostLotTrans);
+
+    // Commit the ledger to the storage.
+    await this.ledgerStorage.commit(tenantId, ledger, trx);
+  };
+
+  /**
+   * Retrieves the inventory cost lots ledger.
+   * @param   {IInventoryLotCost[]} inventoryCostLots
+   * @returns {Ledger}
+   */
+  private getInventoryCostLotsLedger = (
+    inventoryCostLots: IInventoryLotCost[]
+  ) => {
+    // Groups the inventory cost lots transactions.
+    const inventoryTransactions =
+      groupInventoryTransactionsByTypeId(inventoryCostLots);
+
+    const entries = inventoryTransactions
+      .map(this.getSaleInvoiceCostGLEntries)
+      .flat();
+    return new Ledger(entries);
+  };
+
+  /**
+   *
+   * @param   {IInventoryLotCost} inventoryCostLot
+   * @returns {}
+   */
+  private getInvoiceCostGLCommonEntry = (
+    inventoryCostLot: IInventoryLotCost
+  ) => {
+    return {
+      currencyCode: inventoryCostLot.invoice.currencyCode,
+      exchangeRate: inventoryCostLot.invoice.exchangeRate,
+
+      transactionType: inventoryCostLot.transactionType,
+      transactionId: inventoryCostLot.transactionId,
+
+      date: inventoryCostLot.date,
+      indexGroup: 20,
+      costable: true,
+      createdAt: inventoryCostLot.createdAt,
+
+      debit: 0,
+      credit: 0,
+
+      branchId: inventoryCostLot.invoice.branchId,
+    };
+  };
+
+  /**
+   * Retrieves the inventory cost GL entry.
+   * @param   {IInventoryLotCost} inventoryLotCost
+   * @returns {ILedgerEntry[]}
+   */
+  private getInventoryCostGLEntry = R.curry(
+    (
+      getIndexIncrement,
+      inventoryCostLot: IInventoryLotCost
+    ): ILedgerEntry[] => {
+      const commonEntry = this.getInvoiceCostGLCommonEntry(inventoryCostLot);
+      const costAccountId =
+        inventoryCostLot.costAccountId || inventoryCostLot.item.costAccountId;
+
+      // XXX Debit - Cost account.
+      const costEntry = {
+        ...commonEntry,
+        debit: inventoryCostLot.cost,
+        accountId: costAccountId,
+        accountNormal: AccountNormal.DEBIT,
+        itemId: inventoryCostLot.itemId,
+        index: getIndexIncrement(),
+      };
+      // XXX Credit - Inventory account.
+      const inventoryEntry = {
+        ...commonEntry,
+        credit: inventoryCostLot.cost,
+        accountId: inventoryCostLot.item.inventoryAccountId,
+        accountNormal: AccountNormal.DEBIT,
+        itemId: inventoryCostLot.itemId,
+        index: getIndexIncrement(),
+      };
+      return [costEntry, inventoryEntry];
+    }
+  );
+
+  /**
+   * Writes journal entries for given sale invoice.
+   * -------
+   * - Cost of goods sold -> Debit -> YYYY
+   *    - Inventory assets -> Credit -> YYYY
+   * --------
+   * @param {ISaleInvoice} saleInvoice
+   * @param {JournalPoster} journal
+   */
+  public getSaleInvoiceCostGLEntries = (
+    inventoryCostLots: IInventoryLotCost[]
+  ): ILedgerEntry[] => {
+    const getIndexIncrement = increment(0);
+    const getInventoryLotEntry =
+      this.getInventoryCostGLEntry(getIndexIncrement);
+
+    return inventoryCostLots.map(getInventoryLotEntry).flat();
+  };
+}
diff --git a/packages/server/src/services/Sales/Invoices/subscribers/InvoiceCostGLEntriesSubscriber.ts b/packages/server/src/services/Sales/Invoices/subscribers/InvoiceCostGLEntriesSubscriber.ts
new file mode 100644
index 000000000..e18c8cf78
--- /dev/null
+++ b/packages/server/src/services/Sales/Invoices/subscribers/InvoiceCostGLEntriesSubscriber.ts
@@ -0,0 +1,36 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import { IInventoryCostLotsGLEntriesWriteEvent } from '@/interfaces';
+import { SaleInvoiceCostGLEntries } from '../SaleInvoiceCostGLEntries';
+
+@Service()
+export class InvoiceCostGLEntriesSubscriber {
+  @Inject()
+  invoiceCostEntries: SaleInvoiceCostGLEntries;
+
+  /**
+   * Attaches events.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.inventory.onCostLotsGLEntriesWrite,
+      this.writeInvoicesCostEntriesOnCostLotsWritten
+    );
+  }
+
+  /**
+   * Writes the invoices cost GL entries once the inventory cost lots be written.
+   * @param {IInventoryCostLotsGLEntriesWriteEvent}
+   */
+  private writeInvoicesCostEntriesOnCostLotsWritten = async ({
+    trx,
+    startingDate,
+    tenantId,
+  }: IInventoryCostLotsGLEntriesWriteEvent) => {
+    await this.invoiceCostEntries.writeInventoryCostJournalEntries(
+      tenantId,
+      startingDate,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Sales/Invoices/subscribers/InvoicePaymentGLRewriteSubscriber.ts b/packages/server/src/services/Sales/Invoices/subscribers/InvoicePaymentGLRewriteSubscriber.ts
new file mode 100644
index 000000000..d40a6538c
--- /dev/null
+++ b/packages/server/src/services/Sales/Invoices/subscribers/InvoicePaymentGLRewriteSubscriber.ts
@@ -0,0 +1,37 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { ISaleInvoiceEditingPayload } from '@/interfaces';
+import { InvoicePaymentsGLEntriesRewrite } from '../InvoicePaymentsGLRewrite';
+
+@Service()
+export class InvoicePaymentGLRewriteSubscriber {
+  @Inject()
+  private invoicePaymentsRewriteGLEntries: InvoicePaymentsGLEntriesRewrite;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.saleInvoice.onEdited,
+      this.paymentGLEntriesRewriteOnPaymentEdit
+    );
+    return bus;
+  };
+
+  /**
+   * Writes associated invoiceso of payment receive once edit.
+   * @param {ISaleInvoiceEditingPayload} -
+   */
+  private paymentGLEntriesRewriteOnPaymentEdit = async ({
+    tenantId,
+    oldSaleInvoice,
+    trx,
+  }: ISaleInvoiceEditingPayload) => {
+    await this.invoicePaymentsRewriteGLEntries.invoicePaymentsGLEntriesRewrite(
+      tenantId,
+      oldSaleInvoice.id,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Sales/JournalPosterService.ts b/packages/server/src/services/Sales/JournalPosterService.ts
new file mode 100644
index 000000000..9b4c9d104
--- /dev/null
+++ b/packages/server/src/services/Sales/JournalPosterService.ts
@@ -0,0 +1,36 @@
+import { Service, Inject } from 'typedi';
+import JournalPoster from '@/services/Accounting/JournalPoster';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import JournalCommands from '@/services/Accounting/JournalCommands';
+import Knex from 'knex';
+
+@Service()
+export default class JournalPosterService {
+  @Inject()
+  tenancy: TenancyService;
+
+  /**
+   * Deletes the journal transactions that associated to the given reference id.
+   * @param {number} tenantId - The given tenant id.
+   * @param {number} referenceId - The transaction reference id.
+   * @param {string} referenceType - The transaction reference type.
+   * @return {Promise}
+   */
+  async revertJournalTransactions(
+    tenantId: number,
+    referenceId: number|number[],
+    referenceType: string|string[],
+    trx?: Knex.Transaction
+  ): Promise<void> {
+    const journal = new JournalPoster(tenantId, null, trx);
+    const journalCommand = new JournalCommands(journal);
+
+    await journalCommand.revertJournalEntries(referenceId, referenceType);
+
+    await Promise.all([
+      journal.deleteEntries(),
+      journal.saveBalance(),
+      journal.saveContactsBalance(),
+    ]);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Sales/PaymentReceives/GetPaymentReeceivePdf.ts b/packages/server/src/services/Sales/PaymentReceives/GetPaymentReeceivePdf.ts
new file mode 100644
index 000000000..76abd1e5d
--- /dev/null
+++ b/packages/server/src/services/Sales/PaymentReceives/GetPaymentReeceivePdf.ts
@@ -0,0 +1,37 @@
+import { Inject, Service } from 'typedi';
+import PdfService from '@/services/PDF/PdfService';
+import { templateRender } from 'utils';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Tenant } from '@/system/models';
+
+@Service()
+export default class GetPaymentReceivePdf {
+  @Inject()
+  pdfService: PdfService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve sale invoice pdf content.
+   * @param {} saleInvoice -
+   */
+  async getPaymentReceivePdf(tenantId: number, paymentReceive) {
+    const i18n = this.tenancy.i18n(tenantId);
+
+    const organization = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const htmlContent = templateRender('modules/payment-receive-standard', {
+      organization,
+      organizationName: organization.metadata.name,
+      organizationEmail: organization.metadata.email,
+      paymentReceive,
+      ...i18n,
+    });
+    const pdfContent = await this.pdfService.pdfDocument(htmlContent);
+
+    return pdfContent;
+  }
+}
diff --git a/packages/server/src/services/Sales/PaymentReceives/PaymentReceiveGLEntries.ts b/packages/server/src/services/Sales/PaymentReceives/PaymentReceiveGLEntries.ts
new file mode 100644
index 000000000..e804733c0
--- /dev/null
+++ b/packages/server/src/services/Sales/PaymentReceives/PaymentReceiveGLEntries.ts
@@ -0,0 +1,299 @@
+import { Service, Inject } from 'typedi';
+import { sumBy } from 'lodash';
+import { Knex } from 'knex';
+import Ledger from '@/services/Accounting/Ledger';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import {
+  IPaymentReceive,
+  ILedgerEntry,
+  AccountNormal,
+  IPaymentReceiveGLCommonEntry,
+} from '@/interfaces';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import { TenantMetadata } from '@/system/models';
+
+@Service()
+export class PaymentReceiveGLEntries {
+  @Inject()
+  private tenancy: TenancyService;
+
+  @Inject()
+  private ledgerStorage: LedgerStorageService;
+
+  /**
+   * Writes payment GL entries to the storage.
+   * @param   {number} tenantId
+   * @param   {number} paymentReceiveId
+   * @param   {Knex.Transaction} trx
+   * @returns {Promise<void>}
+   */
+  public writePaymentGLEntries = async (
+    tenantId: number,
+    paymentReceiveId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { PaymentReceive } = this.tenancy.models(tenantId);
+
+    // Retrieves the given tenant metadata.
+    const tenantMeta = await TenantMetadata.query().findOne({ tenantId });
+
+    // Retrieves the payment receive with associated entries.
+    const paymentReceive = await PaymentReceive.query(trx)
+      .findById(paymentReceiveId)
+      .withGraphFetched('entries.invoice');
+
+    // Retrives the payment receive ledger.
+    const ledger = await this.getPaymentReceiveGLedger(
+      tenantId,
+      paymentReceive,
+      tenantMeta.baseCurrency,
+      trx
+    );
+    // Commit the ledger entries to the storage.
+    await this.ledgerStorage.commit(tenantId, ledger, trx);
+  };
+
+  /**
+   * Reverts the given payment receive GL entries.
+   * @param {number} tenantId
+   * @param {number} paymentReceiveId
+   * @param {Knex.Transaction} trx
+   */
+  public revertPaymentGLEntries = async (
+    tenantId: number,
+    paymentReceiveId: number,
+    trx?: Knex.Transaction
+  ) => {
+    await this.ledgerStorage.deleteByReference(
+      tenantId,
+      paymentReceiveId,
+      'PaymentReceive',
+      trx
+    );
+  };
+
+  /**
+   * Rewrites the given payment receive GL entries.
+   * @param {number} tenantId
+   * @param {number} paymentReceiveId
+   * @param {Knex.Transaction} trx
+   */
+  public rewritePaymentGLEntries = async (
+    tenantId: number,
+    paymentReceiveId: number,
+    trx?: Knex.Transaction
+  ) => {
+    // Reverts the payment GL entries.
+    await this.revertPaymentGLEntries(tenantId, paymentReceiveId, trx);
+
+    // Writes the payment GL entries.
+    await this.writePaymentGLEntries(tenantId, paymentReceiveId, trx);
+  };
+
+  /**
+   * Retrieves the payment receive general ledger.
+   * @param   {number} tenantId -
+   * @param   {IPaymentReceive} paymentReceive -
+   * @param   {string} baseCurrencyCode -
+   * @param   {Knex.Transaction} trx -
+   * @returns {Ledger}
+   */
+  public getPaymentReceiveGLedger = async (
+    tenantId: number,
+    paymentReceive: IPaymentReceive,
+    baseCurrencyCode: string,
+    trx?: Knex.Transaction
+  ): Promise<Ledger> => {
+    const { Account } = this.tenancy.models(tenantId);
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    // Retrieve the A/R account of the given currency.
+    const receivableAccount =
+      await accountRepository.findOrCreateAccountReceivable(
+        paymentReceive.currencyCode
+      );
+    // Exchange gain/loss account.
+    const exGainLossAccount = await Account.query(trx).modify(
+      'findBySlug',
+      'exchange-grain-loss'
+    );
+    const ledgerEntries = this.getPaymentReceiveGLEntries(
+      paymentReceive,
+      receivableAccount.id,
+      exGainLossAccount.id,
+      baseCurrencyCode
+    );
+    return new Ledger(ledgerEntries);
+  };
+
+  /**
+   * Calculates the payment total exchange gain/loss.
+   * @param   {IBillPayment} paymentReceive - Payment receive with entries.
+   * @returns {number}
+   */
+  private getPaymentExGainOrLoss = (
+    paymentReceive: IPaymentReceive
+  ): number => {
+    return sumBy(paymentReceive.entries, (entry) => {
+      const paymentLocalAmount =
+        entry.paymentAmount * paymentReceive.exchangeRate;
+      const invoicePayment = entry.paymentAmount * entry.invoice.exchangeRate;
+
+      return paymentLocalAmount - invoicePayment;
+    });
+  };
+
+  /**
+   * Retrieves the common entry of payment receive.
+   * @param   {IPaymentReceive} paymentReceive
+   * @returns {}
+   */
+  private getPaymentReceiveCommonEntry = (
+    paymentReceive: IPaymentReceive
+  ): IPaymentReceiveGLCommonEntry => {
+    return {
+      debit: 0,
+      credit: 0,
+
+      currencyCode: paymentReceive.currencyCode,
+      exchangeRate: paymentReceive.exchangeRate,
+
+      transactionId: paymentReceive.id,
+      transactionType: 'PaymentReceive',
+
+      transactionNumber: paymentReceive.paymentReceiveNo,
+      referenceNumber: paymentReceive.referenceNo,
+
+      date: paymentReceive.paymentDate,
+      userId: paymentReceive.userId,
+      createdAt: paymentReceive.createdAt,
+
+      branchId: paymentReceive.branchId,
+    };
+  };
+
+  /**
+   * Retrieves the payment exchange gain/loss entry.
+   * @param   {IPaymentReceive} paymentReceive -
+   * @param   {number} ARAccountId -
+   * @param   {number} exchangeGainOrLossAccountId -
+   * @param   {string} baseCurrencyCode -
+   * @returns {ILedgerEntry[]}
+   */
+  private getPaymentExchangeGainLossEntry = (
+    paymentReceive: IPaymentReceive,
+    ARAccountId: number,
+    exchangeGainOrLossAccountId: number,
+    baseCurrencyCode: string
+  ): ILedgerEntry[] => {
+    const commonJournal = this.getPaymentReceiveCommonEntry(paymentReceive);
+    const gainOrLoss = this.getPaymentExGainOrLoss(paymentReceive);
+    const absGainOrLoss = Math.abs(gainOrLoss);
+
+    return gainOrLoss
+      ? [
+          {
+            ...commonJournal,
+            currencyCode: baseCurrencyCode,
+            exchangeRate: 1,
+            debit: gainOrLoss > 0 ? absGainOrLoss : 0,
+            credit: gainOrLoss < 0 ? absGainOrLoss : 0,
+            accountId: ARAccountId,
+            contactId: paymentReceive.customerId,
+            index: 3,
+            accountNormal: AccountNormal.CREDIT,
+          },
+          {
+            ...commonJournal,
+            currencyCode: baseCurrencyCode,
+            exchangeRate: 1,
+            credit: gainOrLoss > 0 ? absGainOrLoss : 0,
+            debit: gainOrLoss < 0 ? absGainOrLoss : 0,
+            accountId: exchangeGainOrLossAccountId,
+            index: 3,
+            accountNormal: AccountNormal.DEBIT,
+          },
+        ]
+      : [];
+  };
+
+  /**
+   * Retrieves the payment deposit GL entry.
+   * @param   {IPaymentReceive} paymentReceive
+   * @returns {ILedgerEntry}
+   */
+  private getPaymentDepositGLEntry = (
+    paymentReceive: IPaymentReceive
+  ): ILedgerEntry => {
+    const commonJournal = this.getPaymentReceiveCommonEntry(paymentReceive);
+
+    return {
+      ...commonJournal,
+      debit: paymentReceive.localAmount,
+      accountId: paymentReceive.depositAccountId,
+      index: 2,
+      accountNormal: AccountNormal.DEBIT,
+    };
+  };
+
+  /**
+   * Retrieves the payment receivable entry.
+   * @param   {IPaymentReceive} paymentReceive
+   * @param   {number} ARAccountId
+   * @returns {ILedgerEntry}
+   */
+  private getPaymentReceivableEntry = (
+    paymentReceive: IPaymentReceive,
+    ARAccountId: number
+  ): ILedgerEntry => {
+    const commonJournal = this.getPaymentReceiveCommonEntry(paymentReceive);
+
+    return {
+      ...commonJournal,
+      credit: paymentReceive.localAmount,
+      contactId: paymentReceive.customerId,
+      accountId: ARAccountId,
+      index: 1,
+      accountNormal: AccountNormal.DEBIT,
+    };
+  };
+
+  /**
+   * Records payment receive journal transactions.
+   *
+   * Invoice payment journals.
+   * --------
+   * - Account receivable -> Debit
+   * - Payment account [current asset] -> Credit
+   *
+   * @param   {number} tenantId
+   * @param   {IPaymentReceive} paymentRecieve - Payment receive model.
+   * @param   {number} ARAccountId - A/R account id.
+   * @param   {number} exGainOrLossAccountId - Exchange gain/loss account id.
+   * @param   {string} baseCurrency - Base currency code.
+   * @returns {Promise<ILedgerEntry>}
+   */
+  public getPaymentReceiveGLEntries = (
+    paymentReceive: IPaymentReceive,
+    ARAccountId: number,
+    exGainOrLossAccountId: number,
+    baseCurrency: string
+  ): ILedgerEntry[] => {
+    // Retrieve the payment deposit entry.
+    const paymentDepositEntry = this.getPaymentDepositGLEntry(paymentReceive);
+
+    // Retrieves the A/R entry.
+    const receivableEntry = this.getPaymentReceivableEntry(
+      paymentReceive,
+      ARAccountId
+    );
+    // Exchange gain/loss entries.
+    const gainLossEntries = this.getPaymentExchangeGainLossEntry(
+      paymentReceive,
+      ARAccountId,
+      exGainOrLossAccountId,
+      baseCurrency
+    );
+    return [paymentDepositEntry, receivableEntry, ...gainLossEntries];
+  };
+}
diff --git a/packages/server/src/services/Sales/PaymentReceives/PaymentReceiveSmsNotify.ts b/packages/server/src/services/Sales/PaymentReceives/PaymentReceiveSmsNotify.ts
new file mode 100644
index 000000000..fc4eba813
--- /dev/null
+++ b/packages/server/src/services/Sales/PaymentReceives/PaymentReceiveSmsNotify.ts
@@ -0,0 +1,211 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import SMSClient from '@/services/SMSClient';
+import {
+  IPaymentReceiveSmsDetails,
+  SMS_NOTIFICATION_KEY,
+  IPaymentReceive,
+  IPaymentReceiveEntry,
+} from '@/interfaces';
+import PaymentReceiveService from './PaymentsReceives';
+import SmsNotificationsSettingsService from '@/services/Settings/SmsNotificationsSettings';
+import { formatNumber, formatSmsMessage } from 'utils';
+import { TenantMetadata } from '@/system/models';
+import SaleNotifyBySms from '../SaleNotifyBySms';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+@Service()
+export default class PaymentReceiveNotifyBySms {
+  @Inject()
+  paymentReceiveService: PaymentReceiveService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  smsNotificationsSettings: SmsNotificationsSettingsService;
+
+  @Inject()
+  saleSmsNotification: SaleNotifyBySms;
+
+  /**
+   * Notify customer via sms about payment receive details.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} paymentReceiveid - Payment receive id.
+   */
+  public async notifyBySms(tenantId: number, paymentReceiveid: number) {
+    const { PaymentReceive } = this.tenancy.models(tenantId);
+
+    // Retrieve the payment receive or throw not found service error.
+    const paymentReceive = await PaymentReceive.query()
+      .findById(paymentReceiveid)
+      .withGraphFetched('customer')
+      .withGraphFetched('entries.invoice');
+
+    // Validate the customer phone number.
+    this.saleSmsNotification.validateCustomerPhoneNumber(
+      paymentReceive.customer.personalPhone
+    );
+    // Triggers `onPaymentReceiveNotifySms` event.
+    await this.eventPublisher.emitAsync(events.paymentReceive.onNotifySms, {
+      tenantId,
+      paymentReceive,
+    });
+    // Sends the payment receive sms notification to the given customer.
+    await this.sendSmsNotification(tenantId, paymentReceive);
+
+    // Triggers `onPaymentReceiveNotifiedSms` event.
+    await this.eventPublisher.emitAsync(events.paymentReceive.onNotifiedSms, {
+      tenantId,
+      paymentReceive,
+    });
+    return paymentReceive;
+  }
+
+  /**
+   * Sends the payment details sms notification of the given customer.
+   * @param {number} tenantId
+   * @param {IPaymentReceive} paymentReceive
+   * @param {ICustomer} customer
+   */
+  private sendSmsNotification = async (
+    tenantId: number,
+    paymentReceive: IPaymentReceive
+  ) => {
+    const smsClient = this.tenancy.smsClient(tenantId);
+    const tenantMetadata = await TenantMetadata.query().findOne({ tenantId });
+
+    // Retrieve the formatted payment details sms notification message.
+    const message = this.formattedPaymentDetailsMessage(
+      tenantId,
+      paymentReceive,
+      tenantMetadata
+    );
+    // The target phone number.
+    const phoneNumber = paymentReceive.customer.personalPhone;
+
+    await smsClient.sendMessageJob(phoneNumber, message);
+  };
+
+  /**
+   * Notify via SMS message after payment transaction creation.
+   * @param {number} tenantId
+   * @param {number} paymentReceiveId
+   * @returns {Promise<void>}
+   */
+  public notifyViaSmsNotificationAfterCreation = async (
+    tenantId: number,
+    paymentReceiveId: number
+  ): Promise<void> => {
+    const notification = this.smsNotificationsSettings.getSmsNotificationMeta(
+      tenantId,
+      SMS_NOTIFICATION_KEY.PAYMENT_RECEIVE_DETAILS
+    );
+    // Can't continue if the sms auto-notification is not enabled.
+    if (!notification.isNotificationEnabled) return;
+
+    await this.notifyBySms(tenantId, paymentReceiveId);
+  };
+
+  /**
+   * Formates the payment receive details sms message.
+   * @param {number} tenantId -
+   * @param {IPaymentReceive} payment -
+   * @param {ICustomer} customer -
+   */
+  private formattedPaymentDetailsMessage = (
+    tenantId: number,
+    payment: IPaymentReceive,
+    tenantMetadata: TenantMetadata
+  ) => {
+    const notification = this.smsNotificationsSettings.getSmsNotificationMeta(
+      tenantId,
+      SMS_NOTIFICATION_KEY.PAYMENT_RECEIVE_DETAILS
+    );
+    return this.formatPaymentDetailsMessage(
+      notification.smsMessage,
+      payment,
+      tenantMetadata
+    );
+  };
+
+  /**
+   * Formattes the payment details sms notification messafge.
+   * @param {string} smsMessage
+   * @param {IPaymentReceive} payment
+   * @param {ICustomer} customer
+   * @param {TenantMetadata} tenantMetadata
+   * @returns {string}
+   */
+  private formatPaymentDetailsMessage = (
+    smsMessage: string,
+    payment: IPaymentReceive,
+    tenantMetadata: any
+  ): string => {
+    const invoiceNumbers = this.stringifyPaymentInvoicesNumber(payment);
+
+    // Formattes the payment number variable.
+    const formattedPaymentNumber = formatNumber(payment.amount, {
+      currencyCode: payment.currencyCode,
+    });
+
+    return formatSmsMessage(smsMessage, {
+      Amount: formattedPaymentNumber,
+      ReferenceNumber: payment.referenceNo,
+      CustomerName: payment.customer.displayName,
+      PaymentNumber: payment.paymentReceiveNo,
+      InvoiceNumber: invoiceNumbers,
+      CompanyName: tenantMetadata.name,
+    });
+  };
+
+  /**
+   * Stringify payment receive invoices to numbers as string.
+   * @param {IPaymentReceive} payment
+   * @returns {string}
+   */
+  private stringifyPaymentInvoicesNumber(payment: IPaymentReceive) {
+    const invoicesNumberes = payment.entries.map(
+      (entry: IPaymentReceiveEntry) => entry.invoice.invoiceNo
+    );
+    return invoicesNumberes.join(', ');
+  }
+
+  /**
+   * Retrieve the SMS details of the given invoice.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} paymentReceiveid - Payment receive id.
+   */
+  public smsDetails = async (
+    tenantId: number,
+    paymentReceiveid: number
+  ): Promise<IPaymentReceiveSmsDetails> => {
+    const { PaymentReceive } = this.tenancy.models(tenantId);
+
+    // Retrieve the payment receive or throw not found service error.
+    const paymentReceive = await PaymentReceive.query()
+      .findById(paymentReceiveid)
+      .withGraphFetched('customer')
+      .withGraphFetched('entries.invoice');
+
+    // Current tenant metadata.
+    const tenantMetadata = await TenantMetadata.query().findOne({ tenantId });
+
+    // Retrieve the formatted sms message of payment receive details.
+    const smsMessage = this.formattedPaymentDetailsMessage(
+      tenantId,
+      paymentReceive,
+      tenantMetadata
+    );
+
+    return {
+      customerName: paymentReceive.customer.displayName,
+      customerPhoneNumber: paymentReceive.customer.personalPhone,
+      smsMessage,
+    };
+  };
+}
diff --git a/packages/server/src/services/Sales/PaymentReceives/PaymentReceiveSmsSubscriber.ts b/packages/server/src/services/Sales/PaymentReceives/PaymentReceiveSmsSubscriber.ts
new file mode 100644
index 000000000..3793ca5ed
--- /dev/null
+++ b/packages/server/src/services/Sales/PaymentReceives/PaymentReceiveSmsSubscriber.ts
@@ -0,0 +1,28 @@
+import { Container } from 'typedi';
+import { On, EventSubscriber } from 'event-dispatch';
+import events from '@/subscribers/events';
+import SaleReceiptNotifyBySms from '@/services/Sales/SaleReceiptNotifyBySms';
+import PaymentReceiveNotifyBySms from './PaymentReceiveSmsNotify';
+
+@EventSubscriber()
+export default class SendSmsNotificationPaymentReceive {
+  paymentReceiveNotifyBySms: PaymentReceiveNotifyBySms;
+
+  constructor() {
+    this.paymentReceiveNotifyBySms = Container.get(PaymentReceiveNotifyBySms);
+  }
+
+  /**
+   *
+   */
+  @On(events.paymentReceive.onNotifySms)
+  async sendSmsNotificationOnceInvoiceNotify({
+    paymentReceive,
+    customer,
+  }) {
+    await this.paymentReceiveNotifyBySms.sendSmsNotification(
+      paymentReceive,
+      customer
+    );
+  }
+}
diff --git a/packages/server/src/services/Sales/PaymentReceives/PaymentReceiveTransformer.ts b/packages/server/src/services/Sales/PaymentReceives/PaymentReceiveTransformer.ts
new file mode 100644
index 000000000..f12ca5bcc
--- /dev/null
+++ b/packages/server/src/services/Sales/PaymentReceives/PaymentReceiveTransformer.ts
@@ -0,0 +1,58 @@
+import { IPaymentReceive, IPaymentReceiveEntry } from '@/interfaces';
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+import { SaleInvoiceTransformer } from '../SaleInvoiceTransformer';
+
+export class PaymentReceiveTransfromer extends Transformer {
+  /**
+   * Include these attributes to payment receive object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedPaymentDate',
+      'formattedAmount',
+      'formattedExchangeRate',
+      'entries',
+    ];
+  };
+
+  /**
+   * Retrieve formatted payment receive date.
+   * @param {ISaleInvoice} invoice
+   * @returns {String}
+   */
+  protected formattedPaymentDate = (payment: IPaymentReceive): string => {
+    return this.formatDate(payment.paymentDate);
+  };
+
+  /**
+   * Retrieve formatted payment amount.
+   * @param {ISaleInvoice} invoice
+   * @returns {string}
+   */
+  protected formattedAmount = (payment: IPaymentReceive): string => {
+    return formatNumber(payment.amount, { currencyCode: payment.currencyCode });
+  };
+
+  /**
+   * Retrieve the formatted exchange rate.
+   * @param   {IPaymentReceive} payment
+   * @returns {string}
+   */
+  protected formattedExchangeRate = (payment: IPaymentReceive): string => {
+    return formatNumber(payment.exchangeRate, { money: false });
+  };
+
+  /**
+   * Retrieves the 
+   * @param {IPaymentReceive} payment 
+   * @returns {IPaymentReceiveEntry[]}
+   */
+  protected entries = (payment: IPaymentReceive): IPaymentReceiveEntry[] => {
+    return payment?.entries?.map((entry) => ({
+      ...entry,
+      invoice: this.item(entry.invoice, new SaleInvoiceTransformer()),
+    }));
+  };
+}
diff --git a/packages/server/src/services/Sales/PaymentReceives/PaymentReceivesPages.ts b/packages/server/src/services/Sales/PaymentReceives/PaymentReceivesPages.ts
new file mode 100644
index 000000000..b08f2ac71
--- /dev/null
+++ b/packages/server/src/services/Sales/PaymentReceives/PaymentReceivesPages.ts
@@ -0,0 +1,112 @@
+import { Inject, Service } from 'typedi';
+import { omit } from 'lodash';
+import {
+  ISaleInvoice,
+  IPaymentReceivePageEntry,
+  IPaymentReceive,
+  ISystemUser,
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+
+/**
+ * Payment receives edit/new pages service.
+ */
+@Service()
+export default class PaymentReceivesPages {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  /**
+   * Retrive page invoices entries from the given sale invoices models.
+   * @param  {ISaleInvoice[]} invoices - Invoices.
+   * @return {IPaymentReceivePageEntry}
+   */
+  private invoiceToPageEntry(invoice: ISaleInvoice): IPaymentReceivePageEntry {
+    return {
+      entryType: 'invoice',
+      invoiceId: invoice.id,
+      invoiceNo: invoice.invoiceNo,
+      amount: invoice.balance,
+      dueAmount: invoice.dueAmount,
+      paymentAmount: invoice.paymentAmount,
+      totalPaymentAmount: invoice.paymentAmount,
+      currencyCode: invoice.currencyCode,
+      date: invoice.invoiceDate,
+    };
+  }
+
+  /**
+   * Retrieve payment receive new page receivable entries.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} vendorId - Vendor id.
+   * @return {IPaymentReceivePageEntry[]}
+   */
+  public async getNewPageEntries(tenantId: number, customerId: number) {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    // Retrieve due invoices.
+    const entries = await SaleInvoice.query()
+      .modify('delivered')
+      .modify('dueInvoices')
+      .where('customer_id', customerId)
+      .orderBy('invoice_date', 'ASC');
+
+    return entries.map(this.invoiceToPageEntry);
+  }
+
+  /**
+   * Retrieve the payment receive details of the given id.
+   * @param {number} tenantId - Tenant id.
+   * @param {Integer} paymentReceiveId - Payment receive id.
+   */
+  public async getPaymentReceiveEditPage(
+    tenantId: number,
+    paymentReceiveId: number,
+  ): Promise<{
+    paymentReceive: Omit<IPaymentReceive, 'entries'>;
+    entries: IPaymentReceivePageEntry[];
+  }> {
+    const { PaymentReceive, SaleInvoice } = this.tenancy.models(tenantId);
+
+    // Retrieve payment receive.
+    const paymentReceive = await PaymentReceive.query()
+      .findById(paymentReceiveId)
+      .withGraphFetched('entries.invoice');
+
+    // Throw not found the payment receive.
+    if (!paymentReceive) {
+      throw new ServiceError(ERRORS.PAYMENT_RECEIVE_NOT_EXISTS);
+    }
+    const paymentEntries = paymentReceive.entries.map((entry) => ({
+      ...this.invoiceToPageEntry(entry.invoice),
+      dueAmount: entry.invoice.dueAmount + entry.paymentAmount,
+      paymentAmount: entry.paymentAmount,
+      index: entry.index,
+    }));
+    // Retrieves all receivable bills that associated to the payment receive transaction.
+    const restReceivableInvoices = await SaleInvoice.query()
+      .modify('delivered')
+      .modify('dueInvoices')
+      .where('customer_id', paymentReceive.customerId)
+      .whereNotIn(
+        'id',
+        paymentReceive.entries.map((entry) => entry.invoiceId)
+      )
+      .orderBy('invoice_date', 'ASC');
+
+    const restReceivableEntries = restReceivableInvoices.map(
+      this.invoiceToPageEntry
+    );
+    const entries = [...paymentEntries, ...restReceivableEntries];
+
+    return {
+      paymentReceive: omit(paymentReceive, ['entries']),
+      entries,
+    };
+  }
+}
diff --git a/packages/server/src/services/Sales/PaymentReceives/PaymentsReceives.ts b/packages/server/src/services/Sales/PaymentReceives/PaymentsReceives.ts
new file mode 100644
index 000000000..ff6eb7f23
--- /dev/null
+++ b/packages/server/src/services/Sales/PaymentReceives/PaymentsReceives.ts
@@ -0,0 +1,847 @@
+import { omit, sumBy, difference } from 'lodash';
+import { Service, Inject } from 'typedi';
+import * as R from 'ramda';
+import { Knex } from 'knex';
+import events from '@/subscribers/events';
+import {
+  IAccount,
+  IFilterMeta,
+  IPaginationMeta,
+  IPaymentReceive,
+  IPaymentReceiveCreateDTO,
+  IPaymentReceiveEditDTO,
+  IPaymentReceiveEntry,
+  IPaymentReceiveEntryDTO,
+  IPaymentReceivesFilter,
+  IPaymentsReceiveService,
+  IPaymentReceiveCreatedPayload,
+  ISaleInvoice,
+  ISystemUser,
+  IPaymentReceiveEditedPayload,
+  IPaymentReceiveDeletedPayload,
+  IPaymentReceiveCreatingPayload,
+  IPaymentReceiveDeletingPayload,
+  IPaymentReceiveEditingPayload,
+  ICustomer,
+} from '@/interfaces';
+import JournalPosterService from '@/services/Sales/JournalPosterService';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { formatDateFields, entriesAmountDiff } from 'utils';
+import { ServiceError } from '@/exceptions';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+import { ACCOUNT_TYPE } from '@/data/AccountTypes';
+import AutoIncrementOrdersService from '../AutoIncrementOrdersService';
+import { ERRORS } from './constants';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import { PaymentReceiveTransfromer } from './PaymentReceiveTransformer';
+import UnitOfWork from '@/services/UnitOfWork';
+import { BranchTransactionDTOTransform } from '@/services/Branches/Integrations/BranchTransactionDTOTransform';
+import { TenantMetadata } from '@/system/models';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+/**
+ * Payment receive service.
+ * @service
+ */
+@Service('PaymentReceives')
+export default class PaymentReceiveService implements IPaymentsReceiveService {
+  @Inject()
+  itemsEntries: ItemsEntriesService;
+
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  journalService: JournalPosterService;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  @Inject()
+  autoIncrementOrdersService: AutoIncrementOrdersService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  branchDTOTransform: BranchTransactionDTOTransform;
+
+  @Inject()
+  transformer: TransformerInjectable;
+
+  /**
+   * Validates the payment receive number existance.
+   * @param {number} tenantId -
+   * @param {string} paymentReceiveNo -
+   */
+  async validatePaymentReceiveNoExistance(
+    tenantId: number,
+    paymentReceiveNo: string,
+    notPaymentReceiveId?: number
+  ): Promise<void> {
+    const { PaymentReceive } = this.tenancy.models(tenantId);
+    const paymentReceive = await PaymentReceive.query()
+      .findOne('payment_receive_no', paymentReceiveNo)
+      .onBuild((builder) => {
+        if (notPaymentReceiveId) {
+          builder.whereNot('id', notPaymentReceiveId);
+        }
+      });
+
+    if (paymentReceive) {
+      throw new ServiceError(ERRORS.PAYMENT_RECEIVE_NO_EXISTS);
+    }
+  }
+
+  /**
+   * Validates the payment receive existance.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} paymentReceiveId - Payment receive id.
+   */
+  async getPaymentReceiveOrThrowError(
+    tenantId: number,
+    paymentReceiveId: number
+  ): Promise<IPaymentReceive> {
+    const { PaymentReceive } = this.tenancy.models(tenantId);
+    const paymentReceive = await PaymentReceive.query()
+      .withGraphFetched('entries')
+      .findById(paymentReceiveId);
+
+    if (!paymentReceive) {
+      throw new ServiceError(ERRORS.PAYMENT_RECEIVE_NOT_EXISTS);
+    }
+    return paymentReceive;
+  }
+
+  /**
+   * Validate the deposit account id existance.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} depositAccountId - Deposit account id.
+   * @return {Promise<IAccount>}
+   */
+  async getDepositAccountOrThrowError(
+    tenantId: number,
+    depositAccountId: number
+  ): Promise<IAccount> {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    const depositAccount = await accountRepository.findOneById(
+      depositAccountId
+    );
+    if (!depositAccount) {
+      throw new ServiceError(ERRORS.DEPOSIT_ACCOUNT_NOT_FOUND);
+    }
+    // Detarmines whether the account is cash, bank or other current asset.
+    if (
+      !depositAccount.isAccountType([
+        ACCOUNT_TYPE.CASH,
+        ACCOUNT_TYPE.BANK,
+        ACCOUNT_TYPE.OTHER_CURRENT_ASSET,
+      ])
+    ) {
+      throw new ServiceError(ERRORS.DEPOSIT_ACCOUNT_INVALID_TYPE);
+    }
+    return depositAccount;
+  }
+
+  /**
+   * Validates the invoices IDs existance.
+   * @param {number} tenantId -
+   * @param {number} customerId -
+   * @param {IPaymentReceiveEntryDTO[]} paymentReceiveEntries -
+   */
+  async validateInvoicesIDsExistance(
+    tenantId: number,
+    customerId: number,
+    paymentReceiveEntries: { invoiceId: number }[]
+  ): Promise<ISaleInvoice[]> {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    const invoicesIds = paymentReceiveEntries.map(
+      (e: { invoiceId: number }) => e.invoiceId
+    );
+    const storedInvoices = await SaleInvoice.query()
+      .whereIn('id', invoicesIds)
+      .where('customer_id', customerId);
+
+    const storedInvoicesIds = storedInvoices.map((invoice) => invoice.id);
+    const notFoundInvoicesIDs = difference(invoicesIds, storedInvoicesIds);
+
+    if (notFoundInvoicesIDs.length > 0) {
+      throw new ServiceError(ERRORS.INVOICES_IDS_NOT_FOUND);
+    }
+    // Filters the not delivered invoices.
+    const notDeliveredInvoices = storedInvoices.filter(
+      (invoice) => !invoice.isDelivered
+    );
+    if (notDeliveredInvoices.length > 0) {
+      throw new ServiceError(ERRORS.INVOICES_NOT_DELIVERED_YET, null, {
+        notDeliveredInvoices,
+      });
+    }
+    return storedInvoices;
+  }
+
+  /**
+   * Validates entries invoice payment amount.
+   * @param {Request} req -
+   * @param {Response} res -
+   * @param {Function} next -
+   */
+  async validateInvoicesPaymentsAmount(
+    tenantId: number,
+    paymentReceiveEntries: IPaymentReceiveEntryDTO[],
+    oldPaymentEntries: IPaymentReceiveEntry[] = []
+  ) {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+    const invoicesIds = paymentReceiveEntries.map(
+      (e: IPaymentReceiveEntryDTO) => e.invoiceId
+    );
+
+    const storedInvoices = await SaleInvoice.query().whereIn('id', invoicesIds);
+
+    const storedInvoicesMap = new Map(
+      storedInvoices.map((invoice: ISaleInvoice) => {
+        const oldEntries = oldPaymentEntries.filter((entry) => entry.invoiceId);
+        const oldPaymentAmount = sumBy(oldEntries, 'paymentAmount') || 0;
+
+        return [
+          invoice.id,
+          { ...invoice, dueAmount: invoice.dueAmount + oldPaymentAmount },
+        ];
+      })
+    );
+    const hasWrongPaymentAmount: any[] = [];
+
+    paymentReceiveEntries.forEach(
+      (entry: IPaymentReceiveEntryDTO, index: number) => {
+        const entryInvoice = storedInvoicesMap.get(entry.invoiceId);
+        const { dueAmount } = entryInvoice;
+
+        if (dueAmount < entry.paymentAmount) {
+          hasWrongPaymentAmount.push({ index, due_amount: dueAmount });
+        }
+      }
+    );
+    if (hasWrongPaymentAmount.length > 0) {
+      throw new ServiceError(ERRORS.INVALID_PAYMENT_AMOUNT);
+    }
+  }
+
+  /**
+   * Retrieve the next unique payment receive number.
+   * @param  {number} tenantId - Tenant id.
+   * @return {string}
+   */
+  getNextPaymentReceiveNumber(tenantId: number): string {
+    return this.autoIncrementOrdersService.getNextTransactionNumber(
+      tenantId,
+      'payment_receives'
+    );
+  }
+
+  /**
+   * Increment the payment receive next number.
+   * @param {number} tenantId
+   */
+  incrementNextPaymentReceiveNumber(tenantId: number) {
+    return this.autoIncrementOrdersService.incrementSettingsNextNumber(
+      tenantId,
+      'payment_receives'
+    );
+  }
+
+  /**
+   * Validate the payment receive number require.
+   * @param {IPaymentReceive} paymentReceiveObj
+   */
+  validatePaymentReceiveNoRequire(paymentReceiveObj: IPaymentReceive) {
+    if (!paymentReceiveObj.paymentReceiveNo) {
+      throw new ServiceError(ERRORS.PAYMENT_RECEIVE_NO_IS_REQUIRED);
+    }
+  }
+
+  /**
+   * Validate the payment receive entries IDs existance.
+   * @param {number} tenantId
+   * @param {number} paymentReceiveId
+   * @param {IPaymentReceiveEntryDTO[]} paymentReceiveEntries
+   */
+  private async validateEntriesIdsExistance(
+    tenantId: number,
+    paymentReceiveId: number,
+    paymentReceiveEntries: IPaymentReceiveEntryDTO[]
+  ) {
+    const { PaymentReceiveEntry } = this.tenancy.models(tenantId);
+
+    const entriesIds = paymentReceiveEntries
+      .filter((entry) => entry.id)
+      .map((entry) => entry.id);
+
+    const storedEntries = await PaymentReceiveEntry.query().where(
+      'payment_receive_id',
+      paymentReceiveId
+    );
+    const storedEntriesIds = storedEntries.map((entry: any) => entry.id);
+    const notFoundEntriesIds = difference(entriesIds, storedEntriesIds);
+
+    if (notFoundEntriesIds.length > 0) {
+      throw new ServiceError(ERRORS.ENTRIES_IDS_NOT_EXISTS);
+    }
+  }
+
+  /**
+   * Validates the payment receive number require.
+   * @param {string} paymentReceiveNo
+   */
+  validatePaymentNoRequire(paymentReceiveNo: string) {
+    if (!paymentReceiveNo) {
+      throw new ServiceError(ERRORS.PAYMENT_RECEIVE_NO_REQUIRED);
+    }
+  }
+
+  /**
+   * Validate the payment customer whether modified.
+   * @param {IPaymentReceiveEditDTO} paymentReceiveDTO
+   * @param {IPaymentReceive} oldPaymentReceive
+   */
+  validateCustomerNotModified(
+    paymentReceiveDTO: IPaymentReceiveEditDTO,
+    oldPaymentReceive: IPaymentReceive
+  ) {
+    if (paymentReceiveDTO.customerId !== oldPaymentReceive.customerId) {
+      throw new ServiceError(ERRORS.PAYMENT_CUSTOMER_SHOULD_NOT_UPDATE);
+    }
+  }
+
+  /**
+   * Validates the payment account currency code. The deposit account curreny
+   * should be equals the customer currency code or the base currency.
+   * @param  {string} paymentAccountCurrency
+   * @param  {string} customerCurrency
+   * @param  {string} baseCurrency
+   * @throws {ServiceError(ERRORS.PAYMENT_ACCOUNT_CURRENCY_INVALID)}
+   */
+  public validatePaymentAccountCurrency = (
+    paymentAccountCurrency: string,
+    customerCurrency: string,
+    baseCurrency: string
+  ) => {
+    if (
+      paymentAccountCurrency !== customerCurrency &&
+      paymentAccountCurrency !== baseCurrency
+    ) {
+      throw new ServiceError(ERRORS.PAYMENT_ACCOUNT_CURRENCY_INVALID);
+    }
+  };
+
+  /**
+   * Transformes the create payment receive DTO to model object.
+   * @param {number} tenantId
+   * @param {IPaymentReceiveCreateDTO|IPaymentReceiveEditDTO} paymentReceiveDTO - Payment receive DTO.
+   * @param {IPaymentReceive} oldPaymentReceive -
+   * @return {IPaymentReceive}
+   */
+  async transformPaymentReceiveDTOToModel(
+    tenantId: number,
+    customer: ICustomer,
+    paymentReceiveDTO: IPaymentReceiveCreateDTO | IPaymentReceiveEditDTO,
+    oldPaymentReceive?: IPaymentReceive
+  ): Promise<IPaymentReceive> {
+    const paymentAmount = sumBy(paymentReceiveDTO.entries, 'paymentAmount');
+
+    // Retreive the next invoice number.
+    const autoNextNumber = this.getNextPaymentReceiveNumber(tenantId);
+
+    // Retrieve the next payment receive number.
+    const paymentReceiveNo =
+      paymentReceiveDTO.paymentReceiveNo ||
+      oldPaymentReceive?.paymentReceiveNo ||
+      autoNextNumber;
+
+    this.validatePaymentNoRequire(paymentReceiveNo);
+
+    const initialDTO = {
+      ...formatDateFields(omit(paymentReceiveDTO, ['entries']), [
+        'paymentDate',
+      ]),
+      amount: paymentAmount,
+      currencyCode: customer.currencyCode,
+      ...(paymentReceiveNo ? { paymentReceiveNo } : {}),
+      exchangeRate: paymentReceiveDTO.exchangeRate || 1,
+      entries: paymentReceiveDTO.entries.map((entry) => ({
+        ...entry,
+      })),
+    };
+    return R.compose(
+      this.branchDTOTransform.transformDTO<IPaymentReceive>(tenantId)
+    )(initialDTO);
+  }
+
+  /**
+   * Transform the create payment receive DTO.
+   * @param {number} tenantId
+   * @param {ICustomer} customer
+   * @param {IPaymentReceiveCreateDTO} paymentReceiveDTO
+   * @returns
+   */
+  private transformCreateDTOToModel = async (
+    tenantId: number,
+    customer: ICustomer,
+    paymentReceiveDTO: IPaymentReceiveCreateDTO
+  ) => {
+    return this.transformPaymentReceiveDTOToModel(
+      tenantId,
+      customer,
+      paymentReceiveDTO
+    );
+  };
+
+  /**
+   * Transform the edit payment receive DTO.
+   * @param {number} tenantId
+   * @param {ICustomer} customer
+   * @param {IPaymentReceiveEditDTO} paymentReceiveDTO
+   * @param {IPaymentReceive} oldPaymentReceive
+   * @returns
+   */
+  private transformEditDTOToModel = async (
+    tenantId: number,
+    customer: ICustomer,
+    paymentReceiveDTO: IPaymentReceiveEditDTO,
+    oldPaymentReceive: IPaymentReceive
+  ) => {
+    return this.transformPaymentReceiveDTOToModel(
+      tenantId,
+      customer,
+      paymentReceiveDTO,
+      oldPaymentReceive
+    );
+  };
+  /**
+   * Creates a new payment receive and store it to the storage
+   * with associated invoices payment and journal transactions.
+   * @async
+   * @param {number} tenantId - Tenant id.
+   * @param {IPaymentReceive} paymentReceive
+   */
+  public async createPaymentReceive(
+    tenantId: number,
+    paymentReceiveDTO: IPaymentReceiveCreateDTO,
+    authorizedUser: ISystemUser
+  ) {
+    const { PaymentReceive, Contact } = this.tenancy.models(tenantId);
+
+    const tenantMeta = await TenantMetadata.query().findOne({ tenantId });
+
+    // Validate customer existance.
+    const paymentCustomer = await Contact.query()
+      .modify('customer')
+      .findById(paymentReceiveDTO.customerId)
+      .throwIfNotFound();
+
+    // Transformes the payment receive DTO to model.
+    const paymentReceiveObj = await this.transformCreateDTOToModel(
+      tenantId,
+      paymentCustomer,
+      paymentReceiveDTO
+    );
+    // Validate payment receive number uniquiness.
+    await this.validatePaymentReceiveNoExistance(
+      tenantId,
+      paymentReceiveObj.paymentReceiveNo
+    );
+    // Validate the deposit account existance and type.
+    const depositAccount = await this.getDepositAccountOrThrowError(
+      tenantId,
+      paymentReceiveDTO.depositAccountId
+    );
+    // Validate payment receive invoices IDs existance.
+    await this.validateInvoicesIDsExistance(
+      tenantId,
+      paymentReceiveDTO.customerId,
+      paymentReceiveDTO.entries
+    );
+    // Validate invoice payment amount.
+    await this.validateInvoicesPaymentsAmount(
+      tenantId,
+      paymentReceiveDTO.entries
+    );
+    // Validates the payment account currency code.
+    this.validatePaymentAccountCurrency(
+      depositAccount.currencyCode,
+      paymentCustomer.currencyCode,
+      tenantMeta.baseCurrency
+    );
+    // Creates a payment receive transaction under UOW envirment.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onPaymentReceiveCreating` event.
+      await this.eventPublisher.emitAsync(events.paymentReceive.onCreating, {
+        trx,
+        paymentReceiveDTO,
+        tenantId,
+      } as IPaymentReceiveCreatingPayload);
+
+      // Inserts the payment receive transaction.
+      const paymentReceive = await PaymentReceive.query(
+        trx
+      ).insertGraphAndFetch({
+        ...paymentReceiveObj,
+      });
+      // Triggers `onPaymentReceiveCreated` event.
+      await this.eventPublisher.emitAsync(events.paymentReceive.onCreated, {
+        tenantId,
+        paymentReceive,
+        paymentReceiveId: paymentReceive.id,
+        authorizedUser,
+        trx,
+      } as IPaymentReceiveCreatedPayload);
+
+      return paymentReceive;
+    });
+  }
+
+  /**
+   * Edit details the given payment receive with associated entries.
+   * ------
+   * - Update the payment receive transactions.
+   * - Insert the new payment receive entries.
+   * - Update the given payment receive entries.
+   * - Delete the not presented payment receive entries.
+   * - Re-insert the journal transactions and update the different accounts balance.
+   * - Update the different customer balances.
+   * - Update the different invoice payment amount.
+   * @async
+   * @param {number} tenantId -
+   * @param {Integer} paymentReceiveId -
+   * @param {IPaymentReceive} paymentReceive -
+   */
+  public async editPaymentReceive(
+    tenantId: number,
+    paymentReceiveId: number,
+    paymentReceiveDTO: IPaymentReceiveEditDTO,
+    authorizedUser: ISystemUser
+  ) {
+    const { PaymentReceive, Contact } = this.tenancy.models(tenantId);
+
+    const tenantMeta = await TenantMetadata.query().findOne({ tenantId });
+
+    // Validate the payment receive existance.
+    const oldPaymentReceive = await this.getPaymentReceiveOrThrowError(
+      tenantId,
+      paymentReceiveId
+    );
+    // Validate customer existance.
+    const customer = await Contact.query()
+      .modify('customer')
+      .findById(paymentReceiveDTO.customerId)
+      .throwIfNotFound();
+
+    // Transformes the payment receive DTO to model.
+    const paymentReceiveObj = await this.transformEditDTOToModel(
+      tenantId,
+      customer,
+      paymentReceiveDTO,
+      oldPaymentReceive
+    );
+    // Validate customer whether modified.
+    this.validateCustomerNotModified(paymentReceiveDTO, oldPaymentReceive);
+
+    // Validate payment receive number uniquiness.
+    if (paymentReceiveDTO.paymentReceiveNo) {
+      await this.validatePaymentReceiveNoExistance(
+        tenantId,
+        paymentReceiveDTO.paymentReceiveNo,
+        paymentReceiveId
+      );
+    }
+    // Validate the deposit account existance and type.
+    const depositAccount = await this.getDepositAccountOrThrowError(
+      tenantId,
+      paymentReceiveDTO.depositAccountId
+    );
+    // Validate the entries ids existance on payment receive type.
+    await this.validateEntriesIdsExistance(
+      tenantId,
+      paymentReceiveId,
+      paymentReceiveDTO.entries
+    );
+    // Validate payment receive invoices IDs existance and associated
+    // to the given customer id.
+    await this.validateInvoicesIDsExistance(
+      tenantId,
+      oldPaymentReceive.customerId,
+      paymentReceiveDTO.entries
+    );
+    // Validate invoice payment amount.
+    await this.validateInvoicesPaymentsAmount(
+      tenantId,
+      paymentReceiveDTO.entries,
+      oldPaymentReceive.entries
+    );
+    // Validates the payment account currency code.
+    this.validatePaymentAccountCurrency(
+      depositAccount.currencyCode,
+      customer.currencyCode,
+      tenantMeta.baseCurrency
+    );
+    // Creates payment receive transaction under UOW envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onPaymentReceiveEditing` event.
+      await this.eventPublisher.emitAsync(events.paymentReceive.onEditing, {
+        trx,
+        tenantId,
+        oldPaymentReceive,
+        paymentReceiveDTO,
+      } as IPaymentReceiveEditingPayload);
+
+      // Update the payment receive transaction.
+      const paymentReceive = await PaymentReceive.query(
+        trx
+      ).upsertGraphAndFetch({
+        id: paymentReceiveId,
+        ...paymentReceiveObj,
+      });
+      // Triggers `onPaymentReceiveEdited` event.
+      await this.eventPublisher.emitAsync(events.paymentReceive.onEdited, {
+        tenantId,
+        paymentReceiveId,
+        paymentReceive,
+        oldPaymentReceive,
+        authorizedUser,
+        trx,
+      } as IPaymentReceiveEditedPayload);
+
+      return paymentReceive;
+    });
+  }
+
+  /**
+   * Deletes the given payment receive with associated entries
+   * and journal transactions.
+   * -----
+   * - Deletes the payment receive transaction.
+   * - Deletes the payment receive associated entries.
+   * - Deletes the payment receive associated journal transactions.
+   * - Revert the customer balance.
+   * - Revert the payment amount of the associated invoices.
+   * @async
+   * @param {number} tenantId - Tenant id.
+   * @param {Integer} paymentReceiveId - Payment receive id.
+   * @param {IPaymentReceive} paymentReceive - Payment receive object.
+   */
+  public async deletePaymentReceive(
+    tenantId: number,
+    paymentReceiveId: number,
+    authorizedUser: ISystemUser
+  ) {
+    const { PaymentReceive, PaymentReceiveEntry } =
+      this.tenancy.models(tenantId);
+
+    // Retreive payment receive or throw not found service error.
+    const oldPaymentReceive = await this.getPaymentReceiveOrThrowError(
+      tenantId,
+      paymentReceiveId
+    );
+    // Delete payment receive transaction and associate transactions under UOW env.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onPaymentReceiveDeleting` event.
+      await this.eventPublisher.emitAsync(events.paymentReceive.onDeleting, {
+        tenantId,
+        oldPaymentReceive,
+        trx,
+      } as IPaymentReceiveDeletingPayload);
+
+      // Deletes the payment receive associated entries.
+      await PaymentReceiveEntry.query(trx)
+        .where('payment_receive_id', paymentReceiveId)
+        .delete();
+
+      // Deletes the payment receive transaction.
+      await PaymentReceive.query(trx).findById(paymentReceiveId).delete();
+
+      // Triggers `onPaymentReceiveDeleted` event.
+      await this.eventPublisher.emitAsync(events.paymentReceive.onDeleted, {
+        tenantId,
+        paymentReceiveId,
+        oldPaymentReceive,
+        authorizedUser,
+        trx,
+      } as IPaymentReceiveDeletedPayload);
+    });
+  }
+
+  /**
+   * Retrieve payment receive details.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} paymentReceiveId - Payment receive id.
+   * @return {Promise<IPaymentReceive>}
+   */
+  public async getPaymentReceive(
+    tenantId: number,
+    paymentReceiveId: number
+  ): Promise<IPaymentReceive> {
+    const { PaymentReceive } = this.tenancy.models(tenantId);
+
+    const paymentReceive = await PaymentReceive.query()
+      .withGraphFetched('customer')
+      .withGraphFetched('depositAccount')
+      .withGraphFetched('entries.invoice')
+      .withGraphFetched('transactions')
+      .withGraphFetched('branch')
+      .findById(paymentReceiveId);
+
+    if (!paymentReceive) {
+      throw new ServiceError(ERRORS.PAYMENT_RECEIVE_NOT_EXISTS);
+    }
+    return this.transformer.transform(
+      tenantId,
+      paymentReceive,
+      new PaymentReceiveTransfromer()
+    );
+  }
+
+  /**
+   * Retrieve sale invoices that assocaited to the given payment receive.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} paymentReceiveId - Payment receive id.
+   * @return {Promise<ISaleInvoice>}
+   */
+  public async getPaymentReceiveInvoices(
+    tenantId: number,
+    paymentReceiveId: number
+  ) {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    const paymentReceive = await this.getPaymentReceiveOrThrowError(
+      tenantId,
+      paymentReceiveId
+    );
+    const paymentReceiveInvoicesIds = paymentReceive.entries.map(
+      (entry) => entry.invoiceId
+    );
+    const saleInvoices = await SaleInvoice.query().whereIn(
+      'id',
+      paymentReceiveInvoicesIds
+    );
+
+    return saleInvoices;
+  }
+
+  /**
+   * Parses payments receive list filter DTO.
+   * @param filterDTO
+   */
+  private parseListFilterDTO(filterDTO) {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  }
+
+  /**
+   * Retrieve payment receives paginated and filterable list.
+   * @param {number} tenantId
+   * @param {IPaymentReceivesFilter} paymentReceivesFilter
+   */
+  public async listPaymentReceives(
+    tenantId: number,
+    filterDTO: IPaymentReceivesFilter
+  ): Promise<{
+    paymentReceives: IPaymentReceive[];
+    pagination: IPaginationMeta;
+    filterMeta: IFilterMeta;
+  }> {
+    const { PaymentReceive } = this.tenancy.models(tenantId);
+
+    // Parses filter DTO.
+    const filter = this.parseListFilterDTO(filterDTO);
+
+    // Dynamic list service.
+    const dynamicList = await this.dynamicListService.dynamicList(
+      tenantId,
+      PaymentReceive,
+      filter
+    );
+    const { results, pagination } = await PaymentReceive.query()
+      .onBuild((builder) => {
+        builder.withGraphFetched('customer');
+        builder.withGraphFetched('depositAccount');
+        dynamicList.buildQuery()(builder);
+      })
+      .pagination(filter.page - 1, filter.pageSize);
+
+    // Transformer the payment receives models to POJO.
+    const transformedPayments = await this.transformer.transform(
+      tenantId,
+      results,
+      new PaymentReceiveTransfromer()
+    );
+    return {
+      paymentReceives: transformedPayments,
+      pagination,
+      filterMeta: dynamicList.getResponseMeta(),
+    };
+  }
+
+  /**
+   * Saves difference changing between old and new invoice payment amount.
+   * @async
+   * @param {number} tenantId - Tenant id.
+   * @param {Array} paymentReceiveEntries
+   * @param {Array} newPaymentReceiveEntries
+   * @return {Promise<void>}
+   */
+  public async saveChangeInvoicePaymentAmount(
+    tenantId: number,
+    newPaymentReceiveEntries: IPaymentReceiveEntryDTO[],
+    oldPaymentReceiveEntries?: IPaymentReceiveEntryDTO[],
+    trx?: Knex.Transaction
+  ): Promise<void> {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+    const opers: Promise<void>[] = [];
+
+    const diffEntries = entriesAmountDiff(
+      newPaymentReceiveEntries,
+      oldPaymentReceiveEntries,
+      'paymentAmount',
+      'invoiceId'
+    );
+    diffEntries.forEach((diffEntry: any) => {
+      if (diffEntry.paymentAmount === 0) {
+        return;
+      }
+      const oper = SaleInvoice.changePaymentAmount(
+        diffEntry.invoiceId,
+        diffEntry.paymentAmount,
+        trx
+      );
+      opers.push(oper);
+    });
+    await Promise.all([...opers]);
+  }
+
+  /**
+   * Validate the given customer has no payments receives.
+   * @param {number} tenantId
+   * @param {number} customerId - Customer id.
+   */
+  public async validateCustomerHasNoPayments(
+    tenantId: number,
+    customerId: number
+  ) {
+    const { PaymentReceive } = this.tenancy.models(tenantId);
+
+    const paymentReceives = await PaymentReceive.query().where(
+      'customer_id',
+      customerId
+    );
+    if (paymentReceives.length > 0) {
+      throw new ServiceError(ERRORS.CUSTOMER_HAS_PAYMENT_RECEIVES);
+    }
+  }
+}
diff --git a/packages/server/src/services/Sales/PaymentReceives/constants.ts b/packages/server/src/services/Sales/PaymentReceives/constants.ts
new file mode 100644
index 000000000..baa4b2f48
--- /dev/null
+++ b/packages/server/src/services/Sales/PaymentReceives/constants.ts
@@ -0,0 +1,18 @@
+export const ERRORS = {
+  PAYMENT_RECEIVE_NO_EXISTS: 'PAYMENT_RECEIVE_NO_EXISTS',
+  PAYMENT_RECEIVE_NOT_EXISTS: 'PAYMENT_RECEIVE_NOT_EXISTS',
+  DEPOSIT_ACCOUNT_NOT_FOUND: 'DEPOSIT_ACCOUNT_NOT_FOUND',
+  DEPOSIT_ACCOUNT_INVALID_TYPE: 'DEPOSIT_ACCOUNT_INVALID_TYPE',
+  INVALID_PAYMENT_AMOUNT: 'INVALID_PAYMENT_AMOUNT',
+  INVOICES_IDS_NOT_FOUND: 'INVOICES_IDS_NOT_FOUND',
+  ENTRIES_IDS_NOT_EXISTS: 'ENTRIES_IDS_NOT_EXISTS',
+  INVOICES_NOT_DELIVERED_YET: 'INVOICES_NOT_DELIVERED_YET',
+  PAYMENT_RECEIVE_NO_IS_REQUIRED: 'PAYMENT_RECEIVE_NO_IS_REQUIRED',
+  PAYMENT_RECEIVE_NO_REQUIRED: 'PAYMENT_RECEIVE_NO_REQUIRED',
+  PAYMENT_CUSTOMER_SHOULD_NOT_UPDATE: 'PAYMENT_CUSTOMER_SHOULD_NOT_UPDATE',
+  CUSTOMER_HAS_PAYMENT_RECEIVES: 'CUSTOMER_HAS_PAYMENT_RECEIVES',
+  PAYMENT_ACCOUNT_CURRENCY_INVALID: 'PAYMENT_ACCOUNT_CURRENCY_INVALID'
+};
+
+
+export const DEFAULT_VIEWS = [];
\ No newline at end of file
diff --git a/packages/server/src/services/Sales/Receipts/SaleReceiptCostGLEntries.ts b/packages/server/src/services/Sales/Receipts/SaleReceiptCostGLEntries.ts
new file mode 100644
index 000000000..1ec69625b
--- /dev/null
+++ b/packages/server/src/services/Sales/Receipts/SaleReceiptCostGLEntries.ts
@@ -0,0 +1,148 @@
+import { Service, Inject } from 'typedi';
+import * as R from 'ramda';
+import { Knex } from 'knex';
+import { AccountNormal, IInventoryLotCost, ILedgerEntry } from '@/interfaces';
+import { increment } from 'utils';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import Ledger from '@/services/Accounting/Ledger';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import { groupInventoryTransactionsByTypeId } from '../../Inventory/utils';
+
+@Service()
+export class SaleReceiptCostGLEntries {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private ledgerStorage: LedgerStorageService;
+
+  /**
+   * Writes journal entries from sales invoices.
+   * @param {number} tenantId - The tenant id.
+   * @param {Date} startingDate - Starting date.
+   * @param {boolean} override
+   */
+  public writeInventoryCostJournalEntries = async (
+    tenantId: number,
+    startingDate: Date,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { InventoryCostLotTracker } = this.tenancy.models(tenantId);
+
+    const inventoryCostLotTrans = await InventoryCostLotTracker.query()
+      .where('direction', 'OUT')
+      .where('transaction_type', 'SaleReceipt')
+      .where('cost', '>', 0)
+      .modify('filterDateRange', startingDate)
+      .orderBy('date', 'ASC')
+      .withGraphFetched('receipt')
+      .withGraphFetched('item');
+
+    const ledger = this.getInventoryCostLotsLedger(inventoryCostLotTrans);
+
+    // Commit the ledger to the storage.
+    await this.ledgerStorage.commit(tenantId, ledger, trx);
+  };
+
+  /**
+   * Retrieves the inventory cost lots ledger.
+   * @param   {} inventoryCostLots
+   * @returns {Ledger}
+   */
+  private getInventoryCostLotsLedger = (
+    inventoryCostLots: IInventoryLotCost[]
+  ) => {
+    // Groups the inventory cost lots transactions.
+    const inventoryTransactions =
+      groupInventoryTransactionsByTypeId(inventoryCostLots);
+
+    //
+    const entries = inventoryTransactions
+      .map(this.getSaleInvoiceCostGLEntries)
+      .flat();
+
+    return new Ledger(entries);
+  };
+
+  /**
+   *
+   * @param   {IInventoryLotCost} inventoryCostLot
+   * @returns {}
+   */
+  private getInvoiceCostGLCommonEntry = (
+    inventoryCostLot: IInventoryLotCost
+  ) => {
+    return {
+      currencyCode: inventoryCostLot.receipt.currencyCode,
+      exchangeRate: inventoryCostLot.receipt.exchangeRate,
+
+      transactionType: inventoryCostLot.transactionType,
+      transactionId: inventoryCostLot.transactionId,
+
+      date: inventoryCostLot.date,
+      indexGroup: 20,
+      costable: true,
+      createdAt: inventoryCostLot.createdAt,
+
+      debit: 0,
+      credit: 0,
+
+      branchId: inventoryCostLot.receipt.branchId,
+    };
+  };
+
+  /**
+   * Retrieves the inventory cost GL entry.
+   * @param   {IInventoryLotCost} inventoryLotCost
+   * @returns {ILedgerEntry[]}
+   */
+  private getInventoryCostGLEntry = R.curry(
+    (
+      getIndexIncrement,
+      inventoryCostLot: IInventoryLotCost
+    ): ILedgerEntry[] => {
+      const commonEntry = this.getInvoiceCostGLCommonEntry(inventoryCostLot);
+      const costAccountId =
+        inventoryCostLot.costAccountId || inventoryCostLot.item.costAccountId;
+
+      // XXX Debit - Cost account.
+      const costEntry = {
+        ...commonEntry,
+        debit: inventoryCostLot.cost,
+        accountId: costAccountId,
+        accountNormal: AccountNormal.DEBIT,
+        itemId: inventoryCostLot.itemId,
+        index: getIndexIncrement(),
+      };
+      // XXX Credit - Inventory account.
+      const inventoryEntry = {
+        ...commonEntry,
+        credit: inventoryCostLot.cost,
+        accountId: inventoryCostLot.item.inventoryAccountId,
+        accountNormal: AccountNormal.DEBIT,
+        itemId: inventoryCostLot.itemId,
+        index: getIndexIncrement(),
+      };
+      return [costEntry, inventoryEntry];
+    }
+  );
+
+  /**
+   * Writes journal entries for given sale invoice.
+   * -------
+   * - Cost of goods sold -> Debit -> YYYY
+   *    - Inventory assets -> Credit -> YYYY
+   * --------
+   * @param {ISaleInvoice} saleInvoice
+   * @param {JournalPoster} journal
+   */
+  public getSaleInvoiceCostGLEntries = (
+    inventoryCostLots: IInventoryLotCost[]
+  ): ILedgerEntry[] => {
+    const getIndexIncrement = increment(0);
+    const getInventoryLotEntry =
+      this.getInventoryCostGLEntry(getIndexIncrement);
+
+    return inventoryCostLots.map(getInventoryLotEntry).flat();
+  };
+}
diff --git a/packages/server/src/services/Sales/Receipts/SaleReceiptTransformer.ts b/packages/server/src/services/Sales/Receipts/SaleReceiptTransformer.ts
new file mode 100644
index 000000000..0469adfa0
--- /dev/null
+++ b/packages/server/src/services/Sales/Receipts/SaleReceiptTransformer.ts
@@ -0,0 +1,44 @@
+import { Service } from 'typedi';
+import { ISaleReceipt } from '@/interfaces';
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+@Service()
+export class SaleReceiptTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return ['formattedAmount', 'formattedReceiptDate', 'formattedClosedAtDate'];
+  };
+
+  /**
+   * Retrieve formatted receipt date.
+   * @param {ISaleReceipt} invoice
+   * @returns {String}
+   */
+  protected formattedReceiptDate = (receipt: ISaleReceipt): string => {
+    return this.formatDate(receipt.receiptDate);
+  };
+
+  /**
+   * Retrieve formatted estimate closed at date.
+   * @param {ISaleReceipt} invoice
+   * @returns {String}
+   */
+  protected formattedClosedAtDate = (receipt: ISaleReceipt): string => {
+    return this.formatDate(receipt.closedAt);
+  };
+
+  /**
+   * Retrieve formatted invoice amount.
+   * @param {ISaleReceipt} estimate
+   * @returns {string}
+   */
+  protected formattedAmount = (receipt: ISaleReceipt): string => {
+    return formatNumber(receipt.amount, {
+      currencyCode: receipt.currencyCode,
+    });
+  };
+}
diff --git a/packages/server/src/services/Sales/Receipts/SaleReceiptsPdfService.ts b/packages/server/src/services/Sales/Receipts/SaleReceiptsPdfService.ts
new file mode 100644
index 000000000..92db42f38
--- /dev/null
+++ b/packages/server/src/services/Sales/Receipts/SaleReceiptsPdfService.ts
@@ -0,0 +1,36 @@
+import { Inject, Service } from 'typedi';
+import PdfService from '@/services/PDF/PdfService';
+import { templateRender } from 'utils';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Tenant } from '@/system/models';
+
+@Service()
+export default class SaleReceiptsPdf {
+  @Inject()
+  pdfService: PdfService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve sale invoice pdf content.
+   * @param {} saleInvoice -
+   */
+  async saleReceiptPdf(tenantId: number, saleReceipt) {
+    const i18n = this.tenancy.i18n(tenantId);
+
+    const organization = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const htmlContent = templateRender('modules/receipt-regular', {
+      saleReceipt,
+      organizationName: organization.metadata.name,
+      organizationEmail: organization.metadata.email,
+      ...i18n,
+    });
+    const pdfContent = await this.pdfService.pdfDocument(htmlContent);
+
+    return pdfContent;
+  }
+}
diff --git a/packages/server/src/services/Sales/Receipts/constants.ts b/packages/server/src/services/Sales/Receipts/constants.ts
new file mode 100644
index 000000000..bf0cdef18
--- /dev/null
+++ b/packages/server/src/services/Sales/Receipts/constants.ts
@@ -0,0 +1,31 @@
+export const ERRORS = {
+  SALE_RECEIPT_NOT_FOUND: 'SALE_RECEIPT_NOT_FOUND',
+  DEPOSIT_ACCOUNT_NOT_FOUND: 'DEPOSIT_ACCOUNT_NOT_FOUND',
+  DEPOSIT_ACCOUNT_NOT_CURRENT_ASSET: 'DEPOSIT_ACCOUNT_NOT_CURRENT_ASSET',
+  SALE_RECEIPT_NUMBER_NOT_UNIQUE: 'SALE_RECEIPT_NUMBER_NOT_UNIQUE',
+  SALE_RECEIPT_IS_ALREADY_CLOSED: 'SALE_RECEIPT_IS_ALREADY_CLOSED',
+  SALE_RECEIPT_NO_IS_REQUIRED: 'SALE_RECEIPT_NO_IS_REQUIRED',
+  CUSTOMER_HAS_SALES_INVOICES: 'CUSTOMER_HAS_SALES_INVOICES',
+};
+
+export const DEFAULT_VIEW_COLUMNS = [];
+export const DEFAULT_VIEWS = [
+  {
+    name: 'Draft',
+    slug: 'draft',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'draft' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Closed',
+    slug: 'closed',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'closed' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+];
diff --git a/packages/server/src/services/Sales/Receipts/subscribers/SaleReceiptCostGLEntriesSubscriber.ts b/packages/server/src/services/Sales/Receipts/subscribers/SaleReceiptCostGLEntriesSubscriber.ts
new file mode 100644
index 000000000..faaa9a124
--- /dev/null
+++ b/packages/server/src/services/Sales/Receipts/subscribers/SaleReceiptCostGLEntriesSubscriber.ts
@@ -0,0 +1,36 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import { IInventoryCostLotsGLEntriesWriteEvent } from '@/interfaces';
+import { SaleReceiptCostGLEntries } from '../SaleReceiptCostGLEntries';
+
+@Service()
+export class SaleReceiptCostGLEntriesSubscriber {
+  @Inject()
+  saleReceiptCostEntries: SaleReceiptCostGLEntries;
+
+  /**
+   * Attaches events.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.inventory.onCostLotsGLEntriesWrite,
+      this.writeJournalEntriesOnceWriteoffCreate
+    );
+  }
+
+  /**
+   * Writes the receipts cost GL entries once the inventory cost lots be written.
+   * @param {IInventoryCostLotsGLEntriesWriteEvent}
+   */
+  writeJournalEntriesOnceWriteoffCreate = async ({
+    trx,
+    startingDate,
+    tenantId,
+  }: IInventoryCostLotsGLEntriesWriteEvent) => {
+    await this.saleReceiptCostEntries.writeInventoryCostJournalEntries(
+      tenantId,
+      startingDate,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Sales/SaleInvoiceNotifyBySms.ts b/packages/server/src/services/Sales/SaleInvoiceNotifyBySms.ts
new file mode 100644
index 000000000..f0303b981
--- /dev/null
+++ b/packages/server/src/services/Sales/SaleInvoiceNotifyBySms.ts
@@ -0,0 +1,258 @@
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import SaleInvoicesService from './SalesInvoices';
+import SMSClient from '@/services/SMSClient';
+import {
+  ISaleInvoice,
+  ISaleInvoiceSmsDetailsDTO,
+  ISaleInvoiceSmsDetails,
+  SMS_NOTIFICATION_KEY,
+  InvoiceNotificationType,
+  ICustomer,
+} from '@/interfaces';
+import SmsNotificationsSettingsService from '@/services/Settings/SmsNotificationsSettings';
+import { formatSmsMessage, formatNumber } from 'utils';
+import { TenantMetadata } from '@/system/models';
+import SaleNotifyBySms from './SaleNotifyBySms';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+@Service()
+export default class SaleInvoiceNotifyBySms {
+  @Inject()
+  invoiceService: SaleInvoicesService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  smsNotificationsSettings: SmsNotificationsSettingsService;
+
+  @Inject()
+  saleSmsNotification: SaleNotifyBySms;
+
+  /**
+   * Notify customer via sms about sale invoice.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} saleInvoiceId - Sale invoice id.
+   */
+  public notifyBySms = async (
+    tenantId: number,
+    saleInvoiceId: number,
+    invoiceNotificationType: InvoiceNotificationType
+  ) => {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    // Retrieve the sale invoice or throw not found service error.
+    const saleInvoice = await SaleInvoice.query()
+      .findById(saleInvoiceId)
+      .withGraphFetched('customer');
+
+    // Validate the customer phone number existance and number validation.
+    this.saleSmsNotification.validateCustomerPhoneNumber(
+      saleInvoice.customer.personalPhone
+    );
+    // Transformes the invoice notification key to sms notification key.
+    const notificationKey = this.transformDTOKeyToNotificationKey(
+      invoiceNotificationType
+    );
+    // Triggers `onSaleInvoiceNotifySms` event.
+    await this.eventPublisher.emitAsync(events.saleInvoice.onNotifySms, {
+      tenantId,
+      saleInvoice,
+    });
+    // Formattes the sms message and sends sms notification.
+    await this.sendSmsNotification(tenantId, notificationKey, saleInvoice);
+
+    // Triggers `onSaleInvoiceNotifySms` event.
+    await this.eventPublisher.emitAsync(events.saleInvoice.onNotifiedSms, {
+      tenantId,
+      saleInvoice,
+    });
+    return saleInvoice;
+  };
+
+  /**
+   * Notify invoice details by sms notification after invoice creation.
+   * @param {number} tenantId
+   * @param {number} saleInvoiceId
+   * @returns {Promise<void>}
+   */
+  public notifyDetailsBySmsAfterCreation = async (
+    tenantId: number,
+    saleInvoiceId: number
+  ): Promise<void> => {
+    const notification = this.smsNotificationsSettings.getSmsNotificationMeta(
+      tenantId,
+      SMS_NOTIFICATION_KEY.SALE_INVOICE_DETAILS
+    );
+    // Can't continue if the sms auto-notification is not enabled.
+    if (!notification.isNotificationEnabled) return;
+
+    await this.notifyBySms(tenantId, saleInvoiceId, 'details');
+  };
+
+  /**
+   * Sends SMS notification.
+   * @param {ISaleInvoice} invoice
+   * @param {ICustomer} customer
+   * @returns {Promise<void>}
+   */
+  private sendSmsNotification = async (
+    tenantId: number,
+    notificationType:
+      | SMS_NOTIFICATION_KEY.SALE_INVOICE_DETAILS
+      | SMS_NOTIFICATION_KEY.SALE_INVOICE_REMINDER,
+    invoice: ISaleInvoice & { customer: ICustomer }
+  ): Promise<void> => {
+    const smsClient = this.tenancy.smsClient(tenantId);
+    const tenantMetadata = await TenantMetadata.query().findOne({ tenantId });
+
+    // Formates the given sms message.
+    const message = this.formattedInvoiceDetailsMessage(
+      tenantId,
+      notificationType,
+      invoice,
+      tenantMetadata
+    );
+    const phoneNumber = invoice.customer.personalPhone;
+
+    // Run the send sms notification message job.
+    await smsClient.sendMessageJob(phoneNumber, message);
+  };
+
+  /**
+   * Formates the invoice details sms message.
+   * @param {number} tenantId
+   * @param {ISaleInvoice} invoice
+   * @param {ICustomer} customer
+   * @returns {string}
+   */
+  private formattedInvoiceDetailsMessage = (
+    tenantId: number,
+    notificationKey:
+      | SMS_NOTIFICATION_KEY.SALE_INVOICE_DETAILS
+      | SMS_NOTIFICATION_KEY.SALE_INVOICE_REMINDER,
+    invoice: ISaleInvoice,
+    tenantMetadata: TenantMetadata
+  ): string => {
+    const notification = this.smsNotificationsSettings.getSmsNotificationMeta(
+      tenantId,
+      notificationKey
+    );
+    return this.formatInvoiceDetailsMessage(
+      notification.smsMessage,
+      invoice,
+      tenantMetadata
+    );
+  };
+
+  /**
+   * Formattees the given invoice details sms message.
+   * @param {string} smsMessage
+   * @param {ISaleInvoice} invoice
+   * @param {ICustomer} customer
+   * @param {TenantMetadata} tenantMetadata
+   */
+  private formatInvoiceDetailsMessage = (
+    smsMessage: string,
+    invoice: ISaleInvoice & { customer: ICustomer },
+    tenantMetadata: TenantMetadata
+  ) => {
+    const formattedDueAmount = formatNumber(invoice.dueAmount, {
+      currencyCode: invoice.currencyCode,
+    });
+    const formattedAmount = formatNumber(invoice.balance, {
+      currencyCode: invoice.currencyCode,
+    });
+
+    return formatSmsMessage(smsMessage, {
+      InvoiceNumber: invoice.invoiceNo,
+      ReferenceNumber: invoice.referenceNo,
+      CustomerName: invoice.customer.displayName,
+      DueAmount: formattedDueAmount,
+      DueDate: moment(invoice.dueDate).format('YYYY/MM/DD'),
+      Amount: formattedAmount,
+      CompanyName: tenantMetadata.name,
+    });
+  };
+
+  /**
+   * Retrieve the SMS details of the given invoice.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} saleInvoiceId - Sale invoice id.
+   */
+  public smsDetails = async (
+    tenantId: number,
+    saleInvoiceId: number,
+    invoiceSmsDetailsDTO: ISaleInvoiceSmsDetailsDTO
+  ): Promise<ISaleInvoiceSmsDetails> => {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    // Retrieve the sale invoice or throw not found service error.
+    const saleInvoice = await SaleInvoice.query()
+      .findById(saleInvoiceId)
+      .withGraphFetched('customer');
+
+    // Validates the sale invoice existance.
+    this.validateSaleInvoiceExistance(saleInvoice);
+
+    // Current tenant metadata.
+    const tenantMetadata = await TenantMetadata.query().findOne({ tenantId });
+
+    // Transformes the invoice notification key to sms notification key.
+    const notificationKey = this.transformDTOKeyToNotificationKey(
+      invoiceSmsDetailsDTO.notificationKey
+    );
+    // Formates the given sms message.
+    const smsMessage = this.formattedInvoiceDetailsMessage(
+      tenantId,
+      notificationKey,
+      saleInvoice,
+      tenantMetadata
+    );
+
+    return {
+      customerName: saleInvoice.customer.displayName,
+      customerPhoneNumber: saleInvoice.customer.personalPhone,
+      smsMessage,
+    };
+  };
+
+  /**
+   * Transformes the invoice notification key DTO to notification key.
+   * @param {string} invoiceNotifKey
+   * @returns {SMS_NOTIFICATION_KEY.SALE_INVOICE_DETAILS
+   *   | SMS_NOTIFICATION_KEY.SALE_INVOICE_REMINDER}
+   */
+  private transformDTOKeyToNotificationKey = (
+    invoiceNotifKey: string
+  ):
+    | SMS_NOTIFICATION_KEY.SALE_INVOICE_DETAILS
+    | SMS_NOTIFICATION_KEY.SALE_INVOICE_REMINDER => {
+    const invoiceNotifKeyPairs = {
+      details: SMS_NOTIFICATION_KEY.SALE_INVOICE_DETAILS,
+      reminder: SMS_NOTIFICATION_KEY.SALE_INVOICE_REMINDER,
+    };
+    return (
+      invoiceNotifKeyPairs[invoiceNotifKey] ||
+      SMS_NOTIFICATION_KEY.SALE_INVOICE_DETAILS
+    );
+  };
+
+  /**
+   * Validates the sale invoice existance.
+   * @param {ISaleInvoice|null} saleInvoice
+   */
+  private validateSaleInvoiceExistance(saleInvoice: ISaleInvoice | null) {
+    if (!saleInvoice) {
+      throw new ServiceError(ERRORS.SALE_INVOICE_NOT_FOUND);
+    }
+  }
+}
diff --git a/packages/server/src/services/Sales/SaleInvoicePdf.ts b/packages/server/src/services/Sales/SaleInvoicePdf.ts
new file mode 100644
index 000000000..fdbd89100
--- /dev/null
+++ b/packages/server/src/services/Sales/SaleInvoicePdf.ts
@@ -0,0 +1,37 @@
+import { Inject, Service } from 'typedi';
+import PdfService from '@/services/PDF/PdfService';
+import { templateRender } from 'utils';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Tenant } from '@/system/models';
+
+@Service()
+export default class SaleInvoicePdf {
+  @Inject()
+  pdfService: PdfService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieve sale invoice pdf content.
+   * @param {} saleInvoice -
+   */
+  async saleInvoicePdf(tenantId: number, saleInvoice) {
+    const i18n = this.tenancy.i18n(tenantId);
+
+    const organization = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const htmlContent = templateRender('modules/invoice-regular', {
+      organization,
+      organizationName: organization.metadata.name,
+      organizationEmail: organization.metadata.email,
+      saleInvoice,
+      ...i18n,
+    });
+    const pdfContent = await this.pdfService.pdfDocument(htmlContent);
+
+    return pdfContent;
+  }
+}
diff --git a/packages/server/src/services/Sales/SaleInvoiceTransformer.ts b/packages/server/src/services/Sales/SaleInvoiceTransformer.ts
new file mode 100644
index 000000000..dfbd704fa
--- /dev/null
+++ b/packages/server/src/services/Sales/SaleInvoiceTransformer.ts
@@ -0,0 +1,91 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class SaleInvoiceTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedInvoiceDate',
+      'formattedDueDate',
+      'formattedAmount',
+      'formattedDueAmount',
+      'formattedPaymentAmount',
+      'formattedBalanceAmount',
+      'formattedExchangeRate',
+    ];
+  };
+
+  /**
+   * Retrieve formatted invoice date.
+   * @param {ISaleInvoice} invoice
+   * @returns {String}
+   */
+  protected formattedInvoiceDate = (invoice): string => {
+    return this.formatDate(invoice.invoiceDate);
+  };
+
+  /**
+   * Retrieve formatted due date.
+   * @param {ISaleInvoice} invoice
+   * @returns {string}
+   */
+  protected formattedDueDate = (invoice): string => {
+    return this.formatDate(invoice.dueDate);
+  };
+
+  /**
+   * Retrieve formatted invoice amount.
+   * @param {ISaleInvoice} invoice
+   * @returns {string}
+   */
+  protected formattedAmount = (invoice): string => {
+    return formatNumber(invoice.balance, {
+      currencyCode: invoice.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve formatted invoice due amount.
+   * @param {ISaleInvoice} invoice
+   * @returns {string}
+   */
+  protected formattedDueAmount = (invoice): string => {
+    return formatNumber(invoice.dueAmount, {
+      currencyCode: invoice.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve formatted payment amount.
+   * @param {ISaleInvoice} invoice
+   * @returns {string}
+   */
+  protected formattedPaymentAmount = (invoice): string => {
+    return formatNumber(invoice.paymentAmount, {
+      currencyCode: invoice.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve the formatted invoice balance.
+   * @param {ISaleInvoice} invoice
+   * @returns {string}
+   */
+  protected formattedBalanceAmount = (invoice): string => {
+    return formatNumber(invoice.balanceAmount, {
+      currencyCode: invoice.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieve the formatted exchange rate.
+   * @param {ISaleInvoice} invoice
+   * @returns {string}
+   */
+  protected formattedExchangeRate = (invoice): string => {
+    return formatNumber(invoice.exchangeRate, { money: false });
+  };
+}
diff --git a/packages/server/src/services/Sales/SaleInvoiceWriteoff.ts b/packages/server/src/services/Sales/SaleInvoiceWriteoff.ts
new file mode 100644
index 000000000..35792b75f
--- /dev/null
+++ b/packages/server/src/services/Sales/SaleInvoiceWriteoff.ts
@@ -0,0 +1,166 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import {
+  ISaleInvoice,
+  ISaleInvoiceWriteoffCreatePayload,
+  ISaleInvoiceWriteoffDTO,
+  ISaleInvoiceWrittenOffCanceledPayload,
+  ISaleInvoiceWrittenOffCancelPayload,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import { ServiceError } from '@/exceptions';
+
+import JournalPosterService from './JournalPosterService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+const ERRORS = {
+  SALE_INVOICE_ALREADY_WRITTEN_OFF: 'SALE_INVOICE_ALREADY_WRITTEN_OFF',
+  SALE_INVOICE_NOT_WRITTEN_OFF: 'SALE_INVOICE_NOT_WRITTEN_OFF',
+};
+
+@Service()
+export default class SaleInvoiceWriteoff {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  journalService: JournalPosterService;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  /**
+   * Writes-off the sale invoice on bad debt expense account.
+   * @param {number} tenantId
+   * @param {number} saleInvoiceId
+   * @param {ISaleInvoiceWriteoffDTO} writeoffDTO
+   * @return {Promise<ISaleInvoice>}
+   */
+  public writeOff = async (
+    tenantId: number,
+    saleInvoiceId: number,
+    writeoffDTO: ISaleInvoiceWriteoffDTO
+  ): Promise<ISaleInvoice> => {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    // Validate the sale invoice existance.
+    // Retrieve the sale invoice or throw not found service error.
+    const saleInvoice = await SaleInvoice.query()
+      .findById(saleInvoiceId)
+      .throwIfNotFound();
+
+    // Validate the sale invoice whether already written-off.
+    this.validateSaleInvoiceAlreadyWrittenoff(saleInvoice);
+
+    // Saves the invoice write-off transaction with associated transactions 
+    // under unit-of-work envirmenet.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      const eventPayload = {
+        tenantId,
+        saleInvoiceId,
+        saleInvoice,
+        writeoffDTO,
+        trx,
+      } as ISaleInvoiceWriteoffCreatePayload;
+
+      // Triggers `onSaleInvoiceWriteoff` event.
+      await this.eventPublisher.emitAsync(
+        events.saleInvoice.onWriteoff,
+        eventPayload
+      );
+      // Mark the sale invoice as written-off.
+      const newSaleInvoice = await SaleInvoice.query(trx)
+        .patch({
+          writtenoffExpenseAccountId: writeoffDTO.expenseAccountId,
+          writtenoffAmount: saleInvoice.dueAmount,
+          writtenoffAt: new Date(),
+        })
+        .findById(saleInvoiceId);
+
+      // Triggers `onSaleInvoiceWrittenoff` event.
+      await this.eventPublisher.emitAsync(
+        events.saleInvoice.onWrittenoff,
+        eventPayload
+      );
+      return newSaleInvoice;
+    });
+  };
+
+  /**
+   * Cancels the written-off sale invoice.
+   * @param {number} tenantId
+   * @param {number} saleInvoiceId
+   * @returns {Promise<ISaleInvoice>}
+   */
+  public cancelWrittenoff = async (
+    tenantId: number,
+    saleInvoiceId: number
+  ): Promise<ISaleInvoice> => {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    // Validate the sale invoice existance.
+    // Retrieve the sale invoice or throw not found service error.
+    const saleInvoice = await SaleInvoice.query()
+      .findById(saleInvoiceId)
+      .throwIfNotFound();
+
+    // Validate the sale invoice whether already written-off.
+    this.validateSaleInvoiceNotWrittenoff(saleInvoice);
+
+    // Cancels the invoice written-off and removes the associated transactions.
+    return this.uow.withTransaction(tenantId, async (trx) => {
+      // Triggers `onSaleInvoiceWrittenoffCancel` event.
+      await this.eventPublisher.emitAsync(
+        events.saleInvoice.onWrittenoffCancel,
+        {
+          tenantId,
+          saleInvoice,
+          trx,
+        } as ISaleInvoiceWrittenOffCancelPayload
+      );
+      // Mark the sale invoice as written-off.
+      const newSaleInvoice = await SaleInvoice.query(trx)
+        .patch({
+          writtenoffAmount: null,
+          writtenoffAt: null,
+        })
+        .findById(saleInvoiceId);
+
+      // Triggers `onSaleInvoiceWrittenoffCanceled`.
+      await this.eventPublisher.emitAsync(
+        events.saleInvoice.onWrittenoffCanceled,
+        {
+          tenantId,
+          saleInvoice,
+          trx,
+        } as ISaleInvoiceWrittenOffCanceledPayload
+      );
+      return newSaleInvoice;
+    });
+  };
+
+  /**
+   * Should sale invoice not be written-off.
+   * @param {ISaleInvoice} saleInvoice
+   */
+  private validateSaleInvoiceNotWrittenoff(saleInvoice: ISaleInvoice) {
+    if (!saleInvoice.isWrittenoff) {
+      throw new ServiceError(ERRORS.SALE_INVOICE_NOT_WRITTEN_OFF);
+    }
+  }
+
+  /**
+   * Should sale invoice already written-off.
+   * @param {ISaleInvoice} saleInvoice
+   */
+  private validateSaleInvoiceAlreadyWrittenoff(saleInvoice: ISaleInvoice) {
+    if (saleInvoice.isWrittenoff) {
+      throw new ServiceError(ERRORS.SALE_INVOICE_ALREADY_WRITTEN_OFF);
+    }
+  }
+}
diff --git a/packages/server/src/services/Sales/SaleInvoiceWriteoffGLEntries.ts b/packages/server/src/services/Sales/SaleInvoiceWriteoffGLEntries.ts
new file mode 100644
index 000000000..456432cde
--- /dev/null
+++ b/packages/server/src/services/Sales/SaleInvoiceWriteoffGLEntries.ts
@@ -0,0 +1,104 @@
+import { Service } from 'typedi';
+import { ISaleInvoice, AccountNormal, ILedgerEntry, ILedger } from '@/interfaces';
+import Ledger from '@/services/Accounting/Ledger';
+
+@Service()
+export class SaleInvoiceWriteoffGLEntries {
+  /**
+   * Retrieves the invoice write-off common GL entry.
+   * @param {ISaleInvoice} saleInvoice
+   */
+  private getInvoiceWriteoffGLCommonEntry = (saleInvoice: ISaleInvoice) => {
+    return {
+      date: saleInvoice.invoiceDate,
+
+      currencyCode: saleInvoice.currencyCode,
+      exchangeRate: saleInvoice.exchangeRate,
+
+      transactionId: saleInvoice.id,
+      transactionType: 'InvoiceWriteOff',
+      transactionNumber: saleInvoice.invoiceNo,
+
+      referenceNo: saleInvoice.referenceNo,
+      branchId: saleInvoice.branchId,
+    };
+  };
+
+  /**
+   * Retrieves the invoice write-off receiveable GL entry.
+   * @param   {number} ARAccountId
+   * @param   {ISaleInvoice} saleInvoice
+   * @returns {ILedgerEntry}
+   */
+  private getInvoiceWriteoffGLReceivableEntry = (
+    ARAccountId: number,
+    saleInvoice: ISaleInvoice
+  ): ILedgerEntry => {
+    const commontEntry = this.getInvoiceWriteoffGLCommonEntry(saleInvoice);
+
+    return {
+      ...commontEntry,
+      credit: saleInvoice.localWrittenoffAmount,
+      accountId: ARAccountId,
+      contactId: saleInvoice.customerId,
+      debit: 0,
+      index: 1,
+      indexGroup: 300,
+      accountNormal: saleInvoice.writtenoffExpenseAccount.accountNormal,
+    };
+  };
+
+  /**
+   * Retrieves the invoice write-off expense GL entry.
+   * @param   {ISaleInvoice} saleInvoice
+   * @returns {ILedgerEntry}
+   */
+  private getInvoiceWriteoffGLExpenseEntry = (
+    saleInvoice: ISaleInvoice
+  ): ILedgerEntry => {
+    const commontEntry = this.getInvoiceWriteoffGLCommonEntry(saleInvoice);
+
+    return {
+      ...commontEntry,
+      debit: saleInvoice.localWrittenoffAmount,
+      accountId: saleInvoice.writtenoffExpenseAccountId,
+      credit: 0,
+      index: 2,
+      indexGroup: 300,
+      accountNormal: AccountNormal.DEBIT,
+    };
+  };
+
+  /**
+   * Retrieves the invoice write-off GL entries.
+   * @param   {number} ARAccountId
+   * @param   {ISaleInvoice} saleInvoice
+   * @returns {ILedgerEntry[]}
+   */
+  public getInvoiceWriteoffGLEntries = (
+    ARAccountId: number,
+    saleInvoice: ISaleInvoice
+  ): ILedgerEntry[] => {
+    const creditEntry = this.getInvoiceWriteoffGLExpenseEntry(saleInvoice);
+    const debitEntry = this.getInvoiceWriteoffGLReceivableEntry(
+      ARAccountId,
+      saleInvoice
+    );
+    return [debitEntry, creditEntry];
+  };
+
+  /**
+   * Retrieves the invoice write-off ledger.
+   * @param   {number} ARAccountId
+   * @param   {ISaleInvoice} saleInvoice
+   * @returns {Ledger}
+   */
+  public getInvoiceWriteoffLedger = (
+    ARAccountId: number,
+    saleInvoice: ISaleInvoice
+  ): ILedger => {
+    const entries = this.getInvoiceWriteoffGLEntries(ARAccountId, saleInvoice);
+
+    return new Ledger(entries);
+  };
+}
diff --git a/packages/server/src/services/Sales/SaleInvoiceWriteoffGLStorage.ts b/packages/server/src/services/Sales/SaleInvoiceWriteoffGLStorage.ts
new file mode 100644
index 000000000..be58388b7
--- /dev/null
+++ b/packages/server/src/services/Sales/SaleInvoiceWriteoffGLStorage.ts
@@ -0,0 +1,88 @@
+import { Knex } from 'knex';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Service, Inject } from 'typedi';
+import { SaleInvoiceWriteoffGLEntries } from './SaleInvoiceWriteoffGLEntries';
+
+@Service()
+export class SaleInvoiceWriteoffGLStorage {
+  @Inject()
+  private invoiceWriteoffLedger: SaleInvoiceWriteoffGLEntries;
+
+  @Inject()
+  private ledgerStorage: LedgerStorageService;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Writes the invoice write-off GL entries.
+   * @param   {number} tenantId
+   * @param   {number} saleInvoiceId
+   * @param   {Knex.Transaction} trx
+   * @returns {Promise<void>}
+   */
+  public writeInvoiceWriteoffEntries = async (
+    tenantId: number,
+    saleInvoiceId: number,
+    trx?: Knex.Transaction
+  ) => {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+
+    // Retrieves the sale invoice.
+    const saleInvoice = await SaleInvoice.query(trx)
+      .findById(saleInvoiceId)
+      .withGraphFetched('writtenoffExpenseAccount');
+
+    // Find or create the A/R account.
+    const ARAccount = await accountRepository.findOrCreateAccountReceivable(
+      saleInvoice.currencyCode,
+      {},
+      trx
+    );
+    // Retrieves the invoice write-off ledger.
+    const ledger = this.invoiceWriteoffLedger.getInvoiceWriteoffLedger(
+      ARAccount.id,
+      saleInvoice
+    );
+    return this.ledgerStorage.commit(tenantId, ledger, trx);
+  };
+
+  /**
+   * Rewrites the invoice write-off GL entries.
+   * @param   {number} tenantId
+   * @param   {number} saleInvoiceId
+   * @param   {Knex.Transactio} actiontrx
+   * @returns {Promise<void>}
+   */
+  public rewriteInvoiceWriteoffEntries = async (
+    tenantId: number,
+    saleInvoiceId: number,
+    trx?: Knex.Transaction
+  ) => {
+    await this.revertInvoiceWriteoffEntries(tenantId, saleInvoiceId, trx);
+
+    await this.writeInvoiceWriteoffEntries(tenantId, saleInvoiceId, trx);
+  };
+
+  /**
+   * Reverts the invoice write-off GL entries.
+   * @param   {number} tenantId
+   * @param   {number} saleInvoiceId
+   * @param   {Knex.Transaction} trx
+   * @returns {Promise<void>}
+   */
+  public revertInvoiceWriteoffEntries = async (
+    tenantId: number,
+    saleInvoiceId: number,
+    trx?: Knex.Transaction
+  ) => {
+    await this.ledgerStorage.deleteByReference(
+      tenantId,
+      saleInvoiceId,
+      'InvoiceWriteOff',
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Sales/SaleInvoiceWriteoffSubscriber.ts b/packages/server/src/services/Sales/SaleInvoiceWriteoffSubscriber.ts
new file mode 100644
index 000000000..e2e4b0f0d
--- /dev/null
+++ b/packages/server/src/services/Sales/SaleInvoiceWriteoffSubscriber.ts
@@ -0,0 +1,58 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  ISaleInvoiceWriteoffCreatePayload,
+  ISaleInvoiceWrittenOffCanceledPayload,
+} from '@/interfaces';
+import { SaleInvoiceWriteoffGLStorage } from './SaleInvoiceWriteoffGLStorage';
+
+@Service()
+export default class SaleInvoiceWriteoffSubscriber {
+  @Inject()
+  writeGLStorage: SaleInvoiceWriteoffGLStorage;
+
+  /**
+   * Attaches events.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleInvoice.onWrittenoff,
+      this.writeJournalEntriesOnceWriteoffCreate
+    );
+    bus.subscribe(
+      events.saleInvoice.onWrittenoffCanceled,
+      this.revertJournalEntriesOnce
+    );
+  }
+  /**
+   * Write the written-off sale invoice journal entries.
+   * @param {ISaleInvoiceWriteoffCreatePayload}
+   */
+  private writeJournalEntriesOnceWriteoffCreate = async ({
+    tenantId,
+    saleInvoice,
+    trx,
+  }: ISaleInvoiceWriteoffCreatePayload) => {
+    await this.writeGLStorage.writeInvoiceWriteoffEntries(
+      tenantId,
+      saleInvoice.id,
+      trx
+    );
+  };
+
+  /**
+   * Reverts the written-of sale invoice jounral entries.
+   * @param {ISaleInvoiceWrittenOffCanceledPayload}
+   */
+  private revertJournalEntriesOnce = async ({
+    tenantId,
+    saleInvoice,
+    trx,
+  }: ISaleInvoiceWrittenOffCanceledPayload) => {
+    await this.writeGLStorage.revertInvoiceWriteoffEntries(
+      tenantId,
+      saleInvoice.id,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Sales/SaleNotifyBySms.ts b/packages/server/src/services/Sales/SaleNotifyBySms.ts
new file mode 100644
index 000000000..8755d714c
--- /dev/null
+++ b/packages/server/src/services/Sales/SaleNotifyBySms.ts
@@ -0,0 +1,35 @@
+import { ServiceError } from '@/exceptions';
+import parsePhoneNumber from 'libphonenumber-js';
+import { Service } from 'typedi';
+
+const ERRORS = {
+  CUSTOMER_HAS_NO_PHONE_NUMBER: 'CUSTOMER_HAS_NO_PHONE_NUMBER',
+  CUSTOMER_SMS_NOTIFY_PHONE_INVALID: 'CUSTOMER_SMS_NOTIFY_PHONE_INVALID',
+};
+
+@Service()
+export default class SaleNotifyBySms {
+  /**
+   * Validate the customer phone number.
+   * @param {ICustomer} customer
+   */
+  public validateCustomerPhoneNumber = (personalPhone: string) => {
+    if (!personalPhone) {
+      throw new ServiceError(ERRORS.CUSTOMER_HAS_NO_PHONE_NUMBER);
+    }
+
+    this.validateCustomerPhoneNumberLocally(personalPhone);
+  };
+
+  /**
+   *
+   * @param {string} personalPhone
+   */
+  public validateCustomerPhoneNumberLocally = (personalPhone: string) => {
+    const phoneNumber = parsePhoneNumber(personalPhone, 'LY');
+
+    if (!phoneNumber || !phoneNumber.isValid()) {
+      throw new ServiceError(ERRORS.CUSTOMER_SMS_NOTIFY_PHONE_INVALID);
+    }
+  };
+}
diff --git a/packages/server/src/services/Sales/SaleReceiptGLEntries.ts b/packages/server/src/services/Sales/SaleReceiptGLEntries.ts
new file mode 100644
index 000000000..df440958f
--- /dev/null
+++ b/packages/server/src/services/Sales/SaleReceiptGLEntries.ts
@@ -0,0 +1,184 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import * as R from 'ramda';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import LedgerStorageService from '@/services/Accounting/LedgerStorageService';
+import {
+  AccountNormal,
+  ILedgerEntry,
+  ISaleReceipt,
+  IItemEntry,
+} from '@/interfaces';
+import Ledger from '@/services/Accounting/Ledger';
+
+@Service()
+export class SaleReceiptGLEntries {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private ledgerStorage: LedgerStorageService;
+
+  /**
+   * Creates income GL entries.
+   * @param {number} tenantId
+   * @param {number} saleReceiptId
+   * @param {Knex.Transaction} trx
+   */
+  public writeIncomeGLEntries = async (
+    tenantId: number,
+    saleReceiptId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { SaleReceipt } = this.tenancy.models(tenantId);
+
+    const saleReceipt = await SaleReceipt.query()
+      .findById(saleReceiptId)
+      .withGraphFetched('entries.item');
+
+    // Retrieve the income entries ledger.
+    const incomeLedger = this.getIncomeEntriesLedger(saleReceipt);
+
+    // Commits the ledger entries to the storage.
+    await this.ledgerStorage.commit(tenantId, incomeLedger, trx);
+  };
+
+  /**
+   * Reverts the receipt GL entries.
+   * @param   {number} tenantId
+   * @param   {number} saleReceiptId
+   * @param   {Knex.Transaction} trx
+   * @returns {Promise<void>}
+   */
+  public revertReceiptGLEntries = async (
+    tenantId: number,
+    saleReceiptId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    await this.ledgerStorage.deleteByReference(
+      tenantId,
+      saleReceiptId,
+      'SaleReceipt',
+      trx
+    );
+  };
+
+  /**
+   * Rewrites the receipt GL entries.
+   * @param   {number} tenantId
+   * @param   {number} saleReceiptId
+   * @param   {Knex.Transaction} trx
+   * @returns {Promise<void>}
+   */
+  public rewriteReceiptGLEntries = async (
+    tenantId: number,
+    saleReceiptId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    // Reverts the receipt GL entries.
+    await this.revertReceiptGLEntries(tenantId, saleReceiptId, trx);
+
+    // Writes the income GL entries.
+    await this.writeIncomeGLEntries(tenantId, saleReceiptId, trx);
+  };
+
+  /**
+   * Retrieves the income GL ledger.
+   * @param {ISaleReceipt} saleReceipt
+   * @returns {Ledger}
+   */
+  private getIncomeEntriesLedger = (saleReceipt: ISaleReceipt): Ledger => {
+    const entries = this.getIncomeGLEntries(saleReceipt);
+
+    return new Ledger(entries);
+  };
+
+  /**
+   * Retireves the income GL common entry.
+   * @param {ISaleReceipt} saleReceipt -
+   */
+  private getIncomeGLCommonEntry = (saleReceipt: ISaleReceipt) => {
+    return {
+      currencyCode: saleReceipt.currencyCode,
+      exchangeRate: saleReceipt.exchangeRate,
+
+      transactionType: 'SaleReceipt',
+      transactionId: saleReceipt.id,
+
+      date: saleReceipt.receiptDate,
+
+      transactionNumber: saleReceipt.receiptNumber,
+      referenceNumber: saleReceipt.referenceNo,
+
+      createdAt: saleReceipt.createdAt,
+
+      credit: 0,
+      debit: 0,
+
+      userId: saleReceipt.userId,
+      branchId: saleReceipt.branchId,
+    };
+  };
+
+  /**
+   * Retrieve receipt income item GL entry.
+   * @param   {ISaleReceipt} saleReceipt -
+   * @param   {IItemEntry} entry -
+   * @param   {number} index -
+   * @returns {ILedgerEntry}
+   */
+  private getReceiptIncomeItemEntry = R.curry(
+    (
+      saleReceipt: ISaleReceipt,
+      entry: IItemEntry,
+      index: number
+    ): ILedgerEntry => {
+      const commonEntry = this.getIncomeGLCommonEntry(saleReceipt);
+      const itemIncome = entry.amount * saleReceipt.exchangeRate;
+
+      return {
+        ...commonEntry,
+        credit: itemIncome,
+        accountId: entry.item.sellAccountId,
+        note: entry.description,
+        index: index + 2,
+        itemId: entry.itemId,
+        itemQuantity: entry.quantity,
+        accountNormal: AccountNormal.CREDIT,
+      };
+    }
+  );
+
+  /**
+   * Retrieves the receipt deposit GL deposit entry.
+   * @param   {ISaleReceipt} saleReceipt
+   * @returns {ILedgerEntry}
+   */
+  private getReceiptDepositEntry = (
+    saleReceipt: ISaleReceipt
+  ): ILedgerEntry => {
+    const commonEntry = this.getIncomeGLCommonEntry(saleReceipt);
+
+    return {
+      ...commonEntry,
+      debit: saleReceipt.localAmount,
+      accountId: saleReceipt.depositAccountId,
+      index: 1,
+      accountNormal: AccountNormal.DEBIT,
+    };
+  };
+
+  /**
+   * Retrieves the income GL entries.
+   * @param   {ISaleReceipt} saleReceipt -
+   * @returns {ILedgerEntry[]}
+   */
+  private getIncomeGLEntries = (saleReceipt: ISaleReceipt): ILedgerEntry[] => {
+    const getItemEntry = this.getReceiptIncomeItemEntry(saleReceipt);
+
+    const creditEntries = saleReceipt.entries.map(getItemEntry);
+    const depositEntry = this.getReceiptDepositEntry(saleReceipt);
+
+    return [depositEntry, ...creditEntries];
+  };
+}
diff --git a/packages/server/src/services/Sales/SaleReceiptNotifyBySms.ts b/packages/server/src/services/Sales/SaleReceiptNotifyBySms.ts
new file mode 100644
index 000000000..cac535935
--- /dev/null
+++ b/packages/server/src/services/Sales/SaleReceiptNotifyBySms.ts
@@ -0,0 +1,211 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import SMSClient from '@/services/SMSClient';
+import {
+  ISaleReceiptSmsDetails,
+  ISaleReceipt,
+  SMS_NOTIFICATION_KEY,
+  ICustomer,
+} from '@/interfaces';
+import SalesReceiptService from './SalesReceipts';
+import SmsNotificationsSettingsService from '@/services/Settings/SmsNotificationsSettings';
+import { formatNumber, formatSmsMessage } from 'utils';
+import { TenantMetadata } from '@/system/models';
+import SaleNotifyBySms from './SaleNotifyBySms';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './Receipts/constants';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+@Service()
+export default class SaleReceiptNotifyBySms {
+  @Inject()
+  receiptsService: SalesReceiptService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  smsNotificationsSettings: SmsNotificationsSettingsService;
+
+  @Inject()
+  saleSmsNotification: SaleNotifyBySms;
+
+  /**
+   * Notify customer via sms about sale receipt.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} saleReceiptId - Sale receipt id.
+   */
+  public async notifyBySms(tenantId: number, saleReceiptId: number) {
+    const { SaleReceipt } = this.tenancy.models(tenantId);
+
+    // Retrieve the sale receipt or throw not found service error.
+    const saleReceipt = await SaleReceipt.query()
+      .findById(saleReceiptId)
+      .withGraphFetched('customer');
+
+    // Validates the receipt receipt existance.
+    this.validateSaleReceiptExistance(saleReceipt);
+
+    // Validate the customer phone number.
+    this.saleSmsNotification.validateCustomerPhoneNumber(
+      saleReceipt.customer.personalPhone
+    );
+    // Triggers `onSaleReceiptNotifySms` event.
+    await this.eventPublisher.emitAsync(events.saleReceipt.onNotifySms, {
+      tenantId,
+      saleReceipt,
+    });
+    // Sends the payment receive sms notification to the given customer.
+    await this.sendSmsNotification(tenantId, saleReceipt);
+
+    // Triggers `onSaleReceiptNotifiedSms` event.
+    await this.eventPublisher.emitAsync(events.saleReceipt.onNotifiedSms, {
+      tenantId,
+      saleReceipt,
+    });
+    return saleReceipt;
+  }
+
+  /**
+   * Sends SMS notification.
+   * @param {ISaleReceipt} invoice
+   * @param {ICustomer} customer
+   * @returns
+   */
+  public sendSmsNotification = async (
+    tenantId: number,
+    saleReceipt: ISaleReceipt & { customer: ICustomer }
+  ) => {
+    const smsClient = this.tenancy.smsClient(tenantId);
+    const tenantMetadata = await TenantMetadata.query().findOne({ tenantId });
+
+    // Retrieve formatted sms notification message of receipt details.
+    const formattedSmsMessage = this.formattedReceiptDetailsMessage(
+      tenantId,
+      saleReceipt,
+      tenantMetadata
+    );
+    const phoneNumber = saleReceipt.customer.personalPhone;
+
+    // Run the send sms notification message job.
+    return smsClient.sendMessageJob(phoneNumber, formattedSmsMessage);
+  };
+
+  /**
+   * Notify via SMS message after receipt creation.
+   * @param {number} tenantId
+   * @param {number} receiptId
+   * @returns {Promise<void>}
+   */
+  public notifyViaSmsAfterCreation = async (
+    tenantId: number,
+    receiptId: number
+  ): Promise<void> => {
+    const notification = this.smsNotificationsSettings.getSmsNotificationMeta(
+      tenantId,
+      SMS_NOTIFICATION_KEY.SALE_RECEIPT_DETAILS
+    );
+    // Can't continue if the sms auto-notification is not enabled.
+    if (!notification.isNotificationEnabled) return;
+
+    await this.notifyBySms(tenantId, receiptId);
+  };
+
+  /**
+   * Retrieve the formatted sms notification message of the given sale receipt.
+   * @param {number} tenantId
+   * @param {ISaleReceipt} saleReceipt
+   * @param {TenantMetadata} tenantMetadata
+   * @returns {string}
+   */
+  private formattedReceiptDetailsMessage = (
+    tenantId: number,
+    saleReceipt: ISaleReceipt & { customer: ICustomer },
+    tenantMetadata: TenantMetadata
+  ): string => {
+    const notification = this.smsNotificationsSettings.getSmsNotificationMeta(
+      tenantId,
+      SMS_NOTIFICATION_KEY.SALE_RECEIPT_DETAILS
+    );
+    return this.formatReceiptDetailsMessage(
+      notification.smsMessage,
+      saleReceipt,
+      tenantMetadata
+    );
+  };
+
+  /**
+   * Formattes the receipt sms notification message.
+   * @param {string} smsMessage
+   * @param {ISaleReceipt} saleReceipt
+   * @param {TenantMetadata} tenantMetadata
+   * @returns {string}
+   */
+  private formatReceiptDetailsMessage = (
+    smsMessage: string,
+    saleReceipt: ISaleReceipt & { customer: ICustomer },
+    tenantMetadata: TenantMetadata
+  ): string => {
+    // Format the receipt amount.
+    const formattedAmount = formatNumber(saleReceipt.amount, {
+      currencyCode: saleReceipt.currencyCode,
+    });
+
+    return formatSmsMessage(smsMessage, {
+      ReceiptNumber: saleReceipt.receiptNumber,
+      ReferenceNumber: saleReceipt.referenceNo,
+      CustomerName: saleReceipt.customer.displayName,
+      Amount: formattedAmount,
+      CompanyName: tenantMetadata.name,
+    });
+  };
+
+  /**
+   * Retrieve the SMS details of the given invoice.
+   * @param {number} tenantId -
+   * @param {number} saleReceiptId - Sale receipt id.
+   */
+  public smsDetails = async (
+    tenantId: number,
+    saleReceiptId: number
+  ): Promise<ISaleReceiptSmsDetails> => {
+    const { SaleReceipt } = this.tenancy.models(tenantId);
+
+    // Retrieve the sale receipt or throw not found service error.
+    const saleReceipt = await SaleReceipt.query()
+      .findById(saleReceiptId)
+      .withGraphFetched('customer');
+
+    // Validates the receipt receipt existance.
+    this.validateSaleReceiptExistance(saleReceipt);
+
+    // Current tenant metadata.
+    const tenantMetadata = await TenantMetadata.query().findOne({ tenantId });
+
+    // Retrieve the sale receipt formatted sms notification message.
+    const formattedSmsMessage = this.formattedReceiptDetailsMessage(
+      tenantId,
+      saleReceipt,
+      tenantMetadata
+    );
+    return {
+      customerName: saleReceipt.customer.displayName,
+      customerPhoneNumber: saleReceipt.customer.personalPhone,
+      smsMessage: formattedSmsMessage,
+    };
+  };
+
+  /**
+   * Validates the receipt receipt existance.
+   * @param {ISaleReceipt|null} saleReceipt
+   */
+  private validateSaleReceiptExistance(saleReceipt: ISaleReceipt | null) {
+    if (!saleReceipt) {
+      throw new ServiceError(ERRORS.SALE_RECEIPT_NOT_FOUND);
+    }
+  }
+}
diff --git a/packages/server/src/services/Sales/SalesEstimate.ts b/packages/server/src/services/Sales/SalesEstimate.ts
new file mode 100644
index 000000000..f367c0f4a
--- /dev/null
+++ b/packages/server/src/services/Sales/SalesEstimate.ts
@@ -0,0 +1,718 @@
+import { omit, sumBy } from 'lodash';
+import { Service, Inject } from 'typedi';
+import * as R from 'ramda';
+import { Knex } from 'knex';
+import {
+  IEstimatesFilter,
+  IFilterMeta,
+  IPaginationMeta,
+  ISaleEstimate,
+  ISaleEstimateApprovedEvent,
+  ISaleEstimateCreatedPayload,
+  ISaleEstimateCreatingPayload,
+  ISaleEstimateDeletedPayload,
+  ISaleEstimateDeletingPayload,
+  ISaleEstimateDTO,
+  ISaleEstimateEditedPayload,
+  ISaleEstimateEditingPayload,
+  ISaleEstimateEventDeliveredPayload,
+  ISaleEstimateEventDeliveringPayload,
+  ISaleEstimateApprovingEvent,
+  ISalesEstimatesService,
+  ICustomer,
+} from '@/interfaces';
+import { formatDateFields } from 'utils';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+import events from '@/subscribers/events';
+import { ServiceError } from '@/exceptions';
+import moment from 'moment';
+import AutoIncrementOrdersService from './AutoIncrementOrdersService';
+import SaleEstimateTransformer from './Estimates/SaleEstimateTransformer';
+import { ERRORS } from './Estimates/constants';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import { WarehouseTransactionDTOTransform } from '@/services/Warehouses/Integrations/WarehouseTransactionDTOTransform';
+import { BranchTransactionDTOTransform } from '@/services/Branches/Integrations/BranchTransactionDTOTransform';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+/**
+ * Sale estimate service.
+ * @Service
+ */
+@Service('SalesEstimates')
+export default class SaleEstimateService implements ISalesEstimatesService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  itemsEntriesService: ItemsEntriesService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  autoIncrementOrdersService: AutoIncrementOrdersService;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  branchDTOTransform: BranchTransactionDTOTransform;
+
+  @Inject()
+  warehouseDTOTransform: WarehouseTransactionDTOTransform;
+
+  @Inject()
+  transformer: TransformerInjectable;
+
+  /**
+   * Retrieve sale estimate or throw service error.
+   * @param {number} tenantId
+   * @return {ISaleEstimate}
+   */
+  async getSaleEstimateOrThrowError(tenantId: number, saleEstimateId: number) {
+    const { SaleEstimate } = this.tenancy.models(tenantId);
+    const foundSaleEstimate = await SaleEstimate.query().findById(
+      saleEstimateId
+    );
+
+    if (!foundSaleEstimate) {
+      throw new ServiceError(ERRORS.SALE_ESTIMATE_NOT_FOUND);
+    }
+    return foundSaleEstimate;
+  }
+
+  /**
+   * Validate the estimate number unique on the storage.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {Function} next
+   */
+  async validateEstimateNumberExistance(
+    tenantId: number,
+    estimateNumber: string,
+    notEstimateId?: number
+  ) {
+    const { SaleEstimate } = this.tenancy.models(tenantId);
+
+    const foundSaleEstimate = await SaleEstimate.query()
+      .findOne('estimate_number', estimateNumber)
+      .onBuild((builder) => {
+        if (notEstimateId) {
+          builder.whereNot('id', notEstimateId);
+        }
+      });
+    if (foundSaleEstimate) {
+      throw new ServiceError(ERRORS.SALE_ESTIMATE_NUMBER_EXISTANCE);
+    }
+  }
+
+  /**
+   * Validates the given sale estimate not already converted to invoice.
+   * @param {ISaleEstimate} saleEstimate -
+   */
+  validateEstimateNotConverted(saleEstimate: ISaleEstimate) {
+    if (saleEstimate.isConvertedToInvoice) {
+      throw new ServiceError(ERRORS.SALE_ESTIMATE_CONVERTED_TO_INVOICE);
+    }
+  }
+
+  /**
+   * Retrieve the next unique estimate number.
+   * @param  {number} tenantId - Tenant id.
+   * @return {string}
+   */
+  getNextEstimateNumber(tenantId: number): string {
+    return this.autoIncrementOrdersService.getNextTransactionNumber(
+      tenantId,
+      'sales_estimates'
+    );
+  }
+
+  /**
+   * Increment the estimate next number.
+   * @param {number} tenantId -
+   */
+  incrementNextEstimateNumber(tenantId: number) {
+    return this.autoIncrementOrdersService.incrementSettingsNextNumber(
+      tenantId,
+      'sales_estimates'
+    );
+  }
+
+  /**
+   * Retrieve estimate number to object model.
+   * @param {number} tenantId
+   * @param {ISaleEstimateDTO} saleEstimateDTO
+   * @param {ISaleEstimate} oldSaleEstimate
+   */
+  transformEstimateNumberToModel(
+    tenantId: number,
+    saleEstimateDTO: ISaleEstimateDTO,
+    oldSaleEstimate?: ISaleEstimate
+  ): string {
+    // Retreive the next invoice number.
+    const autoNextNumber = this.getNextEstimateNumber(tenantId);
+
+    if (saleEstimateDTO.estimateNumber) {
+      return saleEstimateDTO.estimateNumber;
+    }
+    return oldSaleEstimate ? oldSaleEstimate.estimateNumber : autoNextNumber;
+  }
+
+  /**
+   * Transform create DTO object ot model object.
+   * @param  {number} tenantId
+   * @param  {ISaleEstimateDTO} saleEstimateDTO - Sale estimate DTO.
+   * @return {ISaleEstimate}
+   */
+  async transformDTOToModel(
+    tenantId: number,
+    estimateDTO: ISaleEstimateDTO,
+    paymentCustomer: ICustomer,
+    oldSaleEstimate?: ISaleEstimate
+  ): Promise<ISaleEstimate> {
+    const { ItemEntry, Contact } = this.tenancy.models(tenantId);
+
+    const amount = sumBy(estimateDTO.entries, (e) => ItemEntry.calcAmount(e));
+
+    // Retreive the next invoice number.
+    const autoNextNumber = this.getNextEstimateNumber(tenantId);
+
+    // Retreive the next estimate number.
+    const estimateNumber =
+      estimateDTO.estimateNumber ||
+      oldSaleEstimate?.estimateNumber ||
+      autoNextNumber;
+
+    // Validate the sale estimate number require.
+    this.validateEstimateNoRequire(estimateNumber);
+
+    const initialDTO = {
+      amount,
+      ...formatDateFields(omit(estimateDTO, ['delivered', 'entries']), [
+        'estimateDate',
+        'expirationDate',
+      ]),
+      currencyCode: paymentCustomer.currencyCode,
+      exchangeRate: estimateDTO.exchangeRate || 1,
+      ...(estimateNumber ? { estimateNumber } : {}),
+      entries: estimateDTO.entries.map((entry) => ({
+        reference_type: 'SaleEstimate',
+        ...entry,
+      })),
+      // Avoid rewrite the deliver date in edit mode when already published.
+      ...(estimateDTO.delivered &&
+        !oldSaleEstimate?.deliveredAt && {
+          deliveredAt: moment().toMySqlDateTime(),
+        }),
+    };
+    return R.compose(
+      this.branchDTOTransform.transformDTO<ISaleEstimate>(tenantId),
+      this.warehouseDTOTransform.transformDTO<ISaleEstimate>(tenantId)
+    )(initialDTO);
+  }
+
+  /**
+   * Validate the sale estimate number require.
+   * @param {ISaleEstimate} saleInvoiceObj
+   */
+  validateEstimateNoRequire(estimateNumber: string) {
+    if (!estimateNumber) {
+      throw new ServiceError(ERRORS.SALE_ESTIMATE_NO_IS_REQUIRED);
+    }
+  }
+
+  /**
+   * Creates a new estimate with associated entries.
+   * @async
+   * @param {number} tenantId - The tenant id.
+   * @param {EstimateDTO} estimate
+   * @return {Promise<ISaleEstimate>}
+   */
+  public async createEstimate(
+    tenantId: number,
+    estimateDTO: ISaleEstimateDTO
+  ): Promise<ISaleEstimate> {
+    const { SaleEstimate, Contact } = this.tenancy.models(tenantId);
+
+    // Retrieve the given customer or throw not found service error.
+    const customer = await Contact.query()
+      .modify('customer')
+      .findById(estimateDTO.customerId)
+      .throwIfNotFound();
+
+    // Transform DTO object ot model object.
+    const estimateObj = await this.transformDTOToModel(
+      tenantId,
+      estimateDTO,
+      customer
+    );
+    // Validate estimate number uniquiness on the storage.
+    await this.validateEstimateNumberExistance(
+      tenantId,
+      estimateObj.estimateNumber
+    );
+    // Validate items IDs existance on the storage.
+    await this.itemsEntriesService.validateItemsIdsExistance(
+      tenantId,
+      estimateDTO.entries
+    );
+    // Validate non-sellable items.
+    await this.itemsEntriesService.validateNonSellableEntriesItems(
+      tenantId,
+      estimateDTO.entries
+    );
+    // Creates a sale estimate transaction with associated transactions as UOW.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onSaleEstimateCreating` event.
+      await this.eventPublisher.emitAsync(events.saleEstimate.onCreating, {
+        estimateDTO,
+        tenantId,
+        trx,
+      } as ISaleEstimateCreatingPayload);
+
+      // Upsert the sale estimate graph to the storage.
+      const saleEstimate = await SaleEstimate.query(trx).upsertGraphAndFetch({
+        ...estimateObj,
+      });
+      // Triggers `onSaleEstimateCreated` event.
+      await this.eventPublisher.emitAsync(events.saleEstimate.onCreated, {
+        tenantId,
+        saleEstimate,
+        saleEstimateId: saleEstimate.id,
+        saleEstimateDTO: estimateDTO,
+        trx,
+      } as ISaleEstimateCreatedPayload);
+
+      return saleEstimate;
+    });
+  }
+
+  /**
+   * Edit details of the given estimate with associated entries.
+   * @async
+   * @param {number} tenantId - The tenant id.
+   * @param {Integer} estimateId
+   * @param {EstimateDTO} estimate
+   * @return {void}
+   */
+  public async editEstimate(
+    tenantId: number,
+    estimateId: number,
+    estimateDTO: ISaleEstimateDTO
+  ): Promise<ISaleEstimate> {
+    const { SaleEstimate, Contact } = this.tenancy.models(tenantId);
+
+    const oldSaleEstimate = await this.getSaleEstimateOrThrowError(
+      tenantId,
+      estimateId
+    );
+    // Retrieve the given customer or throw not found service error.
+    const customer = await Contact.query()
+      .modify('customer')
+      .findById(estimateDTO.customerId)
+      .throwIfNotFound();
+
+    // Transform DTO object ot model object.
+    const estimateObj = await this.transformDTOToModel(
+      tenantId,
+      estimateDTO,
+      oldSaleEstimate,
+      customer
+    );
+    // Validate estimate number uniquiness on the storage.
+    if (estimateDTO.estimateNumber) {
+      await this.validateEstimateNumberExistance(
+        tenantId,
+        estimateDTO.estimateNumber,
+        estimateId
+      );
+    }
+    // Validate sale estimate entries existance.
+    await this.itemsEntriesService.validateEntriesIdsExistance(
+      tenantId,
+      estimateId,
+      'SaleEstimate',
+      estimateDTO.entries
+    );
+    // Validate items IDs existance on the storage.
+    await this.itemsEntriesService.validateItemsIdsExistance(
+      tenantId,
+      estimateDTO.entries
+    );
+    // Validate non-sellable items.
+    await this.itemsEntriesService.validateNonSellableEntriesItems(
+      tenantId,
+      estimateDTO.entries
+    );
+    // Edits estimate transaction with associated transactions
+    // under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx) => {
+      // Trigger `onSaleEstimateEditing` event.
+      await this.eventPublisher.emitAsync(events.saleEstimate.onEditing, {
+        tenantId,
+        oldSaleEstimate,
+        estimateDTO,
+        trx,
+      } as ISaleEstimateEditingPayload);
+
+      // Upsert the estimate graph to the storage.
+      const saleEstimate = await SaleEstimate.query(trx).upsertGraphAndFetch({
+        id: estimateId,
+        ...estimateObj,
+      });
+      // Trigger `onSaleEstimateEdited` event.
+      await this.eventPublisher.emitAsync(events.saleEstimate.onEdited, {
+        tenantId,
+        estimateId,
+        saleEstimate,
+        oldSaleEstimate,
+        trx,
+      } as ISaleEstimateEditedPayload);
+
+      return saleEstimate;
+    });
+  }
+
+  /**
+   * Deletes the given estimate id with associated entries.
+   * @async
+   * @param {number} tenantId - The tenant id.
+   * @param {IEstimate} estimateId
+   * @return {void}
+   */
+  public async deleteEstimate(
+    tenantId: number,
+    estimateId: number
+  ): Promise<void> {
+    const { SaleEstimate, ItemEntry } = this.tenancy.models(tenantId);
+
+    // Retrieve sale estimate or throw not found service error.
+    const oldSaleEstimate = await this.getSaleEstimateOrThrowError(
+      tenantId,
+      estimateId
+    );
+    // Throw error if the sale estimate converted to sale invoice.
+    if (oldSaleEstimate.convertedToInvoiceId) {
+      throw new ServiceError(ERRORS.SALE_ESTIMATE_CONVERTED_TO_INVOICE);
+    }
+    // Deletes the estimate with associated transactions under UOW enivrement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onSaleEstimatedDeleting` event.
+      await this.eventPublisher.emitAsync(events.saleEstimate.onDeleting, {
+        trx,
+        tenantId,
+        oldSaleEstimate,
+      } as ISaleEstimateDeletingPayload);
+
+      // Delete sale estimate entries.
+      await ItemEntry.query(trx)
+        .where('reference_id', estimateId)
+        .where('reference_type', 'SaleEstimate')
+        .delete();
+
+      // Delete sale estimate transaction.
+      await SaleEstimate.query(trx).where('id', estimateId).delete();
+
+      // Triggers `onSaleEstimatedDeleted` event.
+      await this.eventPublisher.emitAsync(events.saleEstimate.onDeleted, {
+        tenantId,
+        saleEstimateId: estimateId,
+        oldSaleEstimate,
+        trx,
+      } as ISaleEstimateDeletedPayload);
+    });
+  }
+
+  /**
+   * Retrieve the estimate details with associated entries.
+   * @async
+   * @param {number} tenantId - The tenant id.
+   * @param {Integer} estimateId
+   */
+  public async getEstimate(tenantId: number, estimateId: number) {
+    const { SaleEstimate } = this.tenancy.models(tenantId);
+    const estimate = await SaleEstimate.query()
+      .findById(estimateId)
+      .withGraphFetched('entries.item')
+      .withGraphFetched('customer')
+      .withGraphFetched('branch');
+
+    if (!estimate) {
+      throw new ServiceError(ERRORS.SALE_ESTIMATE_NOT_FOUND);
+    }
+    // Transformes sale estimate model to POJO.
+    return this.transformer.transform(
+      tenantId,
+      estimate,
+      new SaleEstimateTransformer()
+    );
+  }
+
+  /**
+   * Parses estimates list filter DTO.
+   * @param filterDTO
+   */
+  private parseListFilterDTO(filterDTO) {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  }
+
+  /**
+   * Retrieves estimates filterable and paginated list.
+   * @param {number} tenantId -
+   * @param {IEstimatesFilter} estimatesFilter -
+   */
+  public async estimatesList(
+    tenantId: number,
+    filterDTO: IEstimatesFilter
+  ): Promise<{
+    salesEstimates: ISaleEstimate[];
+    pagination: IPaginationMeta;
+    filterMeta: IFilterMeta;
+  }> {
+    const { SaleEstimate } = this.tenancy.models(tenantId);
+
+    // Parses filter DTO.
+    const filter = this.parseListFilterDTO(filterDTO);
+
+    // Dynamic list service.
+    const dynamicFilter = await this.dynamicListService.dynamicList(
+      tenantId,
+      SaleEstimate,
+      filter
+    );
+    const { results, pagination } = await SaleEstimate.query()
+      .onBuild((builder) => {
+        builder.withGraphFetched('customer');
+        builder.withGraphFetched('entries');
+        dynamicFilter.buildQuery()(builder);
+      })
+      .pagination(filter.page - 1, filter.pageSize);
+
+    const transformedEstimates = await this.transformer.transform(
+      tenantId,
+      results,
+      new SaleEstimateTransformer()
+    );
+    return {
+      salesEstimates: transformedEstimates,
+      pagination,
+      filterMeta: dynamicFilter.getResponseMeta(),
+    };
+  }
+
+  /**
+   * Converts estimate to invoice.
+   * @param {number} tenantId -
+   * @param {number} estimateId -
+   * @return {Promise<void>}
+   */
+  async convertEstimateToInvoice(
+    tenantId: number,
+    estimateId: number,
+    invoiceId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> {
+    const { SaleEstimate } = this.tenancy.models(tenantId);
+
+    // Retrieve details of the given sale estimate.
+    const saleEstimate = await this.getSaleEstimateOrThrowError(
+      tenantId,
+      estimateId
+    );
+    // Marks the estimate as converted from the givne invoice.
+    await SaleEstimate.query(trx).where('id', estimateId).patch({
+      convertedToInvoiceId: invoiceId,
+      convertedToInvoiceAt: moment().toMySqlDateTime(),
+    });
+    // Triggers `onSaleEstimateConvertedToInvoice` event.
+    await this.eventPublisher.emitAsync(
+      events.saleEstimate.onConvertedToInvoice,
+      {}
+    );
+  }
+
+  /**
+   * Unlink the converted sale estimates from the given sale invoice.
+   * @param {number} tenantId -
+   * @param {number} invoiceId -
+   * @return {Promise<void>}
+   */
+  async unlinkConvertedEstimateFromInvoice(
+    tenantId: number,
+    invoiceId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> {
+    const { SaleEstimate } = this.tenancy.models(tenantId);
+
+    await SaleEstimate.query(trx)
+      .where({
+        convertedToInvoiceId: invoiceId,
+      })
+      .patch({
+        convertedToInvoiceId: null,
+        convertedToInvoiceAt: null,
+      });
+  }
+
+  /**
+   * Mark the sale estimate as delivered.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} saleEstimateId - Sale estimate id.
+   */
+  public async deliverSaleEstimate(
+    tenantId: number,
+    saleEstimateId: number
+  ): Promise<void> {
+    const { SaleEstimate } = this.tenancy.models(tenantId);
+
+    // Retrieve details of the given sale estimate id.
+    const oldSaleEstimate = await this.getSaleEstimateOrThrowError(
+      tenantId,
+      saleEstimateId
+    );
+    // Throws error in case the sale estimate already published.
+    if (oldSaleEstimate.isDelivered) {
+      throw new ServiceError(ERRORS.SALE_ESTIMATE_ALREADY_DELIVERED);
+    }
+    // Updates the sale estimate transaction with assocaited transactions
+    // under UOW envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onSaleEstimateDelivering` event.
+      await this.eventPublisher.emitAsync(events.saleEstimate.onDelivering, {
+        oldSaleEstimate,
+        trx,
+        tenantId,
+      } as ISaleEstimateEventDeliveringPayload);
+
+      // Record the delivered at on the storage.
+      const saleEstimate = await SaleEstimate.query(trx).patchAndFetchById(
+        saleEstimateId,
+        {
+          deliveredAt: moment().toMySqlDateTime(),
+        }
+      );
+      // Triggers `onSaleEstimateDelivered` event.
+      await this.eventPublisher.emitAsync(events.saleEstimate.onDelivered, {
+        tenantId,
+        saleEstimate,
+        trx,
+      } as ISaleEstimateEventDeliveredPayload);
+    });
+  }
+
+  /**
+   * Mark the sale estimate as approved from the customer.
+   * @param {number} tenantId
+   * @param {number} saleEstimateId
+   */
+  public async approveSaleEstimate(
+    tenantId: number,
+    saleEstimateId: number
+  ): Promise<void> {
+    const { SaleEstimate } = this.tenancy.models(tenantId);
+
+    // Retrieve details of the given sale estimate id.
+    const oldSaleEstimate = await this.getSaleEstimateOrThrowError(
+      tenantId,
+      saleEstimateId
+    );
+    // Throws error in case the sale estimate still not delivered to customer.
+    if (!oldSaleEstimate.isDelivered) {
+      throw new ServiceError(ERRORS.SALE_ESTIMATE_NOT_DELIVERED);
+    }
+    // Throws error in case the sale estimate already approved.
+    if (oldSaleEstimate.isApproved) {
+      throw new ServiceError(ERRORS.SALE_ESTIMATE_ALREADY_APPROVED);
+    }
+    // Triggers `onSaleEstimateApproving` event.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onSaleEstimateApproving` event.
+      await this.eventPublisher.emitAsync(events.saleEstimate.onApproving, {
+        trx,
+        tenantId,
+        oldSaleEstimate,
+      } as ISaleEstimateApprovingEvent);
+
+      // Update estimate as approved.
+      const saleEstimate = await SaleEstimate.query(trx)
+        .where('id', saleEstimateId)
+        .patch({
+          approvedAt: moment().toMySqlDateTime(),
+          rejectedAt: null,
+        });
+      // Triggers `onSaleEstimateApproved` event.
+      await this.eventPublisher.emitAsync(events.saleEstimate.onApproved, {
+        trx,
+        tenantId,
+        oldSaleEstimate,
+        saleEstimate,
+      } as ISaleEstimateApprovedEvent);
+    });
+  }
+
+  /**
+   * Mark the sale estimate as rejected from the customer.
+   * @param {number} tenantId
+   * @param {number} saleEstimateId
+   */
+  public async rejectSaleEstimate(
+    tenantId: number,
+    saleEstimateId: number
+  ): Promise<void> {
+    const { SaleEstimate } = this.tenancy.models(tenantId);
+
+    // Retrieve details of the given sale estimate id.
+    const saleEstimate = await this.getSaleEstimateOrThrowError(
+      tenantId,
+      saleEstimateId
+    );
+    // Throws error in case the sale estimate still not delivered to customer.
+    if (!saleEstimate.isDelivered) {
+      throw new ServiceError(ERRORS.SALE_ESTIMATE_NOT_DELIVERED);
+    }
+    // Throws error in case the sale estimate already rejected.
+    if (saleEstimate.isRejected) {
+      throw new ServiceError(ERRORS.SALE_ESTIMATE_ALREADY_REJECTED);
+    }
+    //
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Mark the sale estimate as reject on the storage.
+      await SaleEstimate.query(trx).where('id', saleEstimateId).patch({
+        rejectedAt: moment().toMySqlDateTime(),
+        approvedAt: null,
+      });
+      // Triggers `onSaleEstimateRejected` event.
+      await this.eventPublisher.emitAsync(events.saleEstimate.onRejected, {});
+    });
+  }
+
+  /**
+   * Validate the given customer has no sales estimates.
+   * @param {number} tenantId
+   * @param {number} customerId - Customer id.
+   */
+  public async validateCustomerHasNoEstimates(
+    tenantId: number,
+    customerId: number
+  ) {
+    const { SaleEstimate } = this.tenancy.models(tenantId);
+
+    const estimates = await SaleEstimate.query().where(
+      'customer_id',
+      customerId
+    );
+    if (estimates.length > 0) {
+      throw new ServiceError(ERRORS.CUSTOMER_HAS_SALES_ESTIMATES);
+    }
+  }
+}
diff --git a/packages/server/src/services/Sales/SalesInvoices.ts b/packages/server/src/services/Sales/SalesInvoices.ts
new file mode 100644
index 000000000..6c7c42632
--- /dev/null
+++ b/packages/server/src/services/Sales/SalesInvoices.ts
@@ -0,0 +1,799 @@
+import { Service, Inject } from 'typedi';
+import { omit, sumBy } from 'lodash';
+import * as R from 'ramda';
+import moment from 'moment';
+import { Knex } from 'knex';
+import composeAsync from 'async/compose';
+import {
+  ISaleInvoice,
+  ISaleInvoiceCreateDTO,
+  ISaleInvoiceEditDTO,
+  ISalesInvoicesFilter,
+  IPaginationMeta,
+  IFilterMeta,
+  ISystemUser,
+  ISalesInvoicesService,
+  ISaleInvoiceCreatedPayload,
+  ISaleInvoiceDeletePayload,
+  ISaleInvoiceDeletedPayload,
+  ISaleInvoiceEventDeliveredPayload,
+  ISaleInvoiceEditedPayload,
+  ISaleInvoiceCreatingPaylaod,
+  ISaleInvoiceEditingPayload,
+  ISaleInvoiceDeliveringPayload,
+  ICustomer,
+  ITenantUser,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import InventoryService from '@/services/Inventory/Inventory';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import { formatDateFields } from 'utils';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { ServiceError } from '@/exceptions';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+import SaleEstimateService from '@/services/Sales/SalesEstimate';
+import AutoIncrementOrdersService from './AutoIncrementOrdersService';
+import { ERRORS } from './constants';
+import { SaleInvoiceTransformer } from './SaleInvoiceTransformer';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import { BranchTransactionDTOTransform } from '@/services/Branches/Integrations/BranchTransactionDTOTransform';
+import { WarehouseTransactionDTOTransform } from '@/services/Warehouses/Integrations/WarehouseTransactionDTOTransform';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+/**
+ * Sales invoices service
+ * @service
+ */
+@Service('SalesInvoices')
+export default class SaleInvoicesService implements ISalesInvoicesService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  inventoryService: InventoryService;
+
+  @Inject()
+  itemsEntriesService: ItemsEntriesService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  @Inject()
+  private saleEstimatesService: SaleEstimateService;
+
+  @Inject()
+  private autoIncrementOrdersService: AutoIncrementOrdersService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private branchDTOTransform: BranchTransactionDTOTransform;
+
+  @Inject()
+  private warehouseDTOTransform: WarehouseTransactionDTOTransform;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Validate whether sale invoice number unqiue on the storage.
+   */
+  async validateInvoiceNumberUnique(
+    tenantId: number,
+    invoiceNumber: string,
+    notInvoiceId?: number
+  ) {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    const saleInvoice = await SaleInvoice.query()
+      .findOne('invoice_no', invoiceNumber)
+      .onBuild((builder) => {
+        if (notInvoiceId) {
+          builder.whereNot('id', notInvoiceId);
+        }
+      });
+
+    if (saleInvoice) {
+      throw new ServiceError(ERRORS.INVOICE_NUMBER_NOT_UNIQUE);
+    }
+  }
+
+  /**
+   * Validate the sale invoice has no payment entries.
+   * @param {number} tenantId
+   * @param {number} saleInvoiceId
+   */
+  async validateInvoiceHasNoPaymentEntries(
+    tenantId: number,
+    saleInvoiceId: number
+  ) {
+    const { PaymentReceiveEntry } = this.tenancy.models(tenantId);
+
+    // Retrieve the sale invoice associated payment receive entries.
+    const entries = await PaymentReceiveEntry.query().where(
+      'invoice_id',
+      saleInvoiceId
+    );
+    if (entries.length > 0) {
+      throw new ServiceError(ERRORS.INVOICE_HAS_ASSOCIATED_PAYMENT_ENTRIES);
+    }
+    return entries;
+  }
+
+  /**
+   * Validate the invoice amount is bigger than payment amount before edit the invoice.
+   * @param {number} saleInvoiceAmount
+   * @param {number} paymentAmount
+   */
+  validateInvoiceAmountBiggerPaymentAmount(
+    saleInvoiceAmount: number,
+    paymentAmount: number
+  ) {
+    if (saleInvoiceAmount < paymentAmount) {
+      throw new ServiceError(ERRORS.INVOICE_AMOUNT_SMALLER_THAN_PAYMENT_AMOUNT);
+    }
+  }
+
+  /**
+   * Validate whether sale invoice exists on the storage.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {Function} next
+   */
+  async getInvoiceOrThrowError(tenantId: number, saleInvoiceId: number) {
+    const { saleInvoiceRepository } = this.tenancy.repositories(tenantId);
+
+    const saleInvoice = await saleInvoiceRepository.findOneById(
+      saleInvoiceId,
+      'entries'
+    );
+    if (!saleInvoice) {
+      throw new ServiceError(ERRORS.SALE_INVOICE_NOT_FOUND);
+    }
+    return saleInvoice;
+  }
+
+  /**
+   * Retrieve the next unique invoice number.
+   * @param  {number} tenantId - Tenant id.
+   * @return {string}
+   */
+  getNextInvoiceNumber(tenantId: number): string {
+    return this.autoIncrementOrdersService.getNextTransactionNumber(
+      tenantId,
+      'sales_invoices'
+    );
+  }
+
+  /**
+   * Increment the invoice next number.
+   * @param {number} tenantId -
+   */
+  incrementNextInvoiceNumber(tenantId: number) {
+    return this.autoIncrementOrdersService.incrementSettingsNextNumber(
+      tenantId,
+      'sales_invoices'
+    );
+  }
+
+  /**
+   * Transformes edit DTO to model.
+   * @param {number} tennatId -
+   * @param {ICustomer} customer -
+   * @param {ISaleInvoiceEditDTO} saleInvoiceDTO -
+   * @param {ISaleInvoice} oldSaleInvoice
+   */
+  private tranformEditDTOToModel = async (
+    tenantId: number,
+    customer: ICustomer,
+    saleInvoiceDTO: ISaleInvoiceEditDTO,
+    oldSaleInvoice: ISaleInvoice,
+    authorizedUser: ITenantUser
+  ) => {
+    return this.transformDTOToModel(
+      tenantId,
+      customer,
+      saleInvoiceDTO,
+      authorizedUser,
+      oldSaleInvoice
+    );
+  };
+
+  /**
+   * Transformes create DTO to model.
+   * @param {number} tenantId -
+   * @param {ICustomer} customer -
+   * @param {ISaleInvoiceCreateDTO} saleInvoiceDTO -
+   */
+  private transformCreateDTOToModel = async (
+    tenantId: number,
+    customer: ICustomer,
+    saleInvoiceDTO: ISaleInvoiceCreateDTO,
+    authorizedUser: ITenantUser
+  ) => {
+    return this.transformDTOToModel(
+      tenantId,
+      customer,
+      saleInvoiceDTO,
+      authorizedUser
+    );
+  };
+
+  /**
+   * Transformes the create DTO to invoice object model.
+   * @param  {ISaleInvoiceCreateDTO} saleInvoiceDTO - Sale invoice DTO.
+   * @param  {ISaleInvoice} oldSaleInvoice - Old sale invoice.
+   * @return {ISaleInvoice}
+   */
+  private async transformDTOToModel(
+    tenantId: number,
+    customer: ICustomer,
+    saleInvoiceDTO: ISaleInvoiceCreateDTO | ISaleInvoiceEditDTO,
+    authorizedUser: ITenantUser,
+    oldSaleInvoice?: ISaleInvoice
+  ): Promise<ISaleInvoice> {
+    const { ItemEntry } = this.tenancy.models(tenantId);
+
+    const balance = sumBy(saleInvoiceDTO.entries, (e) =>
+      ItemEntry.calcAmount(e)
+    );
+    // Retreive the next invoice number.
+    const autoNextNumber = this.getNextInvoiceNumber(tenantId);
+
+    // Invoice number.
+    const invoiceNo =
+      saleInvoiceDTO.invoiceNo || oldSaleInvoice?.invoiceNo || autoNextNumber;
+
+    // Validate the invoice is required.
+    this.validateInvoiceNoRequire(invoiceNo);
+
+    const initialEntries = saleInvoiceDTO.entries.map((entry) => ({
+      referenceType: 'SaleInvoice',
+      ...entry,
+    }));
+    const entries = await composeAsync(
+      // Sets default cost and sell account to invoice items entries.
+      this.itemsEntriesService.setItemsEntriesDefaultAccounts(tenantId)
+    )(initialEntries);
+
+    const initialDTO = {
+      ...formatDateFields(
+        omit(saleInvoiceDTO, ['delivered', 'entries', 'fromEstimateId']),
+        ['invoiceDate', 'dueDate']
+      ),
+      // Avoid rewrite the deliver date in edit mode when already published.
+      balance,
+      currencyCode: customer.currencyCode,
+      exchangeRate: saleInvoiceDTO.exchangeRate || 1,
+      ...(saleInvoiceDTO.delivered &&
+        !oldSaleInvoice?.deliveredAt && {
+          deliveredAt: moment().toMySqlDateTime(),
+        }),
+      // Avoid override payment amount in edit mode.
+      ...(!oldSaleInvoice && { paymentAmount: 0 }),
+      ...(invoiceNo ? { invoiceNo } : {}),
+      entries,
+      userId: authorizedUser.id,
+    } as ISaleInvoice;
+
+    return R.compose(
+      this.branchDTOTransform.transformDTO<ISaleInvoice>(tenantId),
+      this.warehouseDTOTransform.transformDTO<ISaleInvoice>(tenantId)
+    )(initialDTO);
+  }
+
+  /**
+   * Validate the invoice number require.
+   * @param {ISaleInvoice} saleInvoiceObj
+   */
+  validateInvoiceNoRequire(invoiceNo: string) {
+    if (!invoiceNo) {
+      throw new ServiceError(ERRORS.SALE_INVOICE_NO_IS_REQUIRED);
+    }
+  }
+
+  /**
+   * Creates a new sale invoices and store it to the storage
+   * with associated to entries and journal transactions.
+   * @async
+   * @param  {number} tenantId - Tenant id.
+   * @param  {ISaleInvoice} saleInvoiceDTO - Sale invoice object DTO.
+   * @return {Promise<ISaleInvoice>}
+   */
+  public createSaleInvoice = async (
+    tenantId: number,
+    saleInvoiceDTO: ISaleInvoiceCreateDTO,
+    authorizedUser: ITenantUser
+  ): Promise<ISaleInvoice> => {
+    const { SaleInvoice, Contact } = this.tenancy.models(tenantId);
+
+    // Validate customer existance.
+    const customer = await Contact.query()
+      .modify('customer')
+      .findById(saleInvoiceDTO.customerId)
+      .throwIfNotFound();
+
+    // Validate the from estimate id exists on the storage.
+    if (saleInvoiceDTO.fromEstimateId) {
+      const fromEstimate =
+        await this.saleEstimatesService.getSaleEstimateOrThrowError(
+          tenantId,
+          saleInvoiceDTO.fromEstimateId
+        );
+      // Validate the sale estimate is not already converted to invoice.
+      this.saleEstimatesService.validateEstimateNotConverted(fromEstimate);
+    }
+    // Validate items ids existance.
+    await this.itemsEntriesService.validateItemsIdsExistance(
+      tenantId,
+      saleInvoiceDTO.entries
+    );
+    // Validate items should be sellable items.
+    await this.itemsEntriesService.validateNonSellableEntriesItems(
+      tenantId,
+      saleInvoiceDTO.entries
+    );
+    // Transform DTO object to model object.
+    const saleInvoiceObj = await this.transformCreateDTOToModel(
+      tenantId,
+      customer,
+      saleInvoiceDTO,
+      authorizedUser
+    );
+    // Validate sale invoice number uniquiness.
+    if (saleInvoiceObj.invoiceNo) {
+      await this.validateInvoiceNumberUnique(
+        tenantId,
+        saleInvoiceObj.invoiceNo
+      );
+    }
+    // Creates a new sale invoice and associated transactions under unit of work env.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onSaleInvoiceCreating` event.
+      await this.eventPublisher.emitAsync(events.saleInvoice.onCreating, {
+        saleInvoiceDTO,
+        tenantId,
+        trx,
+      } as ISaleInvoiceCreatingPaylaod);
+
+      // Create sale invoice graph to the storage.
+      const saleInvoice = await SaleInvoice.query(trx).upsertGraph(
+        saleInvoiceObj
+      );
+      const eventPayload: ISaleInvoiceCreatedPayload = {
+        tenantId,
+        saleInvoice,
+        saleInvoiceDTO,
+        saleInvoiceId: saleInvoice.id,
+        authorizedUser,
+        trx,
+      };
+      // Triggers the event `onSaleInvoiceCreated`.
+      await this.eventPublisher.emitAsync(
+        events.saleInvoice.onCreated,
+        eventPayload
+      );
+      return saleInvoice;
+    });
+  };
+
+  /**
+   * Edit the given sale invoice.
+   * @async
+   * @param {number} tenantId - Tenant id.
+   * @param {Number} saleInvoiceId - Sale invoice id.
+   * @param {ISaleInvoice} saleInvoice - Sale invoice DTO object.
+   * @return {Promise<ISaleInvoice>}
+   */
+  public async editSaleInvoice(
+    tenantId: number,
+    saleInvoiceId: number,
+    saleInvoiceDTO: ISaleInvoiceEditDTO,
+    authorizedUser: ISystemUser
+  ): Promise<ISaleInvoice> {
+    const { SaleInvoice, Contact } = this.tenancy.models(tenantId);
+
+    // Retrieve the sale invoice or throw not found service error.
+    const oldSaleInvoice = await this.getInvoiceOrThrowError(
+      tenantId,
+      saleInvoiceId
+    );
+    // Validate customer existance.
+    const customer = await Contact.query()
+      .findById(saleInvoiceDTO.customerId)
+      .modify('customer')
+      .throwIfNotFound();
+
+    // Validate items ids existance.
+    await this.itemsEntriesService.validateItemsIdsExistance(
+      tenantId,
+      saleInvoiceDTO.entries
+    );
+    // Validate non-sellable entries items.
+    await this.itemsEntriesService.validateNonSellableEntriesItems(
+      tenantId,
+      saleInvoiceDTO.entries
+    );
+    // Validate the items entries existance.
+    await this.itemsEntriesService.validateEntriesIdsExistance(
+      tenantId,
+      saleInvoiceId,
+      'SaleInvoice',
+      saleInvoiceDTO.entries
+    );
+    // Transform DTO object to model object.
+    const saleInvoiceObj = await this.tranformEditDTOToModel(
+      tenantId,
+      customer,
+      saleInvoiceDTO,
+      oldSaleInvoice,
+      authorizedUser
+    );
+    // Validate sale invoice number uniquiness.
+    if (saleInvoiceObj.invoiceNo) {
+      await this.validateInvoiceNumberUnique(
+        tenantId,
+        saleInvoiceObj.invoiceNo,
+        saleInvoiceId
+      );
+    }
+    // Validate the invoice amount is not smaller than the invoice payment amount.
+    this.validateInvoiceAmountBiggerPaymentAmount(
+      saleInvoiceObj.balance,
+      oldSaleInvoice.paymentAmount
+    );
+    // Edit sale invoice transaction in UOW envirment.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onSaleInvoiceEditing` event.
+      await this.eventPublisher.emitAsync(events.saleInvoice.onEditing, {
+        trx,
+        oldSaleInvoice,
+        tenantId,
+        saleInvoiceDTO,
+      } as ISaleInvoiceEditingPayload);
+
+      // Upsert the the invoice graph to the storage.
+      const saleInvoice: ISaleInvoice =
+        await SaleInvoice.query().upsertGraphAndFetch({
+          id: saleInvoiceId,
+          ...saleInvoiceObj,
+        });
+      // Edit event payload.
+      const editEventPayload: ISaleInvoiceEditedPayload = {
+        tenantId,
+        saleInvoiceId,
+        saleInvoice,
+        saleInvoiceDTO,
+        oldSaleInvoice,
+        authorizedUser,
+        trx,
+      };
+      // Triggers `onSaleInvoiceEdited` event.
+      await this.eventPublisher.emitAsync(
+        events.saleInvoice.onEdited,
+        editEventPayload
+      );
+      return saleInvoice;
+    });
+  }
+
+  /**
+   * Deliver the given sale invoice.
+   * @param  {number} tenantId - Tenant id.
+   * @param  {number} saleInvoiceId - Sale invoice id.
+   * @return {Promise<void>}
+   */
+  public async deliverSaleInvoice(
+    tenantId: number,
+    saleInvoiceId: number,
+    authorizedUser: ISystemUser
+  ): Promise<void> {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    // Retrieve details of the given sale invoice id.
+    const oldSaleInvoice = await this.getInvoiceOrThrowError(
+      tenantId,
+      saleInvoiceId
+    );
+    // Throws error in case the sale invoice already published.
+    if (oldSaleInvoice.isDelivered) {
+      throw new ServiceError(ERRORS.SALE_INVOICE_ALREADY_DELIVERED);
+    }
+    // Update sale invoice transaction with assocaite transactions
+    // under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onSaleInvoiceDelivering` event.
+      await this.eventPublisher.emitAsync(events.saleInvoice.onDelivering, {
+        tenantId,
+        oldSaleInvoice,
+        trx,
+      } as ISaleInvoiceDeliveringPayload);
+
+      // Record the delivered at on the storage.
+      const saleInvoice = await SaleInvoice.query(trx)
+        .where({ id: saleInvoiceId })
+        .update({ deliveredAt: moment().toMySqlDateTime() });
+
+      // Triggers `onSaleInvoiceDelivered` event.
+      await this.eventPublisher.emitAsync(events.saleInvoice.onDelivered, {
+        tenantId,
+        saleInvoiceId,
+        saleInvoice,
+      } as ISaleInvoiceEventDeliveredPayload);
+    });
+  }
+
+  /**
+   * Deletes the given sale invoice with associated entries
+   * and journal transactions.
+   * @param {number} tenantId - Tenant id.
+   * @param {Number} saleInvoiceId - The given sale invoice id.
+   * @param {ISystemUser} authorizedUser -
+   */
+  public async deleteSaleInvoice(
+    tenantId: number,
+    saleInvoiceId: number,
+    authorizedUser: ISystemUser
+  ): Promise<void> {
+    const { ItemEntry, SaleInvoice } = this.tenancy.models(tenantId);
+
+    // Retrieve the given sale invoice with associated entries
+    // or throw not found error.
+    const oldSaleInvoice = await this.getInvoiceOrThrowError(
+      tenantId,
+      saleInvoiceId
+    );
+    // Validate the sale invoice has no associated payment entries.
+    await this.validateInvoiceHasNoPaymentEntries(tenantId, saleInvoiceId);
+
+    // Validate the sale invoice has applied to credit note transaction.
+    await this.validateInvoiceHasNoAppliedToCredit(tenantId, saleInvoiceId);
+
+    // Deletes sale invoice transaction and associate transactions with UOW env.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onSaleInvoiceDelete` event.
+      await this.eventPublisher.emitAsync(events.saleInvoice.onDeleting, {
+        tenantId,
+        saleInvoice: oldSaleInvoice,
+        saleInvoiceId,
+        trx,
+      } as ISaleInvoiceDeletePayload);
+
+      // Unlink the converted sale estimates from the given sale invoice.
+      await this.saleEstimatesService.unlinkConvertedEstimateFromInvoice(
+        tenantId,
+        saleInvoiceId,
+        trx
+      );
+      await ItemEntry.query(trx)
+        .where('reference_id', saleInvoiceId)
+        .where('reference_type', 'SaleInvoice')
+        .delete();
+
+      await SaleInvoice.query(trx).findById(saleInvoiceId).delete();
+
+      // Triggers `onSaleInvoiceDeleted` event.
+      await this.eventPublisher.emitAsync(events.saleInvoice.onDeleted, {
+        tenantId,
+        oldSaleInvoice,
+        saleInvoiceId,
+        authorizedUser,
+        trx,
+      } as ISaleInvoiceDeletedPayload);
+    });
+  }
+
+  /**
+   * Records the inventory transactions of the given sale invoice in case
+   * the invoice has inventory entries only.
+   *
+   * @param {number} tenantId - Tenant id.
+   * @param {SaleInvoice} saleInvoice - Sale invoice DTO.
+   * @param {number} saleInvoiceId - Sale invoice id.
+   * @param {boolean} override - Allow to override old transactions.
+   * @return {Promise<void>}
+   */
+  public async recordInventoryTranscactions(
+    tenantId: number,
+    saleInvoice: ISaleInvoice,
+    override?: boolean,
+    trx?: Knex.Transaction
+  ): Promise<void> {
+    // Loads the inventory items entries of the given sale invoice.
+    const inventoryEntries =
+      await this.itemsEntriesService.filterInventoryEntries(
+        tenantId,
+        saleInvoice.entries
+      );
+    const transaction = {
+      transactionId: saleInvoice.id,
+      transactionType: 'SaleInvoice',
+      transactionNumber: saleInvoice.invoiceNo,
+
+      exchangeRate: saleInvoice.exchangeRate,
+      warehouseId: saleInvoice.warehouseId,
+
+      date: saleInvoice.invoiceDate,
+      direction: 'OUT',
+      entries: inventoryEntries,
+      createdAt: saleInvoice.createdAt,
+    };
+    await this.inventoryService.recordInventoryTransactionsFromItemsEntries(
+      tenantId,
+      transaction,
+      override,
+      trx
+    );
+  }
+  /**
+   * Reverting the inventory transactions once the invoice deleted.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} billId - Bill id.
+   * @return {Promise<void>}
+   */
+  public async revertInventoryTransactions(
+    tenantId: number,
+    saleInvoiceId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> {
+    // Delete the inventory transaction of the given sale invoice.
+    const { oldInventoryTransactions } =
+      await this.inventoryService.deleteInventoryTransactions(
+        tenantId,
+        saleInvoiceId,
+        'SaleInvoice',
+        trx
+      );
+  }
+
+  /**
+   * Retrieve sale invoice with associated entries.
+   * @param {Number} saleInvoiceId -
+   * @param {ISystemUser} authorizedUser -
+   * @return {Promise<ISaleInvoice>}
+   */
+  public async getSaleInvoice(
+    tenantId: number,
+    saleInvoiceId: number,
+    authorizedUser: ISystemUser
+  ): Promise<ISaleInvoice> {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    const saleInvoice = await SaleInvoice.query()
+      .findById(saleInvoiceId)
+      .withGraphFetched('entries.item')
+      .withGraphFetched('customer')
+      .withGraphFetched('branch');
+
+    return this.transformer.transform(
+      tenantId,
+      saleInvoice,
+      new SaleInvoiceTransformer()
+    );
+  }
+
+  /**
+   * Parses the sale invoice list filter DTO.
+   * @param filterDTO
+   * @returns
+   */
+  private parseListFilterDTO(filterDTO) {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  }
+
+  /**
+   * Retrieve sales invoices filterable and paginated list.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public async salesInvoicesList(
+    tenantId: number,
+    filterDTO: ISalesInvoicesFilter
+  ): Promise<{
+    salesInvoices: ISaleInvoice[];
+    pagination: IPaginationMeta;
+    filterMeta: IFilterMeta;
+  }> {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    // Parses stringified filter roles.
+    const filter = this.parseListFilterDTO(filterDTO);
+
+    // Dynamic list service.
+    const dynamicFilter = await this.dynamicListService.dynamicList(
+      tenantId,
+      SaleInvoice,
+      filter
+    );
+    const { results, pagination } = await SaleInvoice.query()
+      .onBuild((builder) => {
+        builder.withGraphFetched('entries');
+        builder.withGraphFetched('customer');
+        dynamicFilter.buildQuery()(builder);
+      })
+      .pagination(filter.page - 1, filter.pageSize);
+
+    // Retrieves the transformed sale invoices.
+    const salesInvoices = await this.transformer.transform(
+      tenantId,
+      results,
+      new SaleInvoiceTransformer()
+    );
+
+    return {
+      salesInvoices,
+      pagination,
+      filterMeta: dynamicFilter.getResponseMeta(),
+    };
+  }
+
+  /**
+   * Retrieve due sales invoices.
+   * @param {number} tenantId
+   * @param {number} customerId
+   */
+  public async getPayableInvoices(
+    tenantId: number,
+    customerId?: number
+  ): Promise<ISaleInvoice> {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    const salesInvoices = await SaleInvoice.query().onBuild((query) => {
+      query.modify('dueInvoices');
+      query.modify('delivered');
+
+      if (customerId) {
+        query.where('customer_id', customerId);
+      }
+    });
+    return salesInvoices;
+  }
+
+  /**
+   * Validate the given customer has no sales invoices.
+   * @param {number} tenantId
+   * @param {number} customerId - Customer id.
+   */
+  public async validateCustomerHasNoInvoices(
+    tenantId: number,
+    customerId: number
+  ) {
+    const { SaleInvoice } = this.tenancy.models(tenantId);
+
+    const invoices = await SaleInvoice.query().where('customer_id', customerId);
+
+    if (invoices.length > 0) {
+      throw new ServiceError(ERRORS.CUSTOMER_HAS_SALES_INVOICES);
+    }
+  }
+
+  /**
+   * Validate the sale invoice has no applied to credit note transaction.
+   * @param {number} tenantId
+   * @param {number} invoiceId
+   * @returns {Promise<void>}
+   */
+  public validateInvoiceHasNoAppliedToCredit = async (
+    tenantId: number,
+    invoiceId: number
+  ): Promise<void> => {
+    const { CreditNoteAppliedInvoice } = this.tenancy.models(tenantId);
+
+    const appliedTransactions = await CreditNoteAppliedInvoice.query().where(
+      'invoiceId',
+      invoiceId
+    );
+    if (appliedTransactions.length > 0) {
+      throw new ServiceError(ERRORS.SALE_INVOICE_HAS_APPLIED_TO_CREDIT_NOTES);
+    }
+  };
+}
diff --git a/packages/server/src/services/Sales/SalesInvoicesCost.ts b/packages/server/src/services/Sales/SalesInvoicesCost.ts
new file mode 100644
index 000000000..8dcfe9977
--- /dev/null
+++ b/packages/server/src/services/Sales/SalesInvoicesCost.ts
@@ -0,0 +1,151 @@
+import { Container, Service, Inject } from 'typedi';
+import { chain } from 'lodash';
+import moment from 'moment';
+import { Knex } from 'knex';
+import InventoryService from '@/services/Inventory/Inventory';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import {
+  IInventoryCostLotsGLEntriesWriteEvent,
+  IInventoryTransaction,
+} from '@/interfaces';
+import UnitOfWork from '@/services/UnitOfWork';
+import { SaleInvoiceCostGLEntries } from './Invoices/SaleInvoiceCostGLEntries';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+
+@Service()
+export default class SaleInvoicesCost {
+  @Inject()
+  private inventoryService: InventoryService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private costGLEntries: SaleInvoiceCostGLEntries;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Schedule sale invoice re-compute based on the item
+   * cost method and starting date.
+   * @param {number[]} itemIds - Inventory items ids.
+   * @param {Date} startingDate - Starting compute cost date.
+   * @return {Promise<Agenda>}
+   */
+  async scheduleComputeCostByItemsIds(
+    tenantId: number,
+    inventoryItemsIds: number[],
+    startingDate: Date
+  ): Promise<void> {
+    const asyncOpers: Promise<[]>[] = [];
+
+    inventoryItemsIds.forEach((inventoryItemId: number) => {
+      const oper: Promise<[]> = this.inventoryService.scheduleComputeItemCost(
+        tenantId,
+        inventoryItemId,
+        startingDate
+      );
+      asyncOpers.push(oper);
+    });
+    await Promise.all([...asyncOpers]);
+  }
+
+  /**
+   * Retrieve the max dated inventory transactions in the transactions that
+   * have the same item id.
+   * @param {IInventoryTransaction[]} inventoryTransactions
+   * @return {IInventoryTransaction[]}
+   */
+  getMaxDateInventoryTransactions(
+    inventoryTransactions: IInventoryTransaction[]
+  ): IInventoryTransaction[] {
+    return chain(inventoryTransactions)
+      .reduce((acc: any, transaction) => {
+        const compatatorDate = acc[transaction.itemId];
+
+        if (
+          !compatatorDate ||
+          moment(compatatorDate.date).isBefore(transaction.date)
+        ) {
+          return {
+            ...acc,
+            [transaction.itemId]: {
+              ...transaction,
+            },
+          };
+        }
+        return acc;
+      }, {})
+      .values()
+      .value();
+  }
+
+  /**
+   * Computes items costs by the given inventory transaction.
+   * @param {number} tenantId
+   * @param {IInventoryTransaction[]} inventoryTransactions
+   */
+  async computeItemsCostByInventoryTransactions(
+    tenantId: number,
+    inventoryTransactions: IInventoryTransaction[]
+  ) {
+    const asyncOpers: Promise<[]>[] = [];
+    const reducedTransactions = this.getMaxDateInventoryTransactions(
+      inventoryTransactions
+    );
+    reducedTransactions.forEach((transaction) => {
+      const oper: Promise<[]> = this.inventoryService.scheduleComputeItemCost(
+        tenantId,
+        transaction.itemId,
+        transaction.date
+      );
+      asyncOpers.push(oper);
+    });
+    await Promise.all([...asyncOpers]);
+  }
+
+  /**
+   * Schedule writing journal entries.
+   * @param {Date} startingDate
+   * @return {Promise<agenda>}
+   */
+  scheduleWriteJournalEntries(tenantId: number, startingDate?: Date) {
+    const agenda = Container.get('agenda');
+
+    return agenda.schedule('in 3 seconds', 'rewrite-invoices-journal-entries', {
+      startingDate,
+      tenantId,
+    });
+  }
+
+  /**
+   * Writes cost GL entries from the inventory cost lots.
+   * @param   {number} tenantId -
+   * @param   {Date} startingDate -
+   * @returns {Promise<void>}
+   */
+  public writeCostLotsGLEntries = (tenantId: number, startingDate: Date) => {
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers event `onInventoryCostLotsGLEntriesBeforeWrite`.
+      await this.eventPublisher.emitAsync(
+        events.inventory.onCostLotsGLEntriesBeforeWrite,
+        {
+          tenantId,
+          startingDate,
+          trx,
+        } as IInventoryCostLotsGLEntriesWriteEvent
+      );
+      // Triggers event `onInventoryCostLotsGLEntriesWrite`.
+      await this.eventPublisher.emitAsync(
+        events.inventory.onCostLotsGLEntriesWrite,
+        {
+          tenantId,
+          startingDate,
+          trx,
+        } as IInventoryCostLotsGLEntriesWriteEvent
+      );
+    });
+  };
+}
diff --git a/packages/server/src/services/Sales/SalesReceipts.ts b/packages/server/src/services/Sales/SalesReceipts.ts
new file mode 100644
index 000000000..a2df05fd7
--- /dev/null
+++ b/packages/server/src/services/Sales/SalesReceipts.ts
@@ -0,0 +1,629 @@
+import { omit, sumBy } from 'lodash';
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import * as R from 'ramda';
+import { Knex } from 'knex';
+import composeAsync from 'async/compose';
+import events from '@/subscribers/events';
+import {
+  IFilterMeta,
+  IPaginationMeta,
+  ISaleReceipt,
+  ISaleReceiptDTO,
+  ISalesReceiptsService,
+  ISaleReceiptCreatedPayload,
+  ISaleReceiptEditedPayload,
+  ISaleReceiptEventClosedPayload,
+  ISaleReceiptEventDeletedPayload,
+  ISaleReceiptCreatingPayload,
+  ISaleReceiptDeletingPayload,
+  ISaleReceiptEditingPayload,
+  ISaleReceiptEventClosingPayload,
+  ICustomer,
+} from '@/interfaces';
+import JournalPosterService from '@/services/Sales/JournalPosterService';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import { formatDateFields } from 'utils';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { ServiceError } from '@/exceptions';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+import { ItemEntry } from 'models';
+import InventoryService from '@/services/Inventory/Inventory';
+import { ACCOUNT_PARENT_TYPE } from '@/data/AccountTypes';
+import AutoIncrementOrdersService from './AutoIncrementOrdersService';
+import { ERRORS } from './Receipts/constants';
+import { SaleReceiptTransformer } from './Receipts/SaleReceiptTransformer';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import { WarehouseTransactionDTOTransform } from '@/services/Warehouses/Integrations/WarehouseTransactionDTOTransform';
+import { BranchTransactionDTOTransform } from '@/services/Branches/Integrations/BranchTransactionDTOTransform';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service('SalesReceipts')
+export default class SalesReceiptService implements ISalesReceiptsService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  dynamicListService: DynamicListingService;
+
+  @Inject()
+  journalService: JournalPosterService;
+
+  @Inject()
+  itemsEntriesService: ItemsEntriesService;
+
+  @Inject()
+  inventoryService: InventoryService;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  autoIncrementOrdersService: AutoIncrementOrdersService;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  branchDTOTransform: BranchTransactionDTOTransform;
+
+  @Inject()
+  warehouseDTOTransform: WarehouseTransactionDTOTransform;
+
+  @Inject()
+  transformer: TransformerInjectable;
+
+  /**
+   * Validate whether sale receipt exists on the storage.
+   * @param {number} tenantId -
+   * @param {number} saleReceiptId -
+   */
+  async getSaleReceiptOrThrowError(tenantId: number, saleReceiptId: number) {
+    const { SaleReceipt } = this.tenancy.models(tenantId);
+
+    const foundSaleReceipt = await SaleReceipt.query()
+      .findById(saleReceiptId)
+      .withGraphFetched('entries');
+
+    if (!foundSaleReceipt) {
+      throw new ServiceError(ERRORS.SALE_RECEIPT_NOT_FOUND);
+    }
+    return foundSaleReceipt;
+  }
+
+  /**
+   * Validate whether sale receipt deposit account exists on the storage.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} accountId - Account id.
+   */
+  async validateReceiptDepositAccountExistance(
+    tenantId: number,
+    accountId: number
+  ) {
+    const { accountRepository } = this.tenancy.repositories(tenantId);
+    const depositAccount = await accountRepository.findOneById(accountId);
+
+    if (!depositAccount) {
+      throw new ServiceError(ERRORS.DEPOSIT_ACCOUNT_NOT_FOUND);
+    }
+    if (!depositAccount.isParentType(ACCOUNT_PARENT_TYPE.CURRENT_ASSET)) {
+      throw new ServiceError(ERRORS.DEPOSIT_ACCOUNT_NOT_CURRENT_ASSET);
+    }
+  }
+
+  /**
+   * Validate sale receipt number uniquiness on the storage.
+   * @param {number} tenantId -
+   * @param {string} receiptNumber -
+   * @param {number} notReceiptId -
+   */
+  async validateReceiptNumberUnique(
+    tenantId: number,
+    receiptNumber: string,
+    notReceiptId?: number
+  ) {
+    const { SaleReceipt } = this.tenancy.models(tenantId);
+
+    const saleReceipt = await SaleReceipt.query()
+      .findOne('receipt_number', receiptNumber)
+      .onBuild((builder) => {
+        if (notReceiptId) {
+          builder.whereNot('id', notReceiptId);
+        }
+      });
+
+    if (saleReceipt) {
+      throw new ServiceError(ERRORS.SALE_RECEIPT_NUMBER_NOT_UNIQUE);
+    }
+  }
+
+  /**
+   * Validate the sale receipt number require.
+   * @param {ISaleReceipt} saleReceipt
+   */
+  validateReceiptNoRequire(receiptNumber: string) {
+    if (!receiptNumber) {
+      throw new ServiceError(ERRORS.SALE_RECEIPT_NO_IS_REQUIRED);
+    }
+  }
+
+  /**
+   * Retrieve the next unique receipt number.
+   * @param  {number} tenantId - Tenant id.
+   * @return {string}
+   */
+  getNextReceiptNumber(tenantId: number): string {
+    return this.autoIncrementOrdersService.getNextTransactionNumber(
+      tenantId,
+      'sales_receipts'
+    );
+  }
+
+  /**
+   * Increment the receipt next number.
+   * @param {number} tenantId -
+   */
+  incrementNextReceiptNumber(tenantId: number) {
+    return this.autoIncrementOrdersService.incrementSettingsNextNumber(
+      tenantId,
+      'sales_receipts'
+    );
+  }
+
+  /**
+   * Transform create DTO object to model object.
+   * @param   {ISaleReceiptDTO} saleReceiptDTO -
+   * @param   {ISaleReceipt} oldSaleReceipt -
+   * @returns {ISaleReceipt}
+   */
+  async transformDTOToModel(
+    tenantId: number,
+    saleReceiptDTO: ISaleReceiptDTO,
+    paymentCustomer: ICustomer,
+    oldSaleReceipt?: ISaleReceipt
+  ): Promise<ISaleReceipt> {
+    const amount = sumBy(saleReceiptDTO.entries, (e) =>
+      ItemEntry.calcAmount(e)
+    );
+    // Retreive the next invoice number.
+    const autoNextNumber = this.getNextReceiptNumber(tenantId);
+
+    // Retreive the receipt number.
+    const receiptNumber =
+      saleReceiptDTO.receiptNumber ||
+      oldSaleReceipt?.receiptNumber ||
+      autoNextNumber;
+
+    // Validate receipt number require.
+    this.validateReceiptNoRequire(receiptNumber);
+
+    const initialEntries = saleReceiptDTO.entries.map((entry) => ({
+      reference_type: 'SaleReceipt',
+      ...entry,
+    }));
+
+    const entries = await composeAsync(
+      // Sets default cost and sell account to receipt items entries.
+      this.itemsEntriesService.setItemsEntriesDefaultAccounts(tenantId)
+    )(initialEntries);
+
+    const initialDTO = {
+      amount,
+      ...formatDateFields(omit(saleReceiptDTO, ['closed', 'entries']), [
+        'receiptDate',
+      ]),
+      currencyCode: paymentCustomer.currencyCode,
+      exchangeRate: saleReceiptDTO.exchangeRate || 1,
+      receiptNumber,
+      // Avoid rewrite the deliver date in edit mode when already published.
+      ...(saleReceiptDTO.closed &&
+        !oldSaleReceipt?.closedAt && {
+          closedAt: moment().toMySqlDateTime(),
+        }),
+      entries,
+    };
+    return R.compose(
+      this.branchDTOTransform.transformDTO<ISaleReceipt>(tenantId),
+      this.warehouseDTOTransform.transformDTO<ISaleReceipt>(tenantId)
+    )(initialDTO);
+  }
+
+  /**
+   * Creates a new sale receipt with associated entries.
+   * @async
+   * @param {ISaleReceipt} saleReceipt
+   * @return {Object}
+   */
+  public async createSaleReceipt(
+    tenantId: number,
+    saleReceiptDTO: any
+  ): Promise<ISaleReceipt> {
+    const { SaleReceipt, Contact } = this.tenancy.models(tenantId);
+
+    // Retireves the payment customer model.
+    const paymentCustomer = await Contact.query()
+      .modify('customer')
+      .findById(saleReceiptDTO.customerId)
+      .throwIfNotFound();
+
+    // Transform sale receipt DTO to model.
+    const saleReceiptObj = await this.transformDTOToModel(
+      tenantId,
+      saleReceiptDTO,
+      paymentCustomer
+    );
+    // Validate receipt deposit account existance and type.
+    await this.validateReceiptDepositAccountExistance(
+      tenantId,
+      saleReceiptDTO.depositAccountId
+    );
+    // Validate items IDs existance on the storage.
+    await this.itemsEntriesService.validateItemsIdsExistance(
+      tenantId,
+      saleReceiptDTO.entries
+    );
+    // Validate the sellable items.
+    await this.itemsEntriesService.validateNonSellableEntriesItems(
+      tenantId,
+      saleReceiptDTO.entries
+    );
+    // Validate sale receipt number uniuqiness.
+    if (saleReceiptDTO.receiptNumber) {
+      await this.validateReceiptNumberUnique(
+        tenantId,
+        saleReceiptDTO.receiptNumber
+      );
+    }
+    // Creates a sale receipt transaction and associated transactions under UOW env.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onSaleReceiptCreating` event.
+      await this.eventPublisher.emitAsync(events.saleReceipt.onCreating, {
+        saleReceiptDTO,
+        tenantId,
+        trx,
+      } as ISaleReceiptCreatingPayload);
+
+      // Inserts the sale receipt graph to the storage.
+      const saleReceipt = await SaleReceipt.query().upsertGraph({
+        ...saleReceiptObj,
+      });
+      // Triggers `onSaleReceiptCreated` event.
+      await this.eventPublisher.emitAsync(events.saleReceipt.onCreated, {
+        tenantId,
+        saleReceipt,
+        saleReceiptId: saleReceipt.id,
+        trx,
+      } as ISaleReceiptCreatedPayload);
+
+      return saleReceipt;
+    });
+  }
+
+  /**
+   * Edit details sale receipt with associated entries.
+   * @param {Integer} saleReceiptId
+   * @param {ISaleReceipt} saleReceipt
+   * @return {void}
+   */
+  public async editSaleReceipt(
+    tenantId: number,
+    saleReceiptId: number,
+    saleReceiptDTO: any
+  ) {
+    const { SaleReceipt, Contact } = this.tenancy.models(tenantId);
+
+    // Retrieve sale receipt or throw not found service error.
+    const oldSaleReceipt = await this.getSaleReceiptOrThrowError(
+      tenantId,
+      saleReceiptId
+    );
+    // Retrieves the payment customer model.
+    const paymentCustomer = await Contact.query()
+      .findById(saleReceiptId)
+      .modify('customer')
+      .throwIfNotFound();
+
+    // Transform sale receipt DTO to model.
+    const saleReceiptObj = await this.transformDTOToModel(
+      tenantId,
+      saleReceiptDTO,
+      paymentCustomer,
+      oldSaleReceipt
+    );
+    // Validate receipt deposit account existance and type.
+    await this.validateReceiptDepositAccountExistance(
+      tenantId,
+      saleReceiptDTO.depositAccountId
+    );
+    // Validate items IDs existance on the storage.
+    await this.itemsEntriesService.validateItemsIdsExistance(
+      tenantId,
+      saleReceiptDTO.entries
+    );
+    // Validate the sellable items.
+    await this.itemsEntriesService.validateNonSellableEntriesItems(
+      tenantId,
+      saleReceiptDTO.entries
+    );
+    // Validate sale receipt number uniuqiness.
+    if (saleReceiptDTO.receiptNumber) {
+      await this.validateReceiptNumberUnique(
+        tenantId,
+        saleReceiptDTO.receiptNumber,
+        saleReceiptId
+      );
+    }
+    // Edits the sale receipt tranasctions with associated transactions under UOW env.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onSaleReceiptsEditing` event.
+      await this.eventPublisher.emitAsync(events.saleReceipt.onEditing, {
+        tenantId,
+        oldSaleReceipt,
+        saleReceiptDTO,
+        trx,
+      } as ISaleReceiptEditingPayload);
+
+      // Upsert the receipt graph to the storage.
+      const saleReceipt = await SaleReceipt.query(trx).upsertGraphAndFetch({
+        id: saleReceiptId,
+        ...saleReceiptObj,
+      });
+      // Triggers `onSaleReceiptEdited` event.
+      await this.eventPublisher.emitAsync(events.saleReceipt.onEdited, {
+        tenantId,
+        oldSaleReceipt,
+        saleReceipt,
+        saleReceiptId,
+        trx,
+      } as ISaleReceiptEditedPayload);
+
+      return saleReceipt;
+    });
+  }
+
+  /**
+   * Deletes the sale receipt with associated entries.
+   * @param {Integer} saleReceiptId
+   * @return {void}
+   */
+  public async deleteSaleReceipt(tenantId: number, saleReceiptId: number) {
+    const { SaleReceipt, ItemEntry } = this.tenancy.models(tenantId);
+
+    const oldSaleReceipt = await this.getSaleReceiptOrThrowError(
+      tenantId,
+      saleReceiptId
+    );
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers  `onSaleReceiptsDeleting` event.
+      await this.eventPublisher.emitAsync(events.saleReceipt.onDeleting, {
+        trx,
+        oldSaleReceipt,
+        tenantId,
+      } as ISaleReceiptDeletingPayload);
+
+      //
+      await ItemEntry.query(trx)
+        .where('reference_id', saleReceiptId)
+        .where('reference_type', 'SaleReceipt')
+        .delete();
+
+      // Delete the sale receipt transaction.
+      await SaleReceipt.query(trx).where('id', saleReceiptId).delete();
+
+      // Triggers `onSaleReceiptsDeleted` event.
+      await this.eventPublisher.emitAsync(events.saleReceipt.onDeleted, {
+        tenantId,
+        saleReceiptId,
+        oldSaleReceipt,
+        trx,
+      } as ISaleReceiptEventDeletedPayload);
+    });
+  }
+
+  /**
+   * Retrieve sale receipt with associated entries.
+   * @param {Integer} saleReceiptId
+   * @return {ISaleReceipt}
+   */
+  async getSaleReceipt(tenantId: number, saleReceiptId: number) {
+    const { SaleReceipt } = this.tenancy.models(tenantId);
+
+    const saleReceipt = await SaleReceipt.query()
+      .findById(saleReceiptId)
+      .withGraphFetched('entries.item')
+      .withGraphFetched('customer')
+      .withGraphFetched('depositAccount')
+      .withGraphFetched('branch');
+
+    if (!saleReceipt) {
+      throw new ServiceError(ERRORS.SALE_RECEIPT_NOT_FOUND);
+    }
+    return this.transformer.transform(
+      tenantId,
+      saleReceipt,
+      new SaleReceiptTransformer()
+    );
+  }
+
+  /**
+   * Parses the sale receipts list filter DTO.
+   * @param filterDTO
+   */
+  private parseListFilterDTO(filterDTO) {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  }
+
+  /**
+   * Retrieve sales receipts paginated and filterable list.
+   * @param {number} tenantId
+   * @param {ISaleReceiptFilter} salesReceiptsFilter
+   */
+  public async salesReceiptsList(
+    tenantId: number,
+    filterDTO: ISaleReceiptFilter
+  ): Promise<{
+    data: ISaleReceipt[];
+    pagination: IPaginationMeta;
+    filterMeta: IFilterMeta;
+  }> {
+    const { SaleReceipt } = this.tenancy.models(tenantId);
+
+    // Parses the stringified filter roles.
+    const filter = this.parseListFilterDTO(filterDTO);
+
+    // Dynamic list service.
+    const dynamicFilter = await this.dynamicListService.dynamicList(
+      tenantId,
+      SaleReceipt,
+      filter
+    );
+    const { results, pagination } = await SaleReceipt.query()
+      .onBuild((builder) => {
+        builder.withGraphFetched('depositAccount');
+        builder.withGraphFetched('customer');
+        builder.withGraphFetched('entries');
+
+        dynamicFilter.buildQuery()(builder);
+      })
+      .pagination(filter.page - 1, filter.pageSize);
+
+    // Transformes the estimates models to POJO.
+    const salesEstimates = await this.transformer.transform(
+      tenantId,
+      results,
+      new SaleReceiptTransformer()
+    );
+    return {
+      data: salesEstimates,
+      pagination,
+      filterMeta: dynamicFilter.getResponseMeta(),
+    };
+  }
+
+  /**
+   * Mark the given sale receipt as closed.
+   * @param {number} tenantId
+   * @param {number} saleReceiptId
+   * @return {Promise<void>}
+   */
+  async closeSaleReceipt(
+    tenantId: number,
+    saleReceiptId: number
+  ): Promise<void> {
+    const { SaleReceipt } = this.tenancy.models(tenantId);
+
+    // Retrieve sale receipt or throw not found service error.
+    const oldSaleReceipt = await this.getSaleReceiptOrThrowError(
+      tenantId,
+      saleReceiptId
+    );
+
+    // Throw service error if the sale receipt already closed.
+    if (oldSaleReceipt.isClosed) {
+      throw new ServiceError(ERRORS.SALE_RECEIPT_IS_ALREADY_CLOSED);
+    }
+    // Updates the sale recept transaction under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onSaleReceiptClosing` event.
+      await this.eventPublisher.emitAsync(events.saleReceipt.onClosing, {
+        tenantId,
+        oldSaleReceipt,
+        trx,
+      } as ISaleReceiptEventClosingPayload);
+
+      // Mark the sale receipt as closed on the storage.
+      const saleReceipt = await SaleReceipt.query(trx)
+        .findById(saleReceiptId)
+        .patch({
+          closedAt: moment().toMySqlDateTime(),
+        });
+
+      // Triggers `onSaleReceiptClosed` event.
+      await this.eventPublisher.emitAsync(events.saleReceipt.onClosed, {
+        saleReceiptId,
+        saleReceipt,
+        tenantId,
+        trx,
+      } as ISaleReceiptEventClosedPayload);
+    });
+  }
+  /**
+   * Records the inventory transactions from the given bill input.
+   * @param {Bill} bill - Bill model object.
+   * @param {number} billId - Bill id.
+   * @return {Promise<void>}
+   */
+  public async recordInventoryTransactions(
+    tenantId: number,
+    saleReceipt: ISaleReceipt,
+    override?: boolean,
+    trx?: Knex.Transaction
+  ): Promise<void> {
+    // Loads the inventory items entries of the given sale invoice.
+    const inventoryEntries =
+      await this.itemsEntriesService.filterInventoryEntries(
+        tenantId,
+        saleReceipt.entries
+      );
+    const transaction = {
+      transactionId: saleReceipt.id,
+      transactionType: 'SaleReceipt',
+      transactionNumber: saleReceipt.receiptNumber,
+      exchangeRate: saleReceipt.exchangeRate,
+
+      date: saleReceipt.receiptDate,
+      direction: 'OUT',
+      entries: inventoryEntries,
+      createdAt: saleReceipt.createdAt,
+
+      warehouseId: saleReceipt.warehouseId,
+    };
+    return this.inventoryService.recordInventoryTransactionsFromItemsEntries(
+      tenantId,
+      transaction,
+      override,
+      trx
+    );
+  }
+
+  /**
+   * Reverts the inventory transactions of the given bill id.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} billId - Bill id.
+   * @return {Promise<void>}
+   */
+  public async revertInventoryTransactions(
+    tenantId: number,
+    receiptId: number,
+    trx?: Knex.Transaction
+  ) {
+    return this.inventoryService.deleteInventoryTransactions(
+      tenantId,
+      receiptId,
+      'SaleReceipt',
+      trx
+    );
+  }
+
+  /**
+   * Validate the given customer has no sales receipts.
+   * @param {number} tenantId
+   * @param {number} customerId - Customer id.
+   */
+  public async validateCustomerHasNoReceipts(
+    tenantId: number,
+    customerId: number
+  ) {
+    const { SaleReceipt } = this.tenancy.models(tenantId);
+
+    const receipts = await SaleReceipt.query().where('customer_id', customerId);
+
+    if (receipts.length > 0) {
+      throw new ServiceError(ERRORS.CUSTOMER_HAS_SALES_INVOICES);
+    }
+  }
+}
diff --git a/packages/server/src/services/Sales/SalesTransactionsLocking.ts b/packages/server/src/services/Sales/SalesTransactionsLocking.ts
new file mode 100644
index 000000000..2fec2a0c8
--- /dev/null
+++ b/packages/server/src/services/Sales/SalesTransactionsLocking.ts
@@ -0,0 +1,32 @@
+import { Service, Inject } from 'typedi';
+import TransactionsLockingValidator from '@/services/TransactionsLocking/TransactionsLockingGuard';
+import { TransactionsLockingGroup } from '@/interfaces';
+
+@Service()
+export default class SalesTransactionsLocking {
+  @Inject()
+  transactionLockingValidator: TransactionsLockingValidator;
+
+  /**
+   * Validates the all and partial sales transactions locking.
+   * @param {number} tenantId
+   * @param {Date} transactionDate
+   */
+  public validateTransactionsLocking = (
+    tenantId: number,
+    transactionDate: Date
+  ) => {
+    // Validates the all transcation locking.
+    this.transactionLockingValidator.validateTransactionsLocking(
+      tenantId,
+      transactionDate,
+      TransactionsLockingGroup.All
+    );
+    // Validates the partial sales transcation locking.
+    // this.transactionLockingValidator.validateTransactionsLocking(
+    //   tenantId,
+    //   transactionDate,
+    //   TransactionsLockingGroup.Sales
+    // );
+  };
+}
diff --git a/packages/server/src/services/Sales/ServiceItemsEntries.js b/packages/server/src/services/Sales/ServiceItemsEntries.js
new file mode 100644
index 000000000..95d2cd6c4
--- /dev/null
+++ b/packages/server/src/services/Sales/ServiceItemsEntries.js
@@ -0,0 +1,16 @@
+import { difference } from "lodash";
+
+
+export default class ServiceItemsEntries {
+  
+  static entriesShouldDeleted(storedEntries, entries) {
+    const storedEntriesIds = storedEntries.map((e) => e.id);
+    const entriesIds = entries.map((e) => e.id);
+
+    return difference(
+      storedEntriesIds,
+      entriesIds,
+    );
+  }
+
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Sales/constants.ts b/packages/server/src/services/Sales/constants.ts
new file mode 100644
index 000000000..b4e5ff272
--- /dev/null
+++ b/packages/server/src/services/Sales/constants.ts
@@ -0,0 +1,75 @@
+export const ERRORS = {
+  INVOICE_NUMBER_NOT_UNIQUE: 'INVOICE_NUMBER_NOT_UNIQUE',
+  SALE_INVOICE_NOT_FOUND: 'SALE_INVOICE_NOT_FOUND',
+  SALE_INVOICE_ALREADY_DELIVERED: 'SALE_INVOICE_ALREADY_DELIVERED',
+  ENTRIES_ITEMS_IDS_NOT_EXISTS: 'ENTRIES_ITEMS_IDS_NOT_EXISTS',
+  NOT_SELLABLE_ITEMS: 'NOT_SELLABLE_ITEMS',
+  SALE_INVOICE_NO_NOT_UNIQUE: 'SALE_INVOICE_NO_NOT_UNIQUE',
+  INVOICE_AMOUNT_SMALLER_THAN_PAYMENT_AMOUNT:
+    'INVOICE_AMOUNT_SMALLER_THAN_PAYMENT_AMOUNT',
+  INVOICE_HAS_ASSOCIATED_PAYMENT_ENTRIES:
+    'INVOICE_HAS_ASSOCIATED_PAYMENT_ENTRIES',
+  SALE_INVOICE_NO_IS_REQUIRED: 'SALE_INVOICE_NO_IS_REQUIRED',
+  CUSTOMER_HAS_SALES_INVOICES: 'CUSTOMER_HAS_SALES_INVOICES',
+  SALE_INVOICE_HAS_APPLIED_TO_CREDIT_NOTES: 'SALE_INVOICE_HAS_APPLIED_TO_CREDIT_NOTES',
+  PAYMENT_ACCOUNT_CURRENCY_INVALID: 'PAYMENT_ACCOUNT_CURRENCY_INVALID'
+};
+
+export const DEFAULT_VIEW_COLUMNS = [];
+export const DEFAULT_VIEWS = [
+  {
+    name: 'Draft',
+    slug: 'draft',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'draft' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Delivered',
+    slug: 'delivered',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'delivered',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Unpaid',
+    slug: 'unpaid',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'unpaid' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Partially paid',
+    slug: 'partially-paid',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'partially-paid',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Paid',
+    slug: 'paid',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'paid' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+];
diff --git a/packages/server/src/services/SessionModel/SessionQueryBuilder.js b/packages/server/src/services/SessionModel/SessionQueryBuilder.js
new file mode 100644
index 000000000..74c642fbe
--- /dev/null
+++ b/packages/server/src/services/SessionModel/SessionQueryBuilder.js
@@ -0,0 +1,13 @@
+import SessionModel from '@/services/SessionModel';
+
+export default class SessionQueryBuilder extends SessionModel.QueryBuilder {
+  /**
+   * Add a custom method that stores a session object to the query context.
+   * @param {*} session -
+   */
+  session(session) {
+    return this.mergeContext({
+      session,
+    });
+  }
+}
diff --git a/packages/server/src/services/SessionModel/index.js b/packages/server/src/services/SessionModel/index.js
new file mode 100644
index 000000000..e99fee588
--- /dev/null
+++ b/packages/server/src/services/SessionModel/index.js
@@ -0,0 +1,24 @@
+import SessionQueryBuilder from '@/services/SessionModel/SessionQueryBuilder';
+
+export default class SessionModel {
+  /**
+   * Constructor method.
+   * @param {Object} options -
+   */
+  constructor(options) {
+    this.options = { ...options, ...SessionModel.defaultOptions };
+  }
+
+  static get defaultOptions() {
+    return {
+      setModifiedBy: true,
+      setModifiedAt: true,
+      setCreatedBy: true,
+      setCreatedAt: true,
+    };
+  }
+
+  static get QueryBuilder() {
+    return SessionQueryBuilder;
+  }
+}
diff --git a/packages/server/src/services/Settings/SettingsService.ts b/packages/server/src/services/Settings/SettingsService.ts
new file mode 100644
index 000000000..b3e3fd11f
--- /dev/null
+++ b/packages/server/src/services/Settings/SettingsService.ts
@@ -0,0 +1,53 @@
+import { Service, Inject } from 'typedi';
+import TenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export default class SettingsService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  /**
+   * Increment next number based on the given find query.
+   * @param {number} tenantId
+   * @param {any} findQuery
+   */
+  async incrementNextNumber(tenantId: number, findQuery: any): Promise<void> {
+    const settings = this.tenancy.settings(tenantId);
+
+    this.logger.info('[settings] increment the next number.', {
+      tenantId,
+      findQuery,
+    });
+    const currentNumber = settings.find(findQuery);
+
+    if (currentNumber) {
+      const nextNumber = parseInt(currentNumber.value, 10) + 1;
+      settings.set(findQuery, nextNumber);
+
+      await settings.save();
+    }
+  }
+
+  /**
+   * Validates the given options is defined or either not.
+   * @param {Array} options
+   * @return {Boolean}
+   */
+  validateNotDefinedSettings(tenantId: number, options) {
+    const notDefined = [];
+
+    const settings = this.tenancy.settings(tenantId);
+
+    options.forEach((option) => {
+      const setting = settings.config.getMetaConfig(option.key, option.group);
+
+      if (!setting) {
+        notDefined.push(option);
+      }
+    });
+    return notDefined;
+  }
+}
diff --git a/packages/server/src/services/Settings/SettingsStore.ts b/packages/server/src/services/Settings/SettingsStore.ts
new file mode 100644
index 000000000..e70ffc31d
--- /dev/null
+++ b/packages/server/src/services/Settings/SettingsStore.ts
@@ -0,0 +1,15 @@
+import Knex from 'knex';
+import MetableStoreDB from '@/lib/Metable/MetableStoreDB';
+import Setting from 'models/Setting';
+
+export default class SettingsStore extends MetableStoreDB {
+  /**
+   * Constructor method.
+   * @param {number} tenantId 
+   */
+  constructor(repository) {
+    super();
+    this.setExtraColumns(['group']);
+    this.setRepository(repository);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Settings/SmsNotificationsSettings.ts b/packages/server/src/services/Settings/SmsNotificationsSettings.ts
new file mode 100644
index 000000000..7fd02541c
--- /dev/null
+++ b/packages/server/src/services/Settings/SmsNotificationsSettings.ts
@@ -0,0 +1,200 @@
+import { Service, Inject } from 'typedi';
+import { isUndefined, omit, keyBy } from 'lodash';
+import {
+  ISmsNotificationDefined,
+  ISmsNotificationMeta,
+  IEditSmsNotificationDTO,
+  ISmsNotificationAllowedVariable,
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import SMSNotificationsConfig from 'config/smsNotifications';
+import { ServiceError } from '@/exceptions';
+import I18nService from '@/services/I18n/I18nService';
+
+const ERRORS = {
+  SMS_NOTIFICATION_KEY_NOT_FOUND: 'SMS_NOTIFICATION_KEY_NOT_FOUND',
+  UNSUPPORTED_SMS_MESSAGE_VARIABLES: 'UNSUPPORTED_SMS_MESSAGE_VARIABLES',
+};
+
+@Service()
+export default class SmsNotificationsSettingsService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  i18nService: I18nService;
+
+  /**
+   * Retrieve sms notification meta from the given notification key.
+   * @param {string} notificationKey - Notification key.
+   * @returns {ISmsNotificationMeta}
+   */
+  public getSmsNotificationMeta = (
+    tenantId: number,
+    notificationKey: string
+  ): ISmsNotificationMeta => {
+    const notificationsByKey = keyBy(SMSNotificationsConfig, 'key');
+    const notification = notificationsByKey[notificationKey];
+
+    // Validates sms notification exists.
+    this.validateSmsNotificationExists(notification);
+
+    return this.transformSmsNotifConfigToMeta(tenantId, notification);
+  };
+
+  /**
+   * Transformes the sms notification config to notificatin meta.
+   * @param {Settings} settings
+   * @param {ISmsNotificationDefined} smsNotification
+   * @returns {ISmsNotificationMeta}
+   */
+  private transformSmsNotifConfigToMeta = (
+    tenantId: number,
+    smsNotification: ISmsNotificationDefined
+  ): ISmsNotificationMeta => {
+    const settings = this.tenancy.settings(tenantId);
+    const i18n = this.tenancy.i18n(tenantId);
+    const group = 'sms-notification';
+
+    const defaultSmsMessage = i18n.__(smsNotification.defaultSmsMessage);
+
+    return {
+      ...omit(smsNotification, [
+        'defaultSmsMessage',
+        'defaultIsNotificationEnabled',
+      ]),
+      notificationLabel: i18n.__(smsNotification.notificationLabel),
+      notificationDescription: i18n.__(smsNotification.notificationDescription),
+      moduleFormatted: i18n.__(smsNotification.moduleFormatted),
+      allowedVariables: smsNotification.allowedVariables.map(
+        (notification) => ({
+          ...notification,
+          description: i18n.__(notification.description),
+        })
+      ),
+      defaultSmsMessage,
+      smsMessage: settings.get(
+        {
+          key: `sms-message.${smsNotification.key}`,
+          group,
+        },
+        defaultSmsMessage
+      ),
+      isNotificationEnabled: settings.get(
+        {
+          key: `sms-notification-enable.${smsNotification.key}`,
+          group,
+        },
+        smsNotification.defaultIsNotificationEnabled
+      ),
+    };
+  };
+
+  /**
+   * Retrieve the sms notifications list.
+   * @param {number} tenantId
+   */
+  public smsNotificationsList = (
+    tenantId: number
+  ): Promise<ISmsNotificationMeta[]> => {
+    return SMSNotificationsConfig.map((notification) => {
+      return this.transformSmsNotifConfigToMeta(tenantId, notification);
+    });
+  };
+
+  /**
+   * Edits/Mutates the sms notification message text.
+   * @param {number} tenantId - Tenant id.
+   * @param {IEditSmsNotificationDTO} editSmsNotificationDTO - Edit SMS notification DTO.
+   */
+  public editSmsNotificationMessage = (
+    tenantId: number,
+    editDTO: IEditSmsNotificationDTO
+  ): ISmsNotificationMeta => {
+    const settings = this.tenancy.settings(tenantId);
+
+    const notification = this.getSmsNotificationMeta(
+      tenantId,
+      editDTO.notificationKey
+    );
+    const group = 'sms-notification';
+
+    if (editDTO.messageText) {
+      this.validateSmsMessageVariables(
+        editDTO.messageText,
+        notification.allowedVariables
+      );
+      settings.set({
+        key: `sms-message.${editDTO.notificationKey}`,
+        value: editDTO.messageText,
+        group,
+      });
+    }
+    if (!isUndefined(editDTO.isNotificationEnabled)) {
+      settings.set({
+        key: `sms-notification-enable.${editDTO.notificationKey}`,
+        value: editDTO.isNotificationEnabled,
+        group,
+      });
+    }
+    return notification;
+  };
+
+  /**
+   * Vaidates the sms notification key existance.
+   * @param {string} notificationKey
+   */
+  private validateSmsNotificationExists = (
+    notificationDefined: ISmsNotificationDefined | null
+  ): void => {
+    if (!notificationDefined) {
+      throw new ServiceError(ERRORS.SMS_NOTIFICATION_KEY_NOT_FOUND);
+    }
+  };
+
+  /**
+   * Retrieve unspported message arguments.
+   * @param {string} smsMessage - SMS message.
+   * @param {string[]} args -
+   * @returns {string[]}
+   */
+  private getUnsupportedMessageArgs = (
+    smsMessage: string,
+    args: string[]
+  ): string[] => {
+    const matchedVariables = smsMessage.match(/\{(.*?)\}/g).map((matched) => {
+      return matched.replace('{', '').replace('}', '');
+    });
+    const invalidVariables = matchedVariables.filter(
+      (variable) => args.indexOf(variable) === -1
+    );
+    return invalidVariables;
+  };
+
+  /**
+   * Validates the sms message variables.
+   * @param {string} smsMessage
+   * @param {string[]} args
+   */
+  private validateSmsMessageVariables(
+    smsMessage: string,
+    allowedVariables: ISmsNotificationAllowedVariable[]
+  ) {
+    const allowedVariablesKeys = allowedVariables.map(
+      (allowed) => allowed.variable
+    );
+    const unsupportedArgs = this.getUnsupportedMessageArgs(
+      smsMessage,
+      allowedVariablesKeys
+    );
+
+    if (unsupportedArgs.length > 0) {
+      throw new ServiceError(ERRORS.UNSUPPORTED_SMS_MESSAGE_VARIABLES, null, {
+        unsupportedArgs,
+      });
+    }
+  }
+}
diff --git a/packages/server/src/services/Setup/SetupService.ts b/packages/server/src/services/Setup/SetupService.ts
new file mode 100644
index 000000000..a00933fd6
--- /dev/null
+++ b/packages/server/src/services/Setup/SetupService.ts
@@ -0,0 +1,119 @@
+import { Service, Inject } from 'typedi';
+import Currencies from 'js-money/lib/currency';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { IOrganizationSetupDTO, ITenant } from '@/interfaces';
+
+import CurrenciesService from '@/services/Currencies/CurrenciesService';
+import TenantsManagerService from '@/services/Tenancy/TenantsManager';
+import { ServiceError } from '@/exceptions';
+
+const ERRORS = {
+  TENANT_IS_ALREADY_SETUPED: 'TENANT_IS_ALREADY_SETUPED',
+  BASE_CURRENCY_INVALID: 'BASE_CURRENCY_INVALID',
+};
+
+@Service()
+export default class SetupService {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  currenciesService: CurrenciesService;
+
+  @Inject()
+  tenantsManager: TenantsManagerService;
+
+  @Inject('repositories')
+  sysRepositories: any;
+
+  /**
+   * Transformes the setup DTO to settings.
+   * @param {IOrganizationSetupDTO} setupDTO
+   * @returns
+   */
+  private transformSetupDTOToOptions(setupDTO: IOrganizationSetupDTO) {
+    return [
+      { key: 'name', value: setupDTO.organizationName },
+      { key: 'base_currency', value: setupDTO.baseCurrency },
+      { key: 'time_zone', value: setupDTO.timeZone },
+      { key: 'industry', value: setupDTO.industry },
+    ];
+  }
+
+  /**
+   * Sets organization setup settings.
+   * @param {number} tenantId
+   * @param {IOrganizationSetupDTO} organizationSetupDTO
+   */
+  private setOrganizationSetupSettings(
+    tenantId: number,
+    organizationSetupDTO: IOrganizationSetupDTO
+  ) {
+    const settings = this.tenancy.settings(tenantId);
+
+    // Can't continue if app is already configured.
+    if (settings.get('app_configured')) { return; }
+
+    settings.set([
+      ...this.transformSetupDTOToOptions(organizationSetupDTO)
+        .filter((option) => typeof option.value !== 'undefined')
+        .map((option) => ({
+          ...option,
+          group: 'organization',
+        })),
+      { key: 'app_configured', value: true },
+    ]);
+  }
+
+  /**
+   * Validates the base currency code.
+   * @param {string} baseCurrency 
+   */
+  public validateBaseCurrencyCode(baseCurrency: string) {
+    if (typeof Currencies[baseCurrency] === 'undefined') {
+      throw new ServiceError(ERRORS.BASE_CURRENCY_INVALID);
+    }
+  }
+
+  /**
+   * Organization setup DTO.
+   * @param {IOrganizationSetupDTO} organizationSetupDTO
+   * @return {Promise<void>}
+   */
+  public async organizationSetup(
+    tenantId: number,
+    organizationSetupDTO: IOrganizationSetupDTO,
+  ): Promise<void> {
+    const { tenantRepository } = this.sysRepositories;
+
+    // Find tenant model by the given id.
+    const tenant = await tenantRepository.findOneById(tenantId);
+
+    // Validate base currency code.
+    this.validateBaseCurrencyCode(organizationSetupDTO.baseCurrency);
+
+    // Validate tenant not already seeded.
+    this.validateTenantNotSeeded(tenant);
+
+    // Seeds the base currency to the currencies list.
+    this.currenciesService.seedBaseCurrency(
+      tenantId,
+      organizationSetupDTO.baseCurrency
+    );
+    // Sets organization setup settings.
+    await this.setOrganizationSetupSettings(tenantId, organizationSetupDTO);
+
+    // Seed tenant.
+    await this.tenantsManager.seedTenant(tenant);
+  }
+
+  /**
+   * Validates tenant not seeded.
+   * @param {ITenant} tenant
+   */
+  private validateTenantNotSeeded(tenant: ITenant) {
+    if (tenant.seededAt) {
+      throw new ServiceError(ERRORS.TENANT_IS_ALREADY_SETUPED);
+    }
+  }
+}
diff --git a/packages/server/src/services/SmsIntegration/EasySmsIntegration.ts b/packages/server/src/services/SmsIntegration/EasySmsIntegration.ts
new file mode 100644
index 000000000..5010ebdd0
--- /dev/null
+++ b/packages/server/src/services/SmsIntegration/EasySmsIntegration.ts
@@ -0,0 +1,63 @@
+import { Inject, Service } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ServiceError } from '@/exceptions';
+
+interface IEasysmsIntegrateDTO {
+  token: string;
+}
+
+const ERRORS = {
+  SMS_GATEWAY_NOT_INTEGRATED: 'SMS_GATEWAY_NOT_INTEGRATED',
+};
+
+const easysmsSettingsQuery = {
+  group: 'sms_integration',
+  key: 'easysms_token',
+};
+
+@Service()
+export default class EasySmsIntegration {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Integrate Easysms SMS gateway with the system.
+   * @param {number} tenantId -
+   * @param {IEasysmsIntegrateDTO} easysmsIntegrateDTO -
+   */
+  public integrate = (
+    tenantId: number,
+    easysmsIntegrateDTO: IEasysmsIntegrateDTO
+  ) => {
+    const settings = this.tenancy.settings(tenantId);
+
+    settings.set({
+      ...easysmsSettingsQuery,
+      value: easysmsIntegrateDTO.token,
+    });
+  };
+
+  /**
+   * Disconnects Easysms integration from the system.
+   * @param {number} tenantId
+   */
+  public disconnect = (tenantId: number) => {
+    const settings = this.tenancy.settings(tenantId);
+
+    settings.remove({ ...easysmsSettingsQuery });
+  };
+
+  /**
+   * Retrieve the Easysms metadata.
+   * @param {number} tenantId
+   */
+  public getIntegrationMeta = (tenantId: number) => {
+    const settings = this.tenancy.settings(tenantId);
+
+    const token = settings.get(easysmsSettingsQuery);
+
+    return {
+      active: !!token,
+    };
+  };
+}
diff --git a/packages/server/src/services/Subscription/MailMessages.ts b/packages/server/src/services/Subscription/MailMessages.ts
new file mode 100644
index 000000000..4c50a5243
--- /dev/null
+++ b/packages/server/src/services/Subscription/MailMessages.ts
@@ -0,0 +1,30 @@
+import { Service } from "typedi";
+
+@Service()
+export default class SubscriptionMailMessages {
+  /**
+   * 
+   * @param phoneNumber 
+   * @param remainingDays 
+   */
+  public async sendRemainingSubscriptionPeriod(phoneNumber: string, remainingDays: number) {
+    const message: string = `
+      Your remaining subscription is ${remainingDays} days,
+      please renew your subscription before expire.
+    `;
+    this.smsClient.sendMessage(phoneNumber, message);
+  }
+
+  /**
+   * 
+   * @param phoneNumber 
+   * @param remainingDays 
+   */
+  public async sendRemainingTrialPeriod(phoneNumber: string, remainingDays: number) {
+    const message: string = `
+      Your remaining free trial is ${remainingDays} days,
+      please subscription before ends, if you have any quation to contact us.`;
+
+    this.smsClient.sendMessage(phoneNumber, message);
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Subscription/SMSMessages.ts b/packages/server/src/services/Subscription/SMSMessages.ts
new file mode 100644
index 000000000..9cb7de273
--- /dev/null
+++ b/packages/server/src/services/Subscription/SMSMessages.ts
@@ -0,0 +1,40 @@
+import { Service, Inject } from 'typedi';
+import SMSClient from '@/services/SMSClient';
+
+@Service()
+export default class SubscriptionSMSMessages {
+  @Inject('SMSClient')
+  smsClient: SMSClient;
+
+  /**
+   * Send remaining subscription period SMS message.
+   * @param {string} phoneNumber -
+   * @param {number} remainingDays -
+   */
+  public async sendRemainingSubscriptionPeriod(
+    phoneNumber: string,
+    remainingDays: number
+  ): Promise<void> {
+    const message: string = `
+      Your remaining subscription is ${remainingDays} days,
+      please renew your subscription before expire.
+    `;
+    this.smsClient.sendMessage(phoneNumber, message);
+  }
+
+  /**
+   * Send remaining trial period SMS message.
+   * @param {string} phoneNumber -
+   * @param {number} remainingDays -
+   */
+  public async sendRemainingTrialPeriod(
+    phoneNumber: string,
+    remainingDays: number
+  ): Promise<void> {
+    const message: string = `
+      Your remaining free trial is ${remainingDays} days,
+      please subscription before ends, if you have any quation to contact us.`;
+
+    this.smsClient.sendMessage(phoneNumber, message);
+  }
+}
diff --git a/packages/server/src/services/Subscription/Subscription.ts b/packages/server/src/services/Subscription/Subscription.ts
new file mode 100644
index 000000000..4592a781f
--- /dev/null
+++ b/packages/server/src/services/Subscription/Subscription.ts
@@ -0,0 +1,80 @@
+import { Inject } from 'typedi';
+import { Tenant, Plan } from '@/system/models';
+import { IPaymentContext } from '@/interfaces';
+import { NotAllowedChangeSubscriptionPlan } from '@/exceptions';
+
+export default class Subscription<PaymentModel> {
+  paymentContext: IPaymentContext | null;
+
+  @Inject('logger')
+  logger: any;
+
+  /**
+   * Constructor method.
+   * @param {IPaymentContext}
+   */
+  constructor(payment?: IPaymentContext) {
+    this.paymentContext = payment;
+  }
+
+  /**
+   * Give the tenant a new subscription.
+   * @param {Tenant} tenant
+   * @param {Plan} plan
+   * @param {string} invoiceInterval
+   * @param {number} invoicePeriod
+   * @param {string} subscriptionSlug
+   */
+  protected async newSubscribtion(
+    tenant,
+    plan,
+    invoiceInterval: string,
+    invoicePeriod: number,
+    subscriptionSlug: string = 'main'
+  ) {
+    const subscription = await tenant
+      .$relatedQuery('subscriptions')
+      .modify('subscriptionBySlug', subscriptionSlug)
+      .first();
+
+    // No allowed to re-new the the subscription while the subscription is active.
+    if (subscription && subscription.active()) {
+      throw new NotAllowedChangeSubscriptionPlan();
+
+      // In case there is already subscription associated to the given tenant renew it.
+    } else if (subscription && subscription.inactive()) {
+      await subscription.renew(invoiceInterval, invoicePeriod);
+
+      // No stored past tenant subscriptions create new one.
+    } else {
+      await tenant.newSubscription(
+        plan.id,
+        invoiceInterval,
+        invoicePeriod,
+        subscriptionSlug
+      );
+    }
+  }
+
+  /**
+   * Subscripe to the given plan.
+   * @param {Plan} plan
+   * @throws {NotAllowedChangeSubscriptionPlan}
+   */
+  public async subscribe(
+    tenant: Tenant,
+    plan: Plan,
+    paymentModel?: PaymentModel,
+    subscriptionSlug: string = 'main'
+  ) {
+    await this.paymentContext.makePayment(paymentModel, plan);
+
+    return this.newSubscribtion(
+      tenant,
+      plan,
+      plan.invoiceInterval,
+      plan.invoicePeriod,
+      subscriptionSlug
+    );
+  }
+}
diff --git a/packages/server/src/services/Subscription/SubscriptionPeriod.ts b/packages/server/src/services/Subscription/SubscriptionPeriod.ts
new file mode 100644
index 000000000..c1d2e4a8b
--- /dev/null
+++ b/packages/server/src/services/Subscription/SubscriptionPeriod.ts
@@ -0,0 +1,41 @@
+import moment from 'moment';
+
+export default class SubscriptionPeriod {
+  start: Date;
+  end: Date;
+  interval: string;
+  count: number;
+
+  /**
+   * Constructor method.
+   * @param {string} interval -
+   * @param {number} count -
+   * @param {Date} start -
+   */
+  constructor(interval: string = 'month', count: number, start?: Date) {
+    this.interval = interval;
+    this.count = count;
+    this.start = start;
+
+    if (!start) {
+      this.start = moment().toDate();
+    }
+    this.end = moment(start).add(count, interval).toDate();
+  }
+
+  getStartDate() {
+    return this.start;
+  }
+
+  getEndDate() {
+    return this.end;
+  }
+
+  getInterval() {
+    return this.interval;
+  }
+
+  getIntervalCount() {
+    return this.interval;
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/services/Subscription/SubscriptionService.ts b/packages/server/src/services/Subscription/SubscriptionService.ts
new file mode 100644
index 000000000..0e254066b
--- /dev/null
+++ b/packages/server/src/services/Subscription/SubscriptionService.ts
@@ -0,0 +1,69 @@
+import { Service, Inject } from 'typedi';
+import { Plan, PlanSubscription, Tenant } from '@/system/models';
+import Subscription from '@/services/Subscription/Subscription';
+import LicensePaymentMethod from '@/services/Payment/LicensePaymentMethod';
+import PaymentContext from '@/services/Payment';
+import SubscriptionSMSMessages from '@/services/Subscription/SMSMessages';
+import SubscriptionMailMessages from '@/services/Subscription/MailMessages';
+import { ILicensePaymentModel } from '@/interfaces';
+import SubscriptionViaLicense from './SubscriptionViaLicense';
+
+@Service()
+export default class SubscriptionService {
+  @Inject()
+  smsMessages: SubscriptionSMSMessages;
+
+  @Inject()
+  mailMessages: SubscriptionMailMessages;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject('repositories')
+  sysRepositories: any;
+
+  /**
+   * Handles the payment process via license code and than subscribe to
+   * the given tenant.
+   * @param {number} tenantId
+   * @param {String} planSlug
+   * @param {string} licenseCode
+   * @return {Promise}
+   */
+  public async subscriptionViaLicense(
+    tenantId: number,
+    planSlug: string,
+    paymentModel: ILicensePaymentModel,
+    subscriptionSlug: string = 'main'
+  ) {
+    // Retrieve plan details.
+    const plan = await Plan.query().findOne('slug', planSlug);
+
+    // Retrieve tenant details.
+    const tenant = await Tenant.query().findById(tenantId);
+
+    // License payment method.
+    const paymentViaLicense = new LicensePaymentMethod();
+
+    // Payment context.
+    const paymentContext = new PaymentContext(paymentViaLicense);
+
+    // Subscription.
+    const subscription = new SubscriptionViaLicense(paymentContext);
+
+    // Subscribe.
+    await subscription.subscribe(tenant, plan, paymentModel, subscriptionSlug);
+  }
+
+  /**
+   * Retrieve all subscription of the given tenant.
+   * @param {number} tenantId
+   */
+  public async getSubscriptions(tenantId: number) {
+    const subscriptions = await PlanSubscription.query().where(
+      'tenant_id',
+      tenantId
+    );
+    return subscriptions;
+  }
+}
diff --git a/packages/server/src/services/Subscription/SubscriptionViaLicense.ts b/packages/server/src/services/Subscription/SubscriptionViaLicense.ts
new file mode 100644
index 000000000..629f30143
--- /dev/null
+++ b/packages/server/src/services/Subscription/SubscriptionViaLicense.ts
@@ -0,0 +1,54 @@
+import { License, Tenant, Plan } from '@/system/models';
+import Subscription from './Subscription';
+import { PaymentModel } from '@/interfaces';
+
+export default class SubscriptionViaLicense extends Subscription<PaymentModel> {
+  /**
+   * Subscripe to the given plan.
+   * @param {Plan} plan
+   * @throws {NotAllowedChangeSubscriptionPlan}
+   */
+  public async subscribe(
+    tenant: Tenant,
+    plan: Plan,
+    paymentModel?: PaymentModel,
+    subscriptionSlug: string = 'main'
+  ): Promise<void> {
+    await this.paymentContext.makePayment(paymentModel, plan);
+
+    return this.newSubscriptionFromLicense(
+      tenant,
+      plan,
+      paymentModel.licenseCode,
+      subscriptionSlug
+    );
+  }
+
+  /**
+   * New subscription from the given license.
+   * @param {Tanant} tenant 
+   * @param {Plab} plan 
+   * @param {string} licenseCode 
+   * @param {string} subscriptionSlug 
+   * @returns {Promise<void>}
+   */
+  private async newSubscriptionFromLicense(
+    tenant,
+    plan,
+    licenseCode: string,
+    subscriptionSlug: string = 'main'
+  ): Promise<void> {
+    // License information.
+    const licenseInfo = await License.query().findOne(
+      'licenseCode',
+      licenseCode
+    );
+    return this.newSubscribtion(
+      tenant,
+      plan,
+      licenseInfo.periodInterval,
+      licenseInfo.licensePeriod,
+      subscriptionSlug
+    );
+  }
+}
diff --git a/packages/server/src/services/Tenancy/SystemService.ts b/packages/server/src/services/Tenancy/SystemService.ts
new file mode 100644
index 000000000..dac5a4320
--- /dev/null
+++ b/packages/server/src/services/Tenancy/SystemService.ts
@@ -0,0 +1,25 @@
+import Container from 'typedi';
+import { Service } from 'typedi';
+
+@Service()
+export default class HasSystemService implements SystemService {
+  private container(key: string) {
+    return Container.get(key);
+  }
+
+  knex() {
+    return this.container('knex');
+  }
+
+  repositories() {
+    return this.container('repositories');
+  }
+
+  cache() {
+    return this.container('cache');
+  }
+
+  dbManager() {
+    return this.container('dbManager');
+  }
+}
diff --git a/packages/server/src/services/Tenancy/TenancyService.ts b/packages/server/src/services/Tenancy/TenancyService.ts
new file mode 100644
index 000000000..68414c827
--- /dev/null
+++ b/packages/server/src/services/Tenancy/TenancyService.ts
@@ -0,0 +1,132 @@
+import { Container, Service, Inject } from 'typedi';
+import TenantsManagerService from '@/services/Tenancy/TenantsManager';
+import tenantModelsLoader from '@/loaders/tenantModels';
+import tenantRepositoriesLoader from '@/loaders/tenantRepositories';
+import tenantCacheLoader from '@/loaders/tenantCache';
+import SmsClientLoader from '@/loaders/smsClient';
+
+@Service()
+export default class HasTenancyService {
+  @Inject()
+  tenantsManager: TenantsManagerService;
+
+  /**
+   * Retrieve the given tenant container.
+   * @param  {number} tenantId
+   * @return {Container}
+   */
+  tenantContainer(tenantId: number) {
+    return Container.of(`tenant-${tenantId}`);
+  }
+
+  /**
+   * Singleton tenant service.
+   * @param {number} tenantId - Tenant id.
+   * @param {string} key - Service key.
+   * @param {Function} callback
+   */
+  singletonService(tenantId: number, key: string, callback: Function) {
+    const container = this.tenantContainer(tenantId);
+    const Logger = Container.get('logger');
+    const hasServiceInstnace = container.has(key);
+
+    if (!hasServiceInstnace) {
+      const serviceInstance = callback();
+
+      container.set(key, serviceInstance);
+      Logger.info(`[tenant_DI] ${key} injected to tenant container.`, {
+        tenantId,
+        key,
+      });
+
+      return serviceInstance;
+    } else {
+      return container.get(key);
+    }
+  }
+
+  /**
+   * Retrieve knex instance of the given tenant id.
+   * @param {number} tenantId
+   */
+  knex(tenantId: number) {
+    return this.singletonService(tenantId, 'tenantManager', () => {
+      return this.tenantsManager.getKnexInstance(tenantId);
+    });
+  }
+
+  /**
+   * Retrieve models of the givne tenant id.
+   * @param {number} tenantId - The tenant id.
+   */
+  models(tenantId: number) {
+    const knexInstance = this.knex(tenantId);
+
+    return this.singletonService(tenantId, 'models', () => {
+      return tenantModelsLoader(knexInstance);
+    });
+  }
+
+  /**
+   * Retrieve repositories of the given tenant id.
+   * @param {number} tenantId - Tenant id.
+   */
+  repositories(tenantId: number) {
+    return this.singletonService(tenantId, 'repositories', () => {
+      const cache = this.cache(tenantId);
+      const knex = this.knex(tenantId);
+      const i18n = this.i18n(tenantId);
+
+      return tenantRepositoriesLoader(knex, cache, i18n);
+    });
+  }
+
+  /**
+   * Sets i18n locals function.
+   * @param {number} tenantId
+   * @param locals
+   */
+  setI18nLocals(tenantId: number, locals: any) {
+    return this.singletonService(tenantId, 'i18n', () => {
+      return locals;
+    });
+  }
+
+  /**
+   * Retrieve i18n locales methods.
+   * @param {number} tenantId - Tenant id.
+   */
+  i18n(tenantId: number) {
+    return this.singletonService(tenantId, 'i18n', () => {
+      throw new Error('I18n locals is not set yet.');
+    });
+  }
+
+  /**
+   * Retrieve tenant cache instance.
+   * @param {number} tenantId - Tenant id.
+   */
+  cache(tenantId: number) {
+    return this.singletonService(tenantId, 'cache', () => {
+      return tenantCacheLoader(tenantId);
+    });
+  }
+
+  settings(tenantId: number) {
+    return this.singletonService(tenantId, 'settings', () => {
+      throw new Error('Settings is not injected yet.');
+    });
+  }
+
+  smsClient(tenantId: number) {
+    return this.singletonService(tenantId, 'smsClient', () => {
+      const settings = this.settings(tenantId);
+
+      const token = settings.get({
+        group: 'sms_integration',
+        key: 'easysms_token',
+      });
+      return SmsClientLoader(token);
+    });
+  }
+}
diff --git a/packages/server/src/services/Tenancy/TenantDBManager.ts b/packages/server/src/services/Tenancy/TenantDBManager.ts
new file mode 100644
index 000000000..981256f9c
--- /dev/null
+++ b/packages/server/src/services/Tenancy/TenantDBManager.ts
@@ -0,0 +1,153 @@
+import { Container } from 'typedi';
+import Knex from 'knex';
+import { knexSnakeCaseMappers } from 'objection';
+import { tenantKnexConfig, tenantSeedConfig } from '@/config/knexConfig';
+import config from '@/config';
+import { ITenant, ITenantDBManager } from '@/interfaces';
+import SystemService from '@/services/Tenancy/SystemService';
+import { TenantDBAlreadyExists } from '@/exceptions';
+
+export default class TenantDBManager implements ITenantDBManager {
+  static knexCache: { [key: string]: Knex } = {};
+
+  // System database manager.
+  dbManager: any;
+
+  // System knex instance.
+  sysKnex: Knex;
+
+  /**
+   * Constructor method.
+   * @param {ITenant} tenant
+   */
+  constructor() {
+    const systemService = Container.get(SystemService);
+
+    this.dbManager = systemService.dbManager();
+    this.sysKnex = systemService.knex();
+  }
+
+  /**
+   * Retrieve the tenant database name.
+   * @return {string}
+   */
+  private getDatabaseName(tenant: ITenant) {
+    return `${config.tenant.db_name_prefix}${tenant.organizationId}`;
+  }
+
+  /**
+   * Detarmines the tenant database weather exists.
+   * @return {Promise<boolean>}
+   */
+  public async databaseExists(tenant: ITenant) {
+    const databaseName = this.getDatabaseName(tenant);
+
+    const results = await this.sysKnex.raw(
+      'SELECT * FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = "' +
+        databaseName +
+        '"'
+    );
+    return results[0].length > 0;
+  }
+
+  /**
+   * Creates a tenant database.
+   * @throws {TenantAlreadyInitialized}
+   * @return {Promise<void>}
+   */
+  public async createDatabase(tenant: ITenant): Promise<void> {
+    await this.throwErrorIfTenantDBExists(tenant);
+
+    const databaseName = this.getDatabaseName(tenant);
+    await this.dbManager.createDb(databaseName);
+  }
+
+  /**
+   * Dropdowns the tenant database if it was exist.
+   * @param {ITenant} tenant -
+   */
+  public async dropDatabaseIfExists(tenant: ITenant) {
+    const isExists = await this.databaseExists(tenant);
+
+    if (!isExists) {
+      return;
+    }
+
+    await this.dropDatabase(tenant);
+  }
+
+  /**
+   * dropdowns the tenant's database.
+   * @param {ITenant} tenant
+   */
+  public async dropDatabase(tenant: ITenant) {
+    const databaseName = this.getDatabaseName(tenant);
+
+    await this.dbManager.dropDb(databaseName);
+  }
+
+  /**
+   * Migrate tenant database schema to the latest version.
+   * @return {Promise<void>}
+   */
+  public async migrate(tenant: ITenant): Promise<void> {
+    const knex = this.setupKnexInstance(tenant);
+
+    await knex.migrate.latest();
+  }
+
+  /**
+   * Seeds initial data to the tenant database.
+   * @return {Promise<void>}
+   */
+  public async seed(tenant: ITenant): Promise<void> {
+    const knex = this.setupKnexInstance(tenant);
+
+    await knex.migrate.latest({
+      ...tenantSeedConfig(tenant),
+      disableMigrationsListValidation: true,
+    });
+  }
+
+  /**
+   * Retrieve the knex instance of tenant.
+   * @return {Knex}
+   */
+  public setupKnexInstance(tenant: ITenant) {
+    const key: string = `${tenant.id}`;
+    let knexInstance = TenantDBManager.knexCache[key];
+
+    if (!knexInstance) {
+      knexInstance = Knex({
+        ...tenantKnexConfig(tenant),
+        ...knexSnakeCaseMappers({ upperCase: true }),
+      });
+      TenantDBManager.knexCache[key] = knexInstance;
+    }
+    return knexInstance;
+  }
+
+  /**
+   * Retrieve knex instance from the givne tenant.
+   */
+  public getKnexInstance(tenantId: number) {
+    const key: string = `${tenantId}`;
+    let knexInstance = TenantDBManager.knexCache[key];
+
+    if (!knexInstance) {
+      throw new Error('Knex instance is not initialized yut.');
+    }
+    return knexInstance;
+  }
+
+  /**
+   * Throws error if the tenant database already exists.
+   * @return {Promise<void>}
+   */
+  async throwErrorIfTenantDBExists(tenant: ITenant) {
+    const isExists = await this.databaseExists(tenant);
+    if (isExists) {
+      throw new TenantDBAlreadyExists();
+    }
+  }
+}
diff --git a/packages/server/src/services/Tenancy/TenantService.ts b/packages/server/src/services/Tenancy/TenantService.ts
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/server/src/services/Tenancy/TenantsManager.ts b/packages/server/src/services/Tenancy/TenantsManager.ts
new file mode 100644
index 000000000..f152fc6ad
--- /dev/null
+++ b/packages/server/src/services/Tenancy/TenantsManager.ts
@@ -0,0 +1,197 @@
+import { Container, Inject, Service } from 'typedi';
+import { ITenantManager, ITenant, ITenantDBManager } from '@/interfaces';
+import {
+  EventDispatcherInterface,
+  EventDispatcher,
+} from 'decorators/eventDispatcher';
+import {
+  TenantAlreadyInitialized,
+  TenantAlreadySeeded,
+  TenantDatabaseNotBuilt,
+} from '@/exceptions';
+import TenantDBManager from '@/services/Tenancy/TenantDBManager';
+import events from '@/subscribers/events';
+import { Tenant } from '@/system/models';
+import { SeedMigration } from '@/lib/Seeder/SeedMigration';
+import i18n from '../../loaders/i18n';
+
+const ERRORS = {
+  TENANT_ALREADY_CREATED: 'TENANT_ALREADY_CREATED',
+  TENANT_NOT_EXISTS: 'TENANT_NOT_EXISTS',
+};
+
+// Tenants manager service.
+@Service()
+export default class TenantsManagerService implements ITenantManager {
+  static instances: { [key: number]: ITenantManager } = {};
+
+  @EventDispatcher()
+  private eventDispatcher: EventDispatcherInterface;
+
+  @Inject('repositories')
+  private sysRepositories: any;
+
+  private tenantDBManager: ITenantDBManager;
+
+  /**
+   * Constructor method.
+   */
+  constructor() {
+    this.tenantDBManager = new TenantDBManager();
+  }
+
+  /**
+   * Creates a new teant with unique organization id.
+   * @param {ITenant} tenant
+   * @return {Promise<ITenant>}
+   */
+  public async createTenant(): Promise<ITenant> {
+    const { tenantRepository } = this.sysRepositories;
+    const tenant = await tenantRepository.createWithUniqueOrgId();
+
+    return tenant;
+  }
+
+  /**
+   * Creates a new tenant database.
+   * @param {ITenant} tenant -
+   * @return {Promise<void>}
+   */
+  public async createDatabase(tenant: ITenant): Promise<void> {
+    this.throwErrorIfTenantAlreadyInitialized(tenant);
+
+    await this.tenantDBManager.createDatabase(tenant);
+
+    this.eventDispatcher.dispatch(events.tenantManager.databaseCreated);
+  }
+
+  /**
+   * Drops the database if the given tenant.
+   * @param {number} tenantId
+   */
+  async dropDatabaseIfExists(tenant: ITenant) {
+    // Drop the database if exists.
+    await this.tenantDBManager.dropDatabaseIfExists(tenant);
+  }
+
+  /**
+   * Detarmines the tenant has database.
+   * @param   {ITenant} tenant
+   * @returns {Promise<boolean>}
+   */
+  public async hasDatabase(tenant: ITenant): Promise<boolean> {
+    return this.tenantDBManager.databaseExists(tenant);
+  }
+
+  /**
+   * Migrates the tenant database.
+   * @param  {ITenant} tenant
+   * @return {Promise<void>}
+   */
+  public async migrateTenant(tenant: ITenant): Promise<void> {
+    // Throw error if the tenant already initialized.
+    this.throwErrorIfTenantAlreadyInitialized(tenant);
+
+    // Migrate the database tenant.
+    await this.tenantDBManager.migrate(tenant);
+
+    // Mark the tenant as initialized.
+    await Tenant.markAsInitialized(tenant.id);
+
+    // Triggers `onTenantMigrated` event.
+    this.eventDispatcher.dispatch(events.tenantManager.tenantMigrated, {
+      tenantId: tenant.id,
+    });
+  }
+
+  /**
+   * Seeds the tenant database.
+   * @param  {ITenant} tenant
+   * @return {Promise<void>}
+   */
+  public async seedTenant(tenant: ITenant, tenancyContext): Promise<void> {
+    // Throw error if the tenant is not built yet.
+    this.throwErrorIfTenantNotBuilt(tenant);
+
+    // Throw error if the tenant is not seeded yet.
+    this.throwErrorIfTenantAlreadySeeded(tenant);
+
+    // Seeds the organization database data.
+    await new SeedMigration(tenancyContext.knex, tenancyContext).latest();
+
+    // Mark the tenant as seeded in specific date.
+    await Tenant.markAsSeeded(tenant.id);
+
+    // Triggers `onTenantSeeded` event.
+    this.eventDispatcher.dispatch(events.tenantManager.tenantSeeded, {
+      tenantId: tenant.id,
+    });
+  }
+
+  /**
+   * Initialize knex instance or retrieve the instance of cache map.
+   * @param {ITenant} tenant
+   * @returns {Knex}
+   */
+  public setupKnexInstance(tenant: ITenant) {
+    return this.tenantDBManager.setupKnexInstance(tenant);
+  }
+
+  /**
+   * Retrieve tenant knex instance or throw error in case was not initialized.
+   * @param {number} tenantId
+   * @returns {Knex}
+   */
+  public getKnexInstance(tenantId: number) {
+    return this.tenantDBManager.getKnexInstance(tenantId);
+  }
+
+  /**
+   * Throws error if the tenant already seeded.
+   * @throws {TenantAlreadySeeded}
+   */
+  private throwErrorIfTenantAlreadySeeded(tenant: ITenant) {
+    if (tenant.seededAt) {
+      throw new TenantAlreadySeeded();
+    }
+  }
+
+  /**
+   * Throws error if the tenant database is not built yut.
+   * @param {ITenant} tenant
+   */
+  private throwErrorIfTenantNotBuilt(tenant: ITenant) {
+    if (!tenant.initializedAt) {
+      throw new TenantDatabaseNotBuilt();
+    }
+  }
+
+  /**
+   * Throws error if the tenant already migrated.
+   * @throws {TenantAlreadyInitialized}
+   */
+  private throwErrorIfTenantAlreadyInitialized(tenant: ITenant) {
+    if (tenant.initializedAt) {
+      throw new TenantAlreadyInitialized();
+    }
+  }
+
+  /**
+   * Initialize seed migration contxt.
+   * @param {ITenant} tenant
+   * @returns
+   */
+  public getSeedMigrationContext(tenant: ITenant) {
+    // Initialize the knex instance.
+    const knex = this.setupKnexInstance(tenant);
+    const i18nInstance = i18n();
+
+    i18nInstance.setLocale(tenant.metadata.language);
+
+    return {
+      knex,
+      i18n: i18nInstance,
+      tenant,
+    };
+  }
+}
diff --git a/packages/server/src/services/TransactionsLocking/CommandTransactionsLockingService.ts b/packages/server/src/services/TransactionsLocking/CommandTransactionsLockingService.ts
new file mode 100644
index 000000000..23722822f
--- /dev/null
+++ b/packages/server/src/services/TransactionsLocking/CommandTransactionsLockingService.ts
@@ -0,0 +1,214 @@
+import { Service, Inject } from 'typedi';
+import { omit } from 'lodash';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import {
+  ICancelTransactionsLockingDTO,
+  ITransactionLockingPartiallyDTO,
+  ITransactionMeta,
+  ITransactionsLockingAllDTO,
+  ITransactionsLockingCanceled,
+  ITransactionsLockingPartialUnlocked,
+  TransactionsLockingGroup,
+  TransactionsLockingType,
+} from '@/interfaces';
+import TransactionsLockingRepository from './TransactionsLockingRepository';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+
+const Modules = ['all', 'sales', 'purchases', 'financial'];
+
+@Service()
+export default class TransactionsLockingService {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  transactionsLockingRepo: TransactionsLockingRepository;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  /**
+   * Enable/disable all  transacations locking.
+   * @param   {number} tenantId
+   * @param   {TransactionsLockingGroup} moduleGroup -
+   * @param   {Partial<ITransactionsLockingAllDTO>} allLockingDTO
+   * @returns {Promise<ITransactionMeta>}
+   */
+  public commandTransactionsLocking = async (
+    tenantId: number,
+    module: TransactionsLockingGroup = TransactionsLockingGroup.All,
+    transactionLockingDTO: Partial<ITransactionsLockingAllDTO>
+  ): Promise<ITransactionMeta> => {
+    // Validate the transaction locking module.
+    this.validateTransactionsLockingModule(module);
+
+    // Saves all transactions locking settings.
+    await this.transactionsLockingRepo.saveTransactionsLocking(
+      tenantId,
+      module,
+      {
+        active: true,
+        lockToDate: transactionLockingDTO.lockToDate,
+        lockReason: transactionLockingDTO.reason,
+      }
+    );
+    // Flag transactions locking type.
+    await this.transactionsLockingRepo.flagTransactionsLockingType(
+      tenantId,
+      module === TransactionsLockingGroup.All
+        ? TransactionsLockingType.All
+        : TransactionsLockingType.Partial
+    );
+    // Triggers `onTransactionLockingPartialUnlocked` event.
+    await this.eventPublisher.emitAsync(
+      events.transactionsLocking.partialUnlocked,
+      {
+        tenantId,
+        module,
+        transactionLockingDTO,
+      } as ITransactionsLockingPartialUnlocked
+    );
+    // Retrieve the transaction locking meta of the given
+    return this.transactionsLockingRepo.getTransactionsLocking(
+      tenantId,
+      module
+    );
+  };
+
+  /**
+   * Cancels the full transactions locking.
+   * @param   {number} tenantId
+   * @param   {TransactionsLockingGroup} moduleGroup
+   * @param   {ICancelTransactionsLockingDTO} cancelLockingDTO
+   * @returns {Promise<ITransactionMeta>}
+   */
+  public cancelTransactionLocking = async (
+    tenantId: number,
+    module: TransactionsLockingGroup = TransactionsLockingGroup.All,
+    cancelLockingDTO: ICancelTransactionsLockingDTO
+  ): Promise<ITransactionMeta> => {
+    // Validate the transaction locking module.
+    this.validateTransactionsLockingModule(module);
+
+    // Saves transactions locking.
+    await this.transactionsLockingRepo.saveTransactionsLocking(
+      tenantId,
+      module,
+      {
+        active: false,
+        unlockFromDate: '',
+        unlockToDate: '',
+        unlockReason: cancelLockingDTO.reason,
+      }
+    );
+    // Reset flag transactions locking type to partial.
+    await this.transactionsLockingRepo.flagTransactionsLockingType(
+      tenantId,
+      TransactionsLockingType.Partial
+    );
+    // Triggers `onTransactionLockingPartialUnlocked` event.
+    await this.eventPublisher.emitAsync(
+      events.transactionsLocking.partialUnlocked,
+      {
+        tenantId,
+        module,
+        cancelLockingDTO,
+      } as ITransactionsLockingCanceled
+    );
+    return this.transactionsLockingRepo.getTransactionsLocking(
+      tenantId,
+      module
+    );
+  };
+
+  /**
+   * Unlock tranactions locking partially.
+   * @param   {number} tenantId
+   * @param   {TransactionsLockingGroup} moduleGroup
+   * @param   {ITransactionLockingPartiallyDTO} partialTransactionLockingDTO
+   * @returns {Promise<ITransactionMeta>}
+   */
+  public unlockTransactionsLockingPartially = async (
+    tenantId: number,
+    moduleGroup: TransactionsLockingGroup = TransactionsLockingGroup.All,
+    partialTransactionLockingDTO: ITransactionLockingPartiallyDTO
+  ): Promise<ITransactionMeta> => {
+    // Validate the transaction locking module.
+    this.validateTransactionsLockingModule(moduleGroup);
+
+    // Retrieve the current transactions locking type.
+    const lockingType =
+      this.transactionsLockingRepo.getTransactionsLockingType(tenantId);
+
+    if (moduleGroup !== TransactionsLockingGroup.All) {
+      this.validateLockingTypeNotAll(lockingType);
+    }
+    // Saves transactions locking settings.
+    await this.transactionsLockingRepo.saveTransactionsLocking(
+      tenantId,
+      moduleGroup,
+      {
+        ...omit(partialTransactionLockingDTO, ['reason']),
+        partialUnlockReason: partialTransactionLockingDTO.reason,
+      }
+    );
+    // Retrieve transaction locking meta of the given module.
+    return this.transactionsLockingRepo.getTransactionsLocking(
+      tenantId,
+      moduleGroup
+    );
+  };
+
+  /**
+   * Cancel partial transactions unlocking.
+   * @param {number} tenantId
+   * @param {TransactionsLockingGroup} moduleGroup
+   */
+  public cancelPartialTransactionsUnlock = async (
+    tenantId: number,
+    module: TransactionsLockingGroup = TransactionsLockingGroup.All
+  ) => {
+    // Validate the transaction locking module.
+    this.validateTransactionsLockingModule(module);
+
+    // Saves transactions locking settings.
+    await this.transactionsLockingRepo.saveTransactionsLocking(
+      tenantId,
+      module,
+      { unlockFromDate: '', unlockToDate: '', partialUnlockReason: '' }
+    );
+  };
+
+  /**
+   * Validates the transaction locking type not partial.
+   * @param {number} tenantId
+   */
+  public validateLockingTypeNotPartial = (lockingType: string) => {
+    if (lockingType === TransactionsLockingType.Partial) {
+      throw new ServiceError(ERRORS.TRANSACTION_LOCKING_PARTIAL);
+    }
+  };
+
+  /**
+   * Validates the transaction locking type not all.
+   * @param {number} tenantId
+   */
+  public validateLockingTypeNotAll = (lockingType: string) => {
+    if (lockingType === TransactionsLockingType.All) {
+      throw new ServiceError(ERRORS.TRANSACTION_LOCKING_ALL);
+    }
+  };
+
+  /**
+   * Validate transactions locking module.
+   * @param {string} module
+   */
+  public validateTransactionsLockingModule = (module: string) => {
+    if (Modules.indexOf(module) === -1) {
+      throw new ServiceError(ERRORS.TRANSACTIONS_LOCKING_MODULE_NOT_FOUND);
+    }
+  };
+}
diff --git a/packages/server/src/services/TransactionsLocking/FinancialTransactionLockingGuard.ts b/packages/server/src/services/TransactionsLocking/FinancialTransactionLockingGuard.ts
new file mode 100644
index 000000000..5cc2e8b45
--- /dev/null
+++ b/packages/server/src/services/TransactionsLocking/FinancialTransactionLockingGuard.ts
@@ -0,0 +1,26 @@
+import { Service, Inject } from 'typedi';
+import TransactionsLockingGuard from './TransactionsLockingGuard';
+import { TransactionsLockingGroup } from '@/interfaces';
+
+@Service()
+export default class FinancialTransactionLocking {
+  @Inject()
+  transactionLockingGuardService: TransactionsLockingGuard;
+
+  /**
+   * Validates the transaction locking of cashflow command action.
+   * @param {number} tenantId
+   * @param {Date} transactionDate
+   * @throws {ServiceError(TRANSACTIONS_DATE_LOCKED)}
+   */
+  public transactionLockingGuard = (
+    tenantId: number,
+    transactionDate: Date
+  ) => {
+    this.transactionLockingGuardService.transactionsLockingGuard(
+      tenantId, 
+      transactionDate,
+      TransactionsLockingGroup.Financial
+    );
+  };
+}
diff --git a/packages/server/src/services/TransactionsLocking/FinancialsTransactionLockingGuardSubscriber.ts b/packages/server/src/services/TransactionsLocking/FinancialsTransactionLockingGuardSubscriber.ts
new file mode 100644
index 000000000..4ceb4dd76
--- /dev/null
+++ b/packages/server/src/services/TransactionsLocking/FinancialsTransactionLockingGuardSubscriber.ts
@@ -0,0 +1,335 @@
+import { Inject, Service } from 'typedi';
+import FinancialTransactionLocking from './FinancialTransactionLockingGuard';
+import events from '@/subscribers/events';
+import {
+  ICommandCashflowCreatingPayload,
+  ICommandCashflowDeletingPayload,
+  IExpenseCreatingPayload,
+  IExpenseDeletingPayload,
+  IExpenseEventEditingPayload,
+  IInventoryAdjustmentCreatingPayload,
+  IInventoryAdjustmentDeletingPayload,
+  IInventoryAdjustmentPublishingPayload,
+  IManualJournalCreatingPayload,
+  IExpensePublishingPayload,
+  IManualJournalEditingPayload,
+  IManualJournalPublishingPayload,
+} from '@/interfaces';
+
+@Service()
+export default class FinancialTransactionLockingGuardSubscriber {
+  @Inject()
+  financialTransactionsLocking: FinancialTransactionLocking;
+
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  public attach = (bus) => {
+    // Manual journals.
+    bus.subscribe(
+      events.manualJournals.onCreating,
+      this.transactionsLockingGuardOnManualJournalCreating
+    );
+    bus.subscribe(
+      events.manualJournals.onEditing,
+      this.transactionsLockingGuardOnManualJournalEditing
+    );
+    bus.subscribe(
+      events.manualJournals.onDeleting,
+      this.transactionsLockingGuardOnManualJournalDeleting
+    );
+    bus.subscribe(
+      events.manualJournals.onPublishing,
+      this.transactionsLockingGuardOnManualJournalPublishing
+    );
+    // Expenses
+    bus.subscribe(
+      events.expenses.onCreating,
+      this.transactionsLockingGuardOnExpenseCreating
+    );
+    bus.subscribe(
+      events.expenses.onEditing,
+      this.transactionsLockingGuardOnExpenseEditing
+    );
+    bus.subscribe(
+      events.expenses.onDeleting,
+      this.transactionsLockingGuardOnExpenseDeleting
+    );
+    bus.subscribe(
+      events.expenses.onPublishing,
+      this.transactionsLockingGuardOnExpensePublishing
+    );
+    // Cashflow
+    bus.subscribe(
+      events.cashflow.onTransactionCreating,
+      this.transactionsLockingGuardOnCashflowTransactionCreating
+    );
+    bus.subscribe(
+      events.cashflow.onTransactionDeleting,
+      this.transactionsLockingGuardOnCashflowTransactionDeleting
+    );
+    // Inventory adjustment.
+    bus.subscribe(
+      events.inventoryAdjustment.onQuickCreating,
+      this.transactionsLockingGuardOnInventoryAdjCreating
+    );
+    bus.subscribe(
+      events.inventoryAdjustment.onDeleting,
+      this.transactionLockingGuardOnInventoryAdjDeleting
+    );
+    bus.subscribe(
+      events.inventoryAdjustment.onPublishing,
+      this.transactionLockingGuardOnInventoryAdjPublishing
+    );
+  };
+
+  /**
+   * ---------------------------------------------
+   * - MANUAL JOURNALS SERVICE.
+   * ---------------------------------------------
+   */
+
+  /**
+   * Transaction locking guard on manual journal creating.
+   * @param {IManualJournalCreatingPayload} payload
+   */
+  private transactionsLockingGuardOnManualJournalCreating = async ({
+    tenantId,
+    manualJournalDTO,
+  }: IManualJournalCreatingPayload) => {
+    // Can't continue if the new journal is not published yet.
+    if (!manualJournalDTO.publish) return;
+
+    await this.financialTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      manualJournalDTO.date
+    );
+  };
+
+  /**
+   * Transactions locking guard on manual journal deleting.
+   * @param {IManualJournalEditingPayload} payload
+   */
+  private transactionsLockingGuardOnManualJournalDeleting = async ({
+    tenantId,
+    oldManualJournal,
+  }: IManualJournalEditingPayload) => {
+    // Can't continue if the old journal is not published.
+    if (!oldManualJournal.isPublished) return;
+
+    await this.financialTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldManualJournal.date
+    );
+  };
+
+  /**
+   * Transactions locking guard on manual journal editing.
+   * @param {IManualJournalDeletingPayload} payload
+   */
+  private transactionsLockingGuardOnManualJournalEditing = async ({
+    tenantId,
+    oldManualJournal,
+    manualJournalDTO,
+  }: IManualJournalEditingPayload) => {
+    // Can't continue if the old and new journal are not published.
+    if (!oldManualJournal.isPublished && !manualJournalDTO.publish) return;
+   
+    // Validate the old journal date.
+    await this.financialTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldManualJournal.date
+    );
+    // Validate the new journal date.
+    await this.financialTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      manualJournalDTO.date
+    );
+  };
+
+  /**
+   * Transactions locking guard on manual journal publishing.
+   * @param {IManualJournalPublishingPayload}
+   */
+  private transactionsLockingGuardOnManualJournalPublishing = async ({
+    oldManualJournal,
+    tenantId,
+  }: IManualJournalPublishingPayload) => {
+    await this.financialTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldManualJournal.date
+    );
+  };
+
+  /**
+   * ---------------------------------------------
+   * - EXPENSES SERVICE.
+   * ---------------------------------------------
+   */
+
+  /**
+   * Transactions locking guard on expense creating.
+   * @param {IExpenseCreatingPayload} payload
+   */
+  private transactionsLockingGuardOnExpenseCreating = async ({
+    expenseDTO,
+    tenantId,
+  }: IExpenseCreatingPayload) => {
+    // Can't continue if the new expense is not published yet.
+    if (!expenseDTO.publish) return;
+
+    await this.financialTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      expenseDTO.paymentDate
+    );
+  };
+
+  /**
+   * Transactions locking guard on expense deleting.
+   * @param {IExpenseDeletingPayload} payload
+   */
+  private transactionsLockingGuardOnExpenseDeleting = async ({
+    tenantId,
+    oldExpense,
+  }: IExpenseDeletingPayload) => {
+    // Can't continue if expense transaction is not published.
+    if (!oldExpense.isPublished) return;
+
+    await this.financialTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldExpense.paymentDate
+    );
+  };
+
+  /**
+   * Transactions locking guard on expense editing.
+   * @param {IExpenseEventEditingPayload}
+   */
+  private transactionsLockingGuardOnExpenseEditing = async ({
+    tenantId,
+    oldExpense,
+    expenseDTO,
+  }: IExpenseEventEditingPayload) => {
+    // Can't continue if the old and new expense is not published.
+    if (!oldExpense.isPublished && !expenseDTO.publish) return;
+
+    // Validate the old expense date.
+    await this.financialTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldExpense.paymentDate
+    );
+    // Validate the new expense date.
+    await this.financialTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      expenseDTO.paymentDate
+    );
+  };
+
+  /**
+   * Transactions locking guard on expense publishing.
+   * @param {IExpensePublishingPayload} payload -
+   */
+  private transactionsLockingGuardOnExpensePublishing = async ({
+    tenantId,
+    oldExpense,
+  }: IExpensePublishingPayload) => {
+    await this.financialTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldExpense.paymentDate
+    );
+  };
+
+  /**
+   * ---------------------------------------------
+   * - CASHFLOW SERVICE.
+   * ---------------------------------------------
+   */
+
+  /**
+   * Transactions locking guard on cashflow transaction creating.
+   * @param {ICommandCashflowCreatingPayload}
+   */
+  private transactionsLockingGuardOnCashflowTransactionCreating = async ({
+    tenantId,
+    newTransactionDTO,
+  }: ICommandCashflowCreatingPayload) => {
+    if (!newTransactionDTO.publish) return;
+
+    await this.financialTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      newTransactionDTO.date
+    );
+  };
+
+  /**
+   * Transactions locking guard on cashflow transaction deleting.
+   * @param {ICommandCashflowDeletingPayload}
+   */
+  private transactionsLockingGuardOnCashflowTransactionDeleting = async ({
+    tenantId,
+    oldCashflowTransaction,
+  }: ICommandCashflowDeletingPayload) => {
+    // Can't continue if the cashflow transaction is not published.
+    if (!oldCashflowTransaction.isPublished) return;
+
+    await this.financialTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldCashflowTransaction.date
+    );
+  };
+
+  /**
+   * ---------------------------------------------
+   * - INVENTORY ADJUSTMENT SERVICE.
+   * ---------------------------------------------
+   */
+
+  /**
+   * Transactions locking guard on inventory adjustment creating.
+   * @param {IInventoryAdjustmentCreatingPayload} payload -
+   */
+  private transactionsLockingGuardOnInventoryAdjCreating = async ({
+    tenantId,
+    quickAdjustmentDTO,
+  }: IInventoryAdjustmentCreatingPayload) => {
+    // Can't locking if the new adjustment is not published yet.
+    if (!quickAdjustmentDTO.publish) return;
+
+    await this.financialTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      quickAdjustmentDTO.date
+    );
+  };
+
+  /**
+   * Transaction locking guard on inventory adjustment deleting.
+   * @param {IInventoryAdjustmentDeletingPayload} payload
+   */
+  private transactionLockingGuardOnInventoryAdjDeleting = async ({
+    tenantId,
+    oldInventoryAdjustment,
+  }: IInventoryAdjustmentDeletingPayload) => {
+    // Can't locking if the adjustment is published yet.
+    if (!oldInventoryAdjustment.isPublished) return;
+
+    await this.financialTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldInventoryAdjustment.date
+    );
+  };
+
+  /**
+   * Transaction locking guard on inventory adjustment publishing.
+   * @param {IInventoryAdjustmentPublishingPayload} payload
+   */
+  private transactionLockingGuardOnInventoryAdjPublishing = async ({
+    tenantId,
+    oldInventoryAdjustment,
+  }: IInventoryAdjustmentPublishingPayload) => {
+    await this.financialTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldInventoryAdjustment.date
+    );
+  };
+}
diff --git a/packages/server/src/services/TransactionsLocking/PurchasesTransactionLockingGuard.ts b/packages/server/src/services/TransactionsLocking/PurchasesTransactionLockingGuard.ts
new file mode 100644
index 000000000..060ed51e1
--- /dev/null
+++ b/packages/server/src/services/TransactionsLocking/PurchasesTransactionLockingGuard.ts
@@ -0,0 +1,25 @@
+import { Service, Inject } from 'typedi';
+import TransactionsLockingGuard from './TransactionsLockingGuard';
+import { TransactionsLockingGroup } from '@/interfaces';
+
+@Service()
+export default class PurchasesTransactionLocking {
+  @Inject()
+  transactionLockingGuardService: TransactionsLockingGuard;
+
+  /**
+   * Validates the transaction locking of purchases services commands.
+   * @param {number} tenantId
+   * @param {Date} transactionDate
+   */
+  public transactionLockingGuard = async (
+    tenantId: number,
+    transactionDate: Date
+  ) => {
+    this.transactionLockingGuardService.transactionsLockingGuard(
+      tenantId, 
+      transactionDate,
+      TransactionsLockingGroup.Purchases
+    );
+  };
+}
diff --git a/packages/server/src/services/TransactionsLocking/PurchasesTransactionLockingGuardSubscriber.ts b/packages/server/src/services/TransactionsLocking/PurchasesTransactionLockingGuardSubscriber.ts
new file mode 100644
index 000000000..96e537893
--- /dev/null
+++ b/packages/server/src/services/TransactionsLocking/PurchasesTransactionLockingGuardSubscriber.ts
@@ -0,0 +1,286 @@
+import { Inject } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  IBillCreatingPayload,
+  IBillEditingPayload,
+  IBillEventDeletingPayload,
+  IBillPaymentCreatingPayload,
+  IBillPaymentDeletingPayload,
+  IBillPaymentEditingPayload,
+  IRefundVendorCreditCreatingPayload,
+  IRefundVendorCreditDeletingPayload,
+  IVendorCreditCreatingPayload,
+  IVendorCreditDeletingPayload,
+  IVendorCreditEditingPayload,
+} from '@/interfaces';
+import PurchasesTransactionsLocking from './PurchasesTransactionLockingGuard';
+
+export default class PurchasesTransactionLockingGuardSubscriber {
+  @Inject()
+  purchasesTransactionsLocking: PurchasesTransactionsLocking;
+
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  public attach = (bus) => {
+    // Bills
+    bus.subscribe(
+      events.bill.onCreating,
+      this.transactionLockingGuardOnBillCreating
+    );
+    bus.subscribe(
+      events.bill.onEditing,
+      this.transactionLockingGuardOnBillEditing
+    );
+    bus.subscribe(
+      events.bill.onDeleting,
+      this.transactionLockingGuardOnBillDeleting
+    );
+    // Payment mades.
+    bus.subscribe(
+      events.billPayment.onCreating,
+      this.transactionLockingGuardOnPaymentCreating
+    );
+    bus.subscribe(
+      events.billPayment.onEditing,
+      this.transactionLockingGuardOnPaymentEditing
+    );
+    bus.subscribe(
+      events.billPayment.onDeleting,
+      this.transactionLockingGuardOnPaymentDeleting
+    );
+    // Vendor credits.
+    bus.subscribe(
+      events.vendorCredit.onCreating,
+      this.transactionLockingGuardOnVendorCreditCreating
+    );
+    bus.subscribe(
+      events.vendorCredit.onDeleting,
+      this.transactionLockingGuardOnVendorCreditDeleting
+    );
+    bus.subscribe(
+      events.vendorCredit.onEditing,
+      this.transactionLockingGuardOnVendorCreditEditing
+    );
+    bus.subscribe(
+      events.vendorCredit.onRefundCreating,
+      this.transactionLockingGuardOnRefundVendorCredit
+    );
+    bus.subscribe(
+      events.vendorCredit.onRefundDeleting,
+      this.transactionLockingGuardOnRefundCreditDeleting
+    );
+  };
+
+  /**
+   * ---------------------------------------------
+   * PAYMENT MADES.
+   * ---------------------------------------------
+   */
+
+  /**
+   * Transaction locking guard on payment editing.
+   * @param {IBillPaymentEditingPayload}
+   */
+  private transactionLockingGuardOnPaymentEditing = async ({
+    tenantId,
+    oldBillPayment,
+    billPaymentDTO,
+  }: IBillPaymentEditingPayload) => {
+    // Validate old payment date.
+    await this.purchasesTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldBillPayment.paymentDate
+    );
+    // Validate the new payment date.
+    await this.purchasesTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      billPaymentDTO.paymentDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on payment creating.
+   * @param {IBillPaymentCreatingPayload}
+   */
+  private transactionLockingGuardOnPaymentCreating = async ({
+    tenantId,
+    billPaymentDTO,
+  }: IBillPaymentCreatingPayload) => {
+    await this.purchasesTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      billPaymentDTO.paymentDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on payment deleting.
+   * @param {IBillPaymentDeletingPayload} payload -
+   */
+  private transactionLockingGuardOnPaymentDeleting = async ({
+    tenantId,
+    oldBillPayment,
+  }: IBillPaymentDeletingPayload) => {
+    await this.purchasesTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldBillPayment.paymentDate
+    );
+  };
+
+  /**
+   * ---------------------------------------------
+   * BILLS.
+   * ---------------------------------------------
+   */
+
+  /**
+   * Transaction locking guard on bill creating.
+   * @param {IBillCreatingPayload} payload
+   */
+  private transactionLockingGuardOnBillCreating = async ({
+    tenantId,
+    billDTO,
+  }: IBillCreatingPayload) => {
+    // Can't continue if the new bill is not published.
+    if (!billDTO.open) return;
+
+    await this.purchasesTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      billDTO.billDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on bill editing.
+   * @param {IBillEditingPayload} payload
+   */
+  private transactionLockingGuardOnBillEditing = async ({
+    oldBill,
+    tenantId,
+    billDTO,
+  }: IBillEditingPayload) => {
+    // Can't continue if the old and new bill are not published.
+    if (!oldBill.isOpen && !billDTO.open) return;
+
+    // Validate the old bill date.
+    await this.purchasesTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldBill.billDate
+    );
+    // Validate the new bill date.
+    await this.purchasesTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      billDTO.billDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on bill deleting.
+   * @param {IBillEventDeletingPayload} payload
+   */
+  private transactionLockingGuardOnBillDeleting = async ({
+    tenantId,
+    oldBill,
+  }: IBillEventDeletingPayload) => {
+    // Can't continue if the old bill is not published.
+    if (!oldBill.isOpen) return;
+
+    await this.purchasesTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldBill.billDate
+    );
+  };
+
+  /**
+   * ---------------------------------------------
+   * VENDOR CREDITS.
+   * ---------------------------------------------
+   */
+
+  /**
+   * Transaction locking guard on vendor credit creating.
+   * @param {IVendorCreditCreatingPayload} payload
+   */
+  private transactionLockingGuardOnVendorCreditCreating = async ({
+    tenantId,
+    vendorCreditCreateDTO,
+  }: IVendorCreditCreatingPayload) => {
+    // Can't continue if the new vendor credit is not published.
+    if (!vendorCreditCreateDTO.open) return;
+
+    await this.purchasesTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      vendorCreditCreateDTO.vendorCreditDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on vendor credit deleting.
+   * @param {IVendorCreditDeletingPayload} payload
+   */
+  private transactionLockingGuardOnVendorCreditDeleting = async ({
+    tenantId,
+    oldVendorCredit,
+  }: IVendorCreditDeletingPayload) => {
+    // Can't continue if the old vendor credit is not open.
+    if (!oldVendorCredit.isOpen) return;
+
+    await this.purchasesTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldVendorCredit.vendorCreditDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on vendor credit editing.
+   * @param {IVendorCreditEditingPayload} payload
+   */
+  private transactionLockingGuardOnVendorCreditEditing = async ({
+    tenantId,
+    oldVendorCredit,
+    vendorCreditDTO,
+  }: IVendorCreditEditingPayload) => {
+    // Can't continue if the old and new vendor credit are not published.
+    if (!oldVendorCredit.isPublished && !vendorCreditDTO.open) return;
+
+    // Validate the old credit date.
+    await this.purchasesTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldVendorCredit.vendorCreditDate
+    );
+    // Validate the new credit date.
+    await this.purchasesTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      vendorCreditDTO.vendorCreditDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on refund vendor credit creating.
+   * @param {IRefundVendorCreditCreatingPayload} payload -
+   */
+  private transactionLockingGuardOnRefundVendorCredit = async ({
+    tenantId,
+    refundVendorCreditDTO,
+  }: IRefundVendorCreditCreatingPayload) => {
+    await this.purchasesTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      refundVendorCreditDTO.date
+    );
+  };
+
+  /**
+   * Transaction locking guard on refund vendor credit deleting.
+   * @param {IRefundVendorCreditDeletingPayload} payload
+   */
+  private transactionLockingGuardOnRefundCreditDeleting = async ({
+    tenantId,
+    oldRefundCredit,
+  }: IRefundVendorCreditDeletingPayload) => {
+    await this.purchasesTransactionsLocking.transactionLockingGuard(
+      tenantId,
+      oldRefundCredit.date
+    );
+  };
+}
diff --git a/packages/server/src/services/TransactionsLocking/QueryTransactionsLocking.ts b/packages/server/src/services/TransactionsLocking/QueryTransactionsLocking.ts
new file mode 100644
index 000000000..4112f63b3
--- /dev/null
+++ b/packages/server/src/services/TransactionsLocking/QueryTransactionsLocking.ts
@@ -0,0 +1,93 @@
+import { Service, Inject } from 'typedi';
+import {
+  ITransactionLockingMetaPOJO,
+  ITransactionsLockingListPOJO,
+  ITransactionsLockingSchema,
+  TransactionsLockingGroup,
+} from '@/interfaces';
+import { TRANSACTIONS_LOCKING_SCHEMA } from './constants';
+import TransactionsLockingMetaTransformer from './TransactionsLockingMetaTransformer';
+import TransactionsLockingRepository from './TransactionsLockingRepository';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export default class QueryTransactionsLocking {
+  @Inject()
+  private transactionsLockingRepo: TransactionsLockingRepository;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieve transactions locking modules.
+   * @param   {number} tenantId
+   * @returns {ITransactionLockingMetaPOJO[]}
+   */
+  public getTransactionsLockingModules = (
+    tenantId: number
+  ): Promise<ITransactionLockingMetaPOJO[]> => {
+    const modules = TRANSACTIONS_LOCKING_SCHEMA.map(
+      (schema: ITransactionsLockingSchema) =>
+        this.getTransactionsLockingModuleMeta(tenantId, schema.module)
+    );
+    return Promise.all(modules);
+  };
+
+  /**
+   * Retireve the transactions locking all module.
+   * @param   {number} tenantId
+   * @returns {ITransactionLockingMetaPOJO}
+   */
+  public getTransactionsLockingAll = (
+    tenantId: number
+  ): Promise<ITransactionLockingMetaPOJO> => {
+    return this.getTransactionsLockingModuleMeta(
+      tenantId,
+      TransactionsLockingGroup.All
+    );
+  };
+
+  /**
+   * Retrieve the transactions locking module meta.
+   * @param   {number} tenantId -
+   * @param   {TransactionsLockingGroup} module -
+   * @returns {ITransactionLockingMetaPOJO}
+   */
+  public getTransactionsLockingModuleMeta = (
+    tenantId: number,
+    module: TransactionsLockingGroup
+  ): Promise<ITransactionLockingMetaPOJO> => {
+    const meta = this.transactionsLockingRepo.getTransactionsLocking(
+      tenantId,
+      module
+    );
+    return this.transformer.transform(
+      tenantId,
+      meta,
+      new TransactionsLockingMetaTransformer(),
+      { module }
+    );
+  };
+
+  /**
+   * Retrieve transactions locking list.
+   * @param   {number} tenantId
+   * @returns {Promise<ITransactionsLockingListPOJO>}
+   */
+  public getTransactionsLockingList = async (
+    tenantId: number
+  ): Promise<ITransactionsLockingListPOJO> => {
+    // Retrieve the current transactions locking type.
+    const lockingType =
+      this.transactionsLockingRepo.getTransactionsLockingType(tenantId);
+
+    const all = await this.getTransactionsLockingAll(tenantId);
+    const modules = await this.getTransactionsLockingModules(tenantId);
+
+    return {
+      lockingType,
+      all,
+      modules,
+    };
+  };
+}
diff --git a/packages/server/src/services/TransactionsLocking/SalesTransactionLockingGuard.ts b/packages/server/src/services/TransactionsLocking/SalesTransactionLockingGuard.ts
new file mode 100644
index 000000000..2363fa296
--- /dev/null
+++ b/packages/server/src/services/TransactionsLocking/SalesTransactionLockingGuard.ts
@@ -0,0 +1,25 @@
+import { Service, Inject } from 'typedi';
+import TransactionsLockingGuard from './TransactionsLockingGuard';
+import { TransactionsLockingGroup } from '@/interfaces';
+
+@Service()
+export default class SalesTransactionLocking {
+  @Inject()
+  transactionLockingGuardService: TransactionsLockingGuard;
+
+  /**
+   * Validates the transaction locking of sales services commands.
+   * @param {number} tenantId
+   * @param {Date} transactionDate
+   */
+  public transactionLockingGuard = async (
+    tenantId: number,
+    transactionDate: Date
+  ) => {
+    await this.transactionLockingGuardService.transactionsLockingGuard(
+      tenantId,
+      transactionDate,
+      TransactionsLockingGroup.Sales
+    );
+  };
+}
diff --git a/packages/server/src/services/TransactionsLocking/SalesTransactionLockingGuardSubscriber.ts b/packages/server/src/services/TransactionsLocking/SalesTransactionLockingGuardSubscriber.ts
new file mode 100644
index 000000000..a2e55fc21
--- /dev/null
+++ b/packages/server/src/services/TransactionsLocking/SalesTransactionLockingGuardSubscriber.ts
@@ -0,0 +1,503 @@
+import { Service, Inject } from 'typedi';
+import {
+  ISaleReceiptCreatingPayload,
+  IRefundCreditNoteCreatingPayload,
+  ISaleInvoiceCreatingPaylaod,
+  ISaleReceiptDeletingPayload,
+  ICreditNoteDeletingPayload,
+  IPaymentReceiveCreatingPayload,
+  IRefundCreditNoteDeletingPayload,
+  IPaymentReceiveDeletingPayload,
+  ISaleEstimateDeletingPayload,
+  ISaleEstimateCreatingPayload,
+  ISaleEstimateEditingPayload,
+  ISaleInvoiceWriteoffCreatePayload,
+  ISaleInvoiceEditingPayload,
+  ISaleInvoiceDeletePayload,
+  ISaleInvoiceWrittenOffCancelPayload,
+  ICreditNoteEditingPayload,
+  ISaleReceiptEditingPayload,
+  IPaymentReceiveEditingPayload,
+  ISaleReceiptEventClosingPayload,
+  ICreditNoteCreatingPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import SalesTransactionLockingGuard from './SalesTransactionLockingGuard';
+
+@Service()
+export default class SalesTransactionLockingGuardSubscriber {
+  @Inject()
+  salesLockingGuard: SalesTransactionLockingGuard;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    // Sale invoice.
+    bus.subscribe(
+      events.saleInvoice.onCreating,
+      this.transactionLockingGuardOnInvoiceCreating
+    );
+    bus.subscribe(
+      events.saleInvoice.onEditing,
+      this.transactionLockingGuardOnInvoiceEditing
+    );
+    bus.subscribe(
+      events.saleInvoice.onWriteoff,
+      this.transactionLockinGuardOnInvoiceWritingoff
+    );
+    bus.subscribe(
+      events.saleInvoice.onWrittenoffCancel,
+      this.transactionLockinGuardOnInvoiceWritingoffCanceling
+    );
+    bus.subscribe(
+      events.saleInvoice.onDeleting,
+      this.transactionLockingGuardOnInvoiceDeleting
+    );
+
+    // Sale receipt
+    bus.subscribe(
+      events.saleReceipt.onCreating,
+      this.transactionLockingGuardOnReceiptCreating
+    );
+    bus.subscribe(
+      events.saleReceipt.onDeleting,
+      this.transactionLockingGuardOnReceiptDeleting
+    );
+    bus.subscribe(
+      events.saleReceipt.onEditing,
+      this.transactionLockingGuardOnReceiptEditing
+    );
+    bus.subscribe(
+      events.saleReceipt.onClosing,
+      this.transactionLockingGuardOnReceiptClosing
+    );
+
+    // Payment receive
+    bus.subscribe(
+      events.paymentReceive.onCreating,
+      this.transactionLockingGuardOnPaymentCreating
+    );
+    bus.subscribe(
+      events.paymentReceive.onEditing,
+      this.transactionLockingGuardOnPaymentEditing
+    );
+    bus.subscribe(
+      events.paymentReceive.onDeleting,
+      this.transactionLockingGuardPaymentDeleting
+    );
+
+    // Credit note.
+    bus.subscribe(
+      events.creditNote.onCreating,
+      this.transactionLockingGuardOnCreditCreating
+    );
+    bus.subscribe(
+      events.creditNote.onEditing,
+      this.transactionLockingGuardOnCreditEditing
+    );
+    bus.subscribe(
+      events.creditNote.onDeleting,
+      this.transactionLockingGuardOnCreditDeleting
+    );
+    bus.subscribe(
+      events.creditNote.onRefundCreating,
+      this.transactionLockingGuardOnCreditRefundCreating
+    );
+    bus.subscribe(
+      events.creditNote.onRefundDeleting,
+      this.transactionLockingGuardOnCreditRefundDeleteing
+    );
+
+    // Sale Estimate
+    bus.subscribe(
+      events.saleEstimate.onCreating,
+      this.transactionLockingGuardOnEstimateCreating
+    );
+    bus.subscribe(
+      events.saleEstimate.onDeleting,
+      this.transactionLockingGuardOnEstimateDeleting
+    );
+    bus.subscribe(
+      events.saleEstimate.onEditing,
+      this.transactionLockingGuardOnEstimateEditing
+    );
+  };
+
+  /**
+   * ---------------------------------------------
+   * SALES INVOICES.
+   * ---------------------------------------------
+   */
+
+  /**
+   * Transaction locking guard on invoice creating.
+   * @param {ISaleInvoiceCreatingPaylaod} payload
+   */
+  private transactionLockingGuardOnInvoiceCreating = async ({
+    saleInvoiceDTO,
+    tenantId,
+  }: ISaleInvoiceCreatingPaylaod) => {
+    // Can't continue if the new invoice is not published yet.
+    if (!saleInvoiceDTO.delivered) return;
+
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      saleInvoiceDTO.invoiceDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on invoice editing.
+   * @param {ISaleInvoiceEditingPayload} payload
+   */
+  private transactionLockingGuardOnInvoiceEditing = async ({
+    tenantId,
+    oldSaleInvoice,
+    saleInvoiceDTO,
+  }: ISaleInvoiceEditingPayload) => {
+    // Can't continue if the old and new invoice are not published yet.
+    if (!oldSaleInvoice.isDelivered && !saleInvoiceDTO.delivered) return;
+
+    // Validate the old invoice date.
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      oldSaleInvoice.invoiceDate
+    );
+    // Validate the new invoice date.
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      saleInvoiceDTO.invoiceDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on invoice deleting.
+   * @param {ISaleInvoiceDeletePayload} payload
+   */
+  private transactionLockingGuardOnInvoiceDeleting = async ({
+    saleInvoice,
+    tenantId,
+  }: ISaleInvoiceDeletePayload) => {
+    // Can't continue if the old invoice not published.
+    if (!saleInvoice.isDelivered) return;
+
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      saleInvoice.invoiceDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on invoice writingoff.
+   * @param {ISaleInvoiceWriteoffCreatePayload} payload
+   */
+  private transactionLockinGuardOnInvoiceWritingoff = async ({
+    tenantId,
+    saleInvoice,
+  }: ISaleInvoiceWriteoffCreatePayload) => {
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      saleInvoice.invoiceDate
+    );
+  };
+
+  /**
+   * Transaciton locking guard on canceling written-off invoice.
+   * @param {ISaleInvoiceWrittenOffCancelPayload} payload
+   */
+  private transactionLockinGuardOnInvoiceWritingoffCanceling = async ({
+    tenantId,
+    saleInvoice,
+  }: ISaleInvoiceWrittenOffCancelPayload) => {
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      saleInvoice.invoiceDate
+    );
+  };
+
+  /**
+   * ---------------------------------------------
+   * SALES RECEIPTS.
+   * ---------------------------------------------
+   */
+
+  /**
+   * Transaction  locking guard on receipt creating.
+   * @param {ISaleReceiptCreatingPayload}
+   */
+  private transactionLockingGuardOnReceiptCreating = async ({
+    tenantId,
+    saleReceiptDTO,
+  }: ISaleReceiptCreatingPayload) => {
+    // Can't continue if the sale receipt is not published.
+    if (!saleReceiptDTO.closed) return;
+
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      saleReceiptDTO.receiptDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on receipt creating.
+   * @param {ISaleReceiptDeletingPayload}
+   */
+  private transactionLockingGuardOnReceiptDeleting = async ({
+    tenantId,
+    oldSaleReceipt,
+  }: ISaleReceiptDeletingPayload) => {
+    if (!oldSaleReceipt.isClosed) return;
+
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      oldSaleReceipt.receiptDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on sale receipt editing.
+   * @param {ISaleReceiptEditingPayload} payload
+   */
+  private transactionLockingGuardOnReceiptEditing = async ({
+    tenantId,
+    oldSaleReceipt,
+    saleReceiptDTO,
+  }: ISaleReceiptEditingPayload) => {
+    // Validate the old receipt date.
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      oldSaleReceipt.receiptDate
+    );
+    // Validate the new receipt date.
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      saleReceiptDTO.receiptDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on sale receipt closing.
+   * @param {ISaleReceiptEventClosingPayload} payload
+   */
+  private transactionLockingGuardOnReceiptClosing = async ({
+    tenantId,
+    oldSaleReceipt,
+  }: ISaleReceiptEventClosingPayload) => {
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      oldSaleReceipt.receiptDate
+    );
+  };
+
+  /**
+   * ---------------------------------------------
+   * CREDIT NOTES.
+   * ---------------------------------------------
+   */
+
+  /**
+   * Transaction locking guard on credit note deleting.
+   * @param {ICreditNoteDeletingPayload} payload -
+   */
+  private transactionLockingGuardOnCreditDeleting = async ({
+    oldCreditNote,
+    tenantId,
+  }: ICreditNoteDeletingPayload) => {
+    // Can't continue if the old credit is not published.
+    if (!oldCreditNote.isPublished) return;
+
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      oldCreditNote.creditNoteDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on credit note creating.
+   * @param {ICreditNoteCreatingPayload} payload
+   */
+  private transactionLockingGuardOnCreditCreating = async ({
+    tenantId,
+    creditNoteDTO,
+  }: ICreditNoteCreatingPayload) => {
+    // Can't continue if the new credit is still draft.
+    if (!creditNoteDTO.open) return;
+
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      creditNoteDTO.creditNoteDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on credit note editing.
+   * @param {ICreditNoteEditingPayload} payload -
+   */
+  private transactionLockingGuardOnCreditEditing = async ({
+    creditNoteEditDTO,
+    oldCreditNote,
+    tenantId,
+  }: ICreditNoteEditingPayload) => {
+    // Can't continue if the new and old credit note are not published yet.
+    if (!creditNoteEditDTO.open && !oldCreditNote.isPublished) return;
+
+    // Validate the old credit date.
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      oldCreditNote.creditNoteDate
+    );
+    // Validate the new credit date.
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      creditNoteEditDTO.creditNoteDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on payment deleting.
+   * @param {IRefundCreditNoteDeletingPayload} paylaod -
+   */
+  private transactionLockingGuardOnCreditRefundDeleteing = async ({
+    tenantId,
+    oldRefundCredit,
+  }: IRefundCreditNoteDeletingPayload) => {
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      oldRefundCredit.date
+    );
+  };
+
+  /**
+   * Transaction locking guard on refund credit note creating.
+   * @param {IRefundCreditNoteCreatingPayload} payload -
+   */
+  private transactionLockingGuardOnCreditRefundCreating = async ({
+    tenantId,
+    newCreditNoteDTO,
+  }: IRefundCreditNoteCreatingPayload) => {
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      newCreditNoteDTO.date
+    );
+  };
+
+  /**
+   * ---------------------------------------------
+   * SALES ESTIMATES.
+   * ---------------------------------------------
+   */
+
+  /**
+   * Transaction locking guard on estimate creating.
+   * @param {ISaleEstimateCreatingPayload} payload -
+   */
+  private transactionLockingGuardOnEstimateCreating = async ({
+    estimateDTO,
+    tenantId,
+  }: ISaleEstimateCreatingPayload) => {
+    // Can't continue if the new estimate is not published yet.
+    if (!estimateDTO.delivered) return;
+
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      estimateDTO.estimateDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on estimate deleting.
+   * @param {ISaleEstimateDeletingPayload} payload
+   */
+  private transactionLockingGuardOnEstimateDeleting = async ({
+    oldSaleEstimate,
+    tenantId,
+  }: ISaleEstimateDeletingPayload) => {
+    // Can't continue if the old estimate is not published.
+    if (!oldSaleEstimate.isDelivered) return;
+
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      oldSaleEstimate.estimateDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on estimate editing.
+   * @param {ISaleEstimateEditingPayload} payload
+   */
+  private transactionLockingGuardOnEstimateEditing = async ({
+    tenantId,
+    oldSaleEstimate,
+    estimateDTO,
+  }: ISaleEstimateEditingPayload) => {
+    // Can't continue if the new and old estimate transactions are not published yet.
+    if (!estimateDTO.delivered && !oldSaleEstimate.isDelivered) return;
+
+    // Validate the old estimate date.
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      oldSaleEstimate.estimateDate
+    );
+    // Validate the new estimate date.
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      estimateDTO.estimateDate
+    );
+  };
+
+  /**
+   * ---------------------------------------------
+   * PAYMENT RECEIVES.
+   * ---------------------------------------------
+   */
+
+  /**
+   * Transaction locking guard on payment receive editing.
+   * @param {IPaymentReceiveEditingPayload}
+   */
+  private transactionLockingGuardOnPaymentEditing = async ({
+    tenantId,
+    oldPaymentReceive,
+    paymentReceiveDTO,
+  }: IPaymentReceiveEditingPayload) => {
+    // Validate the old payment date.
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      oldPaymentReceive.paymentDate
+    );
+    // Validate the new payment date.
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      paymentReceiveDTO.paymentDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on payment creating.
+   * @param {IPaymentReceiveCreatingPayload}
+   */
+  private transactionLockingGuardOnPaymentCreating = async ({
+    tenantId,
+    paymentReceiveDTO,
+  }: IPaymentReceiveCreatingPayload) => {
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      paymentReceiveDTO.paymentDate
+    );
+  };
+
+  /**
+   * Transaction locking guard on payment deleting.
+   * @param {IPaymentReceiveDeletingPayload} payload -
+   */
+  private transactionLockingGuardPaymentDeleting = async ({
+    oldPaymentReceive,
+    tenantId,
+  }: IPaymentReceiveDeletingPayload) => {
+    await this.salesLockingGuard.transactionLockingGuard(
+      tenantId,
+      oldPaymentReceive.paymentDate
+    );
+  };
+}
diff --git a/packages/server/src/services/TransactionsLocking/TransactionsLockingGuard.ts b/packages/server/src/services/TransactionsLocking/TransactionsLockingGuard.ts
new file mode 100644
index 000000000..ef6829679
--- /dev/null
+++ b/packages/server/src/services/TransactionsLocking/TransactionsLockingGuard.ts
@@ -0,0 +1,121 @@
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ServiceError, ServiceErrors } from '@/exceptions';
+import { TransactionsLockingGroup } from '@/interfaces';
+import TransactionsLockingRepository from './TransactionsLockingRepository';
+import { ERRORS } from './constants';
+
+@Service()
+export default class TransactionsLockingGuard {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  transactionsLockingRepo: TransactionsLockingRepository;
+
+  /**
+   * Detarmines whether the transaction date between the locking date period.
+   * @param {number} tenantId
+   * @param {Date} transactionDate
+   * @param {TransactionsLockingGroup} lockingGroup
+   * @returns {boolean}
+   */
+  public isTransactionsLocking = (
+    tenantId: number,
+    transactionDate: Date,
+    lockingGroup: string = TransactionsLockingGroup.All
+  ): boolean => {
+    const { isEnabled, unlockFromDate, unlockToDate, lockToDate } =
+      this.transactionsLockingRepo.getTransactionsLocking(
+        tenantId,
+        lockingGroup
+      );
+    // Returns false anyway in case if the transaction locking is disabled.
+    if (!isEnabled) return false;
+
+    const inLockingDate = moment(transactionDate).isSameOrBefore(lockToDate);
+    const inUnlockDate =
+      unlockFromDate && unlockToDate
+        ? moment(transactionDate).isSameOrAfter(unlockFromDate) &&
+          moment(transactionDate).isSameOrBefore(unlockFromDate)
+        : false;
+
+    // Retruns true in case the transaction date between locking date
+    // and not between unlocking date.
+    return !!(isEnabled && inLockingDate && !inUnlockDate);
+  };
+
+  /**
+   * Validates the transaction date between the locking date period
+   * or throw service error.
+   * @param {number} tenantId
+   * @param {Date} transactionDate
+   * @param {TransactionsLockingGroup} lockingGroup
+   *
+   * @throws {ServiceError}
+   */
+  public validateTransactionsLocking = (
+    tenantId: number,
+    transactionDate: Date,
+    lockingGroup: TransactionsLockingGroup
+  ) => {
+    const isLocked = this.isTransactionsLocking(
+      tenantId,
+      transactionDate,
+      lockingGroup
+    );
+    if (isLocked) {
+      this.throwTransactionsLockError(tenantId, lockingGroup);
+    }
+  };
+
+  /**
+   * Throws transactions locking error.
+   * @param {number} tenantId
+   * @param {TransactionsLockingGroup} lockingGroup
+   */
+  public throwTransactionsLockError = (
+    tenantId: number,
+    lockingGroup: TransactionsLockingGroup
+  ) => {
+    const { lockToDate } = this.transactionsLockingRepo.getTransactionsLocking(
+      tenantId,
+      lockingGroup
+    );
+    throw new ServiceError(ERRORS.TRANSACTIONS_DATE_LOCKED, null, {
+      lockedToDate: lockToDate,
+      formattedLockedToDate: moment(lockToDate).format('YYYY/MM/DD'),
+    });
+  };
+
+  /**
+   * Validate the transaction locking of the given locking group and transaction date.
+   * @param {number} tenantId -
+   * @param {TransactionsLockingGroup} lockingGroup - transaction group
+   * @param {Date} fromDate -
+   */
+  public transactionsLockingGuard = (
+    tenantId: number,
+    transactionDate: Date,
+    moduleType: TransactionsLockingGroup
+  ) => {
+    const lockingType =
+      this.transactionsLockingRepo.getTransactionsLockingType(tenantId);
+
+    //
+    if (lockingType === TransactionsLockingGroup.All) {
+      return this.validateTransactionsLocking(
+        tenantId,
+        transactionDate,
+        TransactionsLockingGroup.All
+      );
+    }
+    //
+    return this.validateTransactionsLocking(
+      tenantId,
+      transactionDate,
+      moduleType
+    );
+  };
+}
diff --git a/packages/server/src/services/TransactionsLocking/TransactionsLockingMetaTransformer.ts b/packages/server/src/services/TransactionsLocking/TransactionsLockingMetaTransformer.ts
new file mode 100644
index 000000000..f9a04e4ac
--- /dev/null
+++ b/packages/server/src/services/TransactionsLocking/TransactionsLockingMetaTransformer.ts
@@ -0,0 +1,83 @@
+import { get } from 'lodash';
+import { TransactionsLockingGroup } from '@/interfaces';
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { getTransactionsLockingSchemaMeta } from './constants';
+
+export default class TransactionsLockingMetaTransformer extends Transformer {
+  /**
+   * Include these attributes to sale credit note object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'module',
+      'formattedModule',
+      'description',
+      'formattedLockToDate',
+      'formattedUnlockFromDate',
+      'formattedUnlockToDate',
+    ];
+  };
+
+  /**
+   * Module slug.
+   * @returns {string}
+   */
+  protected module = () => {
+    return this.options.module;
+  };
+
+  /**
+   * Formatted module name.
+   * @returns {string}
+   */
+  protected formattedModule = () => {
+    return this.options.module === TransactionsLockingGroup.All
+      ? this.context.i18n.__('transactions_locking.module.all_transactions')
+      : this.context.i18n.__(
+          get(
+            getTransactionsLockingSchemaMeta(this.options.module),
+            'formattedModule'
+          )
+        );
+  };
+
+  /**
+   * Module description.
+   * @returns {string}
+   */
+  protected description = () => {
+    return this.options.module === TransactionsLockingGroup.All
+      ? ''
+      : this.context.i18n.__(
+          get(
+            getTransactionsLockingSchemaMeta(this.options.module),
+            'description'
+          )
+        );
+  };
+
+  /**
+   * Formatted unlock to date.
+   * @returns {string}
+   */
+  protected formattedUnlockToDate = (item) => {
+    return item.unlockToDate ? this.formatDate(item.unlockToDate) : '';
+  };
+
+  /**
+   * Formatted unlock from date.
+   * @returns {string}
+   */
+  protected formattedUnlockFromDate = (item) => {
+    return item.unlockFromDate ? this.formatDate(item.unlockFromDate) : '';
+  };
+
+  /**
+   * Formatted lock to date.
+   * @returns {string}
+   */
+  protected formattedLockToDate = (item) => {
+    return item.lockToDate ? this.formatDate(item.lockToDate) : '';
+  };
+}
diff --git a/packages/server/src/services/TransactionsLocking/TransactionsLockingRepository.ts b/packages/server/src/services/TransactionsLocking/TransactionsLockingRepository.ts
new file mode 100644
index 000000000..53bca9758
--- /dev/null
+++ b/packages/server/src/services/TransactionsLocking/TransactionsLockingRepository.ts
@@ -0,0 +1,151 @@
+import { Service, Inject } from 'typedi';
+import { isUndefined } from 'lodash';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import {
+  ITransactionMeta,
+  TransactionsLockingGroup,
+  TransactionsLockingType,
+} from '@/interfaces';
+import { parseDate } from 'utils';
+
+@Service()
+export default class TransactionsLockingRepository {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  async saveTransactionsLocking(
+    tenantId: number,
+    lockingGroup: string = TransactionsLockingGroup.All,
+    transactionlocking
+  ) {
+    const settings = this.tenancy.settings(tenantId);
+    const group = `transactions-locking`;
+
+    if (!isUndefined(transactionlocking.active)) {
+      settings.set({
+        group,
+        key: `${lockingGroup}.active`,
+        value: transactionlocking.active,
+      });
+    }
+    if (!isUndefined(transactionlocking.lockToDate)) {
+      settings.set({
+        group,
+        key: `${lockingGroup}.lock_to_date`,
+        value: parseDate(transactionlocking.lockToDate),
+      });
+    }
+    if (!isUndefined(transactionlocking.unlockFromDate)) {
+      settings.set({
+        group,
+        key: `${lockingGroup}.unlock_from_date`,
+        value: parseDate(transactionlocking.unlockFromDate),
+      });
+    }
+    if (!isUndefined(transactionlocking.unlockToDate)) {
+      settings.set({
+        group,
+        key: `${lockingGroup}.unlock_to_date`,
+        value: parseDate(transactionlocking.unlockToDate),
+      });
+    }
+    if (!isUndefined(transactionlocking.lockReason)) {
+      settings.set({
+        group,
+        key: `${lockingGroup}.lock_reason`,
+        value: transactionlocking.lockReason,
+      });
+    }
+    if (!isUndefined(transactionlocking.unlockReason)) {
+      settings.set({
+        group,
+        key: `${lockingGroup}.unlock_reason`,
+        value: transactionlocking.unlockReason,
+      });
+    }
+    if (!isUndefined(transactionlocking.partialUnlockReason)) {
+      settings.set({
+        group,
+        key: `${lockingGroup}.partial_unlock_reason`,
+        value: transactionlocking.partialUnlockReason,
+      });
+    }
+
+    await settings.save();
+  }
+
+  getTransactionsLocking(
+    tenantId: number,
+    lockingGroup: string = TransactionsLockingGroup.All
+  ): ITransactionMeta {
+    const settings = this.tenancy.settings(tenantId);
+    const group = `transactions-locking`;
+
+    const isEnabled = settings.get({ group, key: `${lockingGroup}.active` });
+
+    const lockFromDate = settings.get({
+      group,
+      key: `${lockingGroup}.lock_from_date`,
+    });
+    const lockToDate = settings.get({
+      group,
+      key: `${lockingGroup}.lock_to_date`,
+    });
+
+    const unlockFromDate = settings.get({
+      group,
+      key: `${lockingGroup}.unlock_from_date`,
+    });
+    const unlockToDate = settings.get({
+      group,
+      key: `${lockingGroup}.unlock_to_date`,
+    });
+
+    const lockReason = settings.get({
+      group,
+      key: `${lockingGroup}.lock_reason`,
+    });
+    const unlockReason = settings.get({
+      group,
+      key: `${lockingGroup}.unlock_reason`,
+    });
+    const partialUnlockReason = settings.get({
+      group,
+      key: `${lockingGroup}.partial_unlock_reason`,
+    });
+
+    return {
+      isEnabled,
+      lockToDate: lockToDate || null,
+      unlockFromDate: unlockFromDate || null,
+      unlockToDate: unlockToDate || null,
+      isPartialUnlock: Boolean(unlockToDate && unlockFromDate),
+      lockReason: lockReason || '',
+      unlockReason: unlockReason || '',
+      partialUnlockReason: partialUnlockReason || '',
+    };
+  }
+
+  getTransactionsLockingType(tenantId: number) {
+    const settings = this.tenancy.settings(tenantId);
+
+    const lockingType = settings.get({
+      group: 'transactions-locking',
+      key: 'locking-type',
+    });
+    return lockingType || 'partial';
+  }
+
+  flagTransactionsLockingType(
+    tenantId: number,
+    transactionsType: TransactionsLockingType
+  ) {
+    const settings = this.tenancy.settings(tenantId);
+
+    settings.set({
+      group: 'transactions-locking',
+      key: 'locking-type',
+      value: transactionsType,
+    });
+  }
+}
diff --git a/packages/server/src/services/TransactionsLocking/constants.ts b/packages/server/src/services/TransactionsLocking/constants.ts
new file mode 100644
index 000000000..01a2bd35e
--- /dev/null
+++ b/packages/server/src/services/TransactionsLocking/constants.ts
@@ -0,0 +1,36 @@
+import {
+  ITransactionsLockingSchema,
+  TransactionsLockingGroup,
+} from '@/interfaces';
+
+export const ERRORS = {
+  TRANSACTIONS_DATE_LOCKED: 'TRANSACTIONS_DATE_LOCKED',
+  TRANSACTION_LOCKING_PARTIAL: 'TRANSACTION_LOCKING_PARTIAL',
+  TRANSACTION_LOCKING_ALL: 'TRANSACTION_LOCKING_ALL',
+  TRANSACTIONS_LOCKING_MODULE_NOT_FOUND:
+    'TRANSACTIONS_LOCKING_MODULE_NOT_FOUND',
+};
+
+export const TRANSACTIONS_LOCKING_SCHEMA = [
+  {
+    module: 'sales',
+    formattedModule: 'transactions_locking.module.sales.label',
+    description: 'transactions_locking.module.sales.desc',
+  },
+  {
+    module: 'purchases',
+    formattedModule: 'transactions_locking.module.purchases.label',
+    description: 'transactions_locking.module.purchases.desc',
+  },
+  {
+    module: 'financial',
+    formattedModule: 'transactions_locking.module.financial.label',
+    description: 'transactions_locking.module.financial.desc',
+  },
+] as ITransactionsLockingSchema[];
+
+export function getTransactionsLockingSchemaMeta(
+  module: TransactionsLockingGroup
+): ITransactionsLockingSchema {
+  return TRANSACTIONS_LOCKING_SCHEMA.find((schema) => schema.module === module);
+}
diff --git a/packages/server/src/services/UnitOfWork/TransactionsHooks.ts b/packages/server/src/services/UnitOfWork/TransactionsHooks.ts
new file mode 100644
index 000000000..6cb75f726
--- /dev/null
+++ b/packages/server/src/services/UnitOfWork/TransactionsHooks.ts
@@ -0,0 +1,36 @@
+/**
+ * @param {any} maybeTrx
+ * @returns {maybeTrx is import('objection').TransactionOrKnex & { executionPromise: Promise<any> }}
+ */
+function checkIsTransaction(maybeTrx) {
+  return Boolean(maybeTrx && maybeTrx.executionPromise);
+}
+
+/**
+ * Wait for a transaction to be complete.
+ * @param {import('objection').TransactionOrKnex} [trx]
+ */
+export async function waitForTransaction(trx) {
+  return Promise.resolve(checkIsTransaction(trx) ? trx.executionPromise : null);
+}
+
+/**
+ * Run a callback when the transaction is done.
+ * @param {import('objection').TransactionOrKnex | undefined} trx
+ * @param {Function} callback
+ */
+export function runAfterTransaction(trx, callback) {
+  waitForTransaction(trx).then(
+    () => {
+      // If transaction success, then run action
+      return Promise.resolve(callback()).catch((error) => {
+        setTimeout(() => {
+          throw error;
+        });
+      });
+    },
+    () => {
+      // Ignore transaction error
+    }
+  );
+}
diff --git a/packages/server/src/services/UnitOfWork/index.ts b/packages/server/src/services/UnitOfWork/index.ts
new file mode 100644
index 000000000..c4c0c0dec
--- /dev/null
+++ b/packages/server/src/services/UnitOfWork/index.ts
@@ -0,0 +1,56 @@
+import { Service, Inject } from 'typedi';
+import TenancyService from '@/services/Tenancy/TenancyService';
+
+/**
+ * Enumeration that represents transaction isolation levels for use with the {@link Transactional} annotation
+ */
+export enum IsolationLevel {
+  /**
+   * A constant indicating that dirty reads, non-repeatable reads and phantom reads can occur.
+   */
+  READ_UNCOMMITTED = 'read uncommitted',
+  /**
+   * A constant indicating that dirty reads are prevented; non-repeatable reads and phantom reads can occur.
+   */
+  READ_COMMITTED = 'read committed',
+  /**
+   * A constant indicating that dirty reads and non-repeatable reads are prevented; phantom reads can occur.
+   */
+  REPEATABLE_READ = 'repeatable read',
+  /**
+   * A constant indicating that dirty reads, non-repeatable reads and phantom reads are prevented.
+   */
+  SERIALIZABLE = 'serializable',
+}
+
+@Service()
+export default class UnitOfWork {
+  @Inject()
+  tenancy: TenancyService;
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {} work
+   * @param {IsolationLevel} isolationLevel
+   * @returns {}
+   */
+  public withTransaction = async (
+    tenantId: number,
+    work,
+    isolationLevel: IsolationLevel = IsolationLevel.READ_UNCOMMITTED
+  ) => {
+    const knex = this.tenancy.knex(tenantId);
+    const trx = await knex.transaction({ isolationLevel });
+
+    try {
+      const result = await work(trx);
+      trx.commit();
+
+      return result;
+    } catch (error) {
+      trx.rollback();
+      throw error;
+    }
+  };
+}
diff --git a/packages/server/src/services/Users/PurgeUserAbilityCache.ts b/packages/server/src/services/Users/PurgeUserAbilityCache.ts
new file mode 100644
index 000000000..454306612
--- /dev/null
+++ b/packages/server/src/services/Users/PurgeUserAbilityCache.ts
@@ -0,0 +1,39 @@
+import events from '@/subscribers/events';
+import {
+  ITenantUserInactivatedPayload,
+  ITenantUserActivatedPayload,
+  ITenantUserDeletedPayload,
+  ITenantUserEditedPayload,
+} from '@/interfaces';
+import { ABILITIES_CACHE } from '../../api/middleware/AuthorizationMiddleware';
+
+export default class PurgeUserAbilityCache {
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  attach(bus) {
+    bus.subscribe(events.tenantUser.onEdited, this.purgeAuthorizedUserAbility);
+    bus.subscribe(
+      events.tenantUser.onActivated,
+      this.purgeAuthorizedUserAbility
+    );
+    bus.subscribe(
+      events.tenantUser.onInactivated,
+      this.purgeAuthorizedUserAbility
+    );
+  }
+
+  /**
+   * Purges authorized user ability once the user mutate.
+   */
+  purgeAuthorizedUserAbility({
+    tenantUser,
+  }:
+    | ITenantUserInactivatedPayload
+    | ITenantUserActivatedPayload
+    | ITenantUserDeletedPayload
+    | ITenantUserEditedPayload) {
+    ABILITIES_CACHE.del(tenantUser.systemUserId);
+  }
+}
diff --git a/packages/server/src/services/Users/SyncTenantUserSaved.ts b/packages/server/src/services/Users/SyncTenantUserSaved.ts
new file mode 100644
index 000000000..ab7f8224f
--- /dev/null
+++ b/packages/server/src/services/Users/SyncTenantUserSaved.ts
@@ -0,0 +1,71 @@
+import { pick } from 'lodash';
+import {
+  ITenantUser,
+  ITenantUserActivatedPayload,
+  ITenantUserDeletedPayload,
+  ITenantUserEditedPayload,
+  ITenantUserInactivatedPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import { SystemUser } from '@/system/models';
+
+export default class SyncTenantUserMutate {
+  /**
+   * Attaches events with handlers.
+   * @param bus
+   */
+  attach(bus) {
+    bus.subscribe(events.tenantUser.onEdited, this.syncSystemUserOnceEdited);
+    bus.subscribe(
+      events.tenantUser.onActivated,
+      this.syncSystemUserOnceActivated
+    );
+    bus.subscribe(
+      events.tenantUser.onInactivated,
+      this.syncSystemUserOnceInactivated
+    );
+  }
+  /**
+   *
+   * @param tenantUser
+   */
+  private syncSystemUserOnceEdited = async ({
+    tenantUser,
+  }: ITenantUserEditedPayload) => {
+    await SystemUser.query()
+      .where('id', tenantUser.systemUserId)
+      .patch({
+        ...pick(tenantUser, [
+          'firstName',
+          'lastName',
+          'email',
+          'active',
+          'phoneNumber',
+        ]),
+      });
+  };
+
+  /**
+   * Syncs activate system user.
+   * @param {ITenantUserInactivatedPayload} payload -
+   */
+  private syncSystemUserOnceActivated = async ({
+    tenantUser,
+  }: ITenantUserInactivatedPayload) => {
+    await SystemUser.query().where('id', tenantUser.systemUserId).patch({
+      active: true,
+    });
+  };
+
+  /**
+   * Syncs inactivate system user.
+   * @param {ITenantUserActivatedPayload} payload -
+   */
+  private syncSystemUserOnceInactivated = async ({
+    tenantUser,
+  }: ITenantUserActivatedPayload) => {
+    await SystemUser.query().where('id', tenantUser.systemUserId).patch({
+      active: false,
+    });
+  };
+}
diff --git a/packages/server/src/services/Users/UsersService.ts b/packages/server/src/services/Users/UsersService.ts
new file mode 100644
index 000000000..e6f15c36a
--- /dev/null
+++ b/packages/server/src/services/Users/UsersService.ts
@@ -0,0 +1,338 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import { ServiceError } from '@/exceptions';
+import {
+  IEditUserDTO,
+  ISystemUser,
+  ITenantUser,
+  ITenantUserActivatedPayload,
+  ITenantUserDeletedPayload,
+  ITenantUserEditedPayload,
+  ITenantUserInactivatedPayload,
+} from '@/interfaces';
+import RolesService from '@/services/Roles/RolesService';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ERRORS } from './constants';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+
+@Service()
+export default class UsersService {
+  @Inject('logger')
+  logger: any;
+
+  @Inject('repositories')
+  repositories: any;
+
+  @Inject()
+  rolesService: RolesService;
+
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  /**
+   * Creates a new user.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} userId - User id.
+   * @param {IUserDTO} editUserDTO - Edit user DTO.
+   * @return {Promise<ISystemUser>}
+   */
+  public async editUser(
+    tenantId: number,
+    userId: number,
+    editUserDTO: IEditUserDTO,
+    authorizedUser: ISystemUser
+  ): Promise<any> {
+    const { User } = this.tenancy.models(tenantId);
+    const { email, phoneNumber } = editUserDTO;
+
+    // Retrieve the tenant user or throw not found service error.
+    const oldTenantUser = await this.getTenantUserOrThrowError(
+      tenantId,
+      userId
+    );
+    // Validate cannot mutate the authorized user.
+    this.validateMutateRoleNotAuthorizedUser(
+      oldTenantUser,
+      editUserDTO,
+      authorizedUser
+    );
+    // Validate user email should be unique.
+    await this.validateUserEmailUniquiness(tenantId, email, userId);
+
+    // Validate user phone number should be unique.
+    await this.validateUserPhoneNumberUniqiness(tenantId, phoneNumber, userId);
+
+    // Retrieve the given role or throw not found service error.
+    const role = await this.rolesService.getRoleOrThrowError(
+      tenantId,
+      editUserDTO.roleId
+    );
+    // Updates the tenant user.
+    const tenantUser = await User.query().updateAndFetchById(userId, {
+      ...editUserDTO,
+    });
+    // Triggers `onTenantUserEdited` event.
+    await this.eventPublisher.emitAsync(events.tenantUser.onEdited, {
+      tenantId,
+      userId,
+      editUserDTO,
+      tenantUser,
+      oldTenantUser,
+    } as ITenantUserEditedPayload);
+
+    return tenantUser;
+  }
+
+  /**
+   * Deletes the given user id.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} userId - User id.
+   */
+  public async deleteUser(tenantId: number, userId: number): Promise<void> {
+    const { User } = this.tenancy.models(tenantId);
+
+    // Retrieve user details or throw not found service error.
+    const tenantUser = await this.getTenantUserOrThrowError(tenantId, userId);
+
+    // Validate the delete user should not be the last user.
+    await this.validateNotLastUserDelete(tenantId);
+
+    // Delete user from the storage.
+    await User.query().findById(userId).delete();
+
+    // Triggers `onTenantUserDeleted` event.
+    await this.eventPublisher.emitAsync(events.tenantUser.onDeleted, {
+      tenantId,
+      userId,
+      tenantUser,
+    } as ITenantUserDeletedPayload);
+  }
+
+  /**
+   * Activate the given user id.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} userId - User id.
+   * @return {Promise<void>}
+   */
+  public async activateUser(
+    tenantId: number,
+    userId: number,
+    authorizedUser: ISystemUser
+  ): Promise<void> {
+    const { User } = this.tenancy.models(tenantId);
+
+    // Throw service error if the given user is equals the authorized user.
+    this.throwErrorIfUserSameAuthorizedUser(userId, authorizedUser);
+
+    // Retrieve the user or throw not found service error.
+    const tenantUser = await this.getTenantUserOrThrowError(tenantId, userId);
+
+    // Throw serivce error if the user is already activated.
+    this.throwErrorIfUserActive(tenantUser);
+
+    // Marks the tenant user as active.
+    await User.query().findById(userId).update({ active: true });
+
+    // Triggers `onTenantUserActivated` event.
+    await this.eventPublisher.emitAsync(events.tenantUser.onActivated, {
+      tenantId,
+      userId,
+      authorizedUser,
+      tenantUser,
+    } as ITenantUserActivatedPayload);
+  }
+
+  /**
+   * Inactivate the given user id.
+   * @param {number} tenantId
+   * @param {number} userId
+   * @return {Promise<void>}
+   */
+  public async inactivateUser(
+    tenantId: number,
+    userId: number,
+    authorizedUser: ISystemUser
+  ): Promise<void> {
+    const { User } = this.tenancy.models(tenantId);
+
+    // Throw service error if the given user is equals the authorized user.
+    this.throwErrorIfUserSameAuthorizedUser(userId, authorizedUser);
+
+    // Retrieve the user or throw not found service error.
+    const tenantUser = await this.getTenantUserOrThrowError(tenantId, userId);
+
+    // Throw serivce error if the user is already inactivated.
+    this.throwErrorIfUserInactive(tenantUser);
+
+    // Marks the tenant user as active.
+    await User.query().findById(userId).update({ active: true });
+
+    // Triggers `onTenantUserActivated` event.
+    await this.eventPublisher.emitAsync(events.tenantUser.onInactivated, {
+      tenantId,
+      userId,
+      authorizedUser,
+      tenantUser,
+    } as ITenantUserInactivatedPayload);
+  }
+
+  /**
+   * Retrieve users list based on the given filter.
+   * @param {number} tenantId
+   * @param {object} filter
+   */
+  public async getList(tenantId: number) {
+    const { User } = this.tenancy.models(tenantId);
+
+    const users = await User.query().withGraphFetched('role');
+
+    return users;
+  }
+
+  /**
+   * Retrieve the given user details.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} userId - User id.
+   */
+  public async getUser(tenantId: number, userId: number) {
+    // Retrieve the system user.
+    const user = await this.getTenantUserOrThrowError(tenantId, userId);
+
+    return user;
+  }
+
+  /**
+   * Validate user existance throw error in case user was not found.,
+   * @param {number} tenantId -
+   * @param {number} userId -
+   * @returns {ISystemUser}
+   */
+  async getTenantUserOrThrowError(
+    tenantId: number,
+    userId: number
+  ): Promise<ITenantUser> {
+    const { User } = this.tenancy.models(tenantId);
+
+    const user = await User.query().findById(userId);
+
+    if (!user) {
+      throw new ServiceError(ERRORS.USER_NOT_FOUND);
+    }
+    return user;
+  }
+
+  /**
+   * Validate the delete user should not be the last user.
+   * @param {number} tenantId
+   */
+  private async validateNotLastUserDelete(tenantId: number) {
+    const { systemUserRepository } = this.repositories;
+
+    const usersFound = await systemUserRepository.find({ tenantId });
+
+    if (usersFound.length === 1) {
+      throw new ServiceError(ERRORS.CANNOT_DELETE_LAST_USER);
+    }
+  }
+
+  /**
+   * Throws service error in case the user was already active.
+   * @param {ISystemUser} user
+   * @throws {ServiceError}
+   */
+  private throwErrorIfUserActive(user: ISystemUser) {
+    if (user.active) {
+      throw new ServiceError(ERRORS.USER_ALREADY_ACTIVE);
+    }
+  }
+
+  /**
+   * Throws service error in case the user was already inactive.
+   * @param {ISystemUser} user
+   * @throws {ServiceError}
+   */
+  private throwErrorIfUserInactive(user: ITenantUser) {
+    if (!user.active) {
+      throw new ServiceError(ERRORS.USER_ALREADY_INACTIVE);
+    }
+  }
+
+  /**
+   * Throw service error in case the given user same the authorized user.
+   * @param {number} userId
+   * @param {ISystemUser} authorizedUser
+   */
+  private throwErrorIfUserSameAuthorizedUser(
+    userId: number,
+    authorizedUser: ISystemUser
+  ) {
+    if (userId === authorizedUser.id) {
+      throw new ServiceError(ERRORS.USER_SAME_THE_AUTHORIZED_USER);
+    }
+  }
+
+  /**
+   * Validate the given user email should be unique in the storage.
+   * @param {string} email
+   * @param {number} userId
+   */
+  private validateUserEmailUniquiness = async (
+    tenantId: number,
+    email: string,
+    userId: number
+  ) => {
+    const { User } = this.tenancy.models(tenantId);
+
+    const userByEmail = await User.query()
+      .findOne('email', email)
+      .whereNot('id', userId);
+
+    if (userByEmail) {
+      throw new ServiceError(ERRORS.EMAIL_ALREADY_EXISTS);
+    }
+  };
+
+  /**
+   * Validate user phone number should be unique.
+   * @param {string} phoneNumber -
+   * @param {number} userId -
+   */
+  private validateUserPhoneNumberUniqiness = async (
+    tenantId: number,
+    phoneNumber: string,
+    userId: number
+  ) => {
+    const { User } = this.tenancy.models(tenantId);
+
+    const userByPhoneNumber = await User.query()
+      .findOne('phone_number', phoneNumber)
+      .whereNot('id', userId);
+
+    if (userByPhoneNumber) {
+      throw new ServiceError(ERRORS.PHONE_NUMBER_ALREADY_EXIST);
+    }
+  };
+
+  /**
+   * Validate the authorized user cannot mutate its role.
+   * @param {ITenantUser} oldTenantUser 
+   * @param {IEditUserDTO} editUserDTO 
+   * @param {ISystemUser} authorizedUser 
+   */
+  validateMutateRoleNotAuthorizedUser(
+    oldTenantUser: ITenantUser,
+    editUserDTO: IEditUserDTO,
+    authorizedUser: ISystemUser
+  ) {
+    if (
+      authorizedUser.id === oldTenantUser.systemUserId &&
+      editUserDTO.roleId !== oldTenantUser.roleId
+    ) {
+      throw new ServiceError(ERRORS.CANNOT_AUTHORIZED_USER_MUTATE_ROLE);
+    }
+  }
+
+}
diff --git a/packages/server/src/services/Users/constants.ts b/packages/server/src/services/Users/constants.ts
new file mode 100644
index 000000000..e74dd0e21
--- /dev/null
+++ b/packages/server/src/services/Users/constants.ts
@@ -0,0 +1,10 @@
+export const ERRORS = {
+  CANNOT_DELETE_LAST_USER: 'CANNOT_DELETE_LAST_USER',
+  USER_ALREADY_ACTIVE: 'USER_ALREADY_ACTIVE',
+  USER_ALREADY_INACTIVE: 'USER_ALREADY_INACTIVE',
+  EMAIL_ALREADY_EXISTS: 'EMAIL_ALREADY_EXISTS',
+  PHONE_NUMBER_ALREADY_EXIST: 'PHONE_NUMBER_ALREADY_EXIST',
+  USER_NOT_FOUND: 'USER_NOT_FOUND',
+  USER_SAME_THE_AUTHORIZED_USER: 'USER_SAME_THE_AUTHORIZED_USER',
+  CANNOT_AUTHORIZED_USER_MUTATE_ROLE: 'CANNOT_AUTHORIZED_USER_MUTATE_ROLE'
+};
diff --git a/packages/server/src/services/Views/ViewsService.ts b/packages/server/src/services/Views/ViewsService.ts
new file mode 100644
index 000000000..d7426d527
--- /dev/null
+++ b/packages/server/src/services/Views/ViewsService.ts
@@ -0,0 +1,52 @@
+import { Service, Inject } from 'typedi';
+import {
+  IViewsService,
+  IView,
+  IModel,
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import ResourceService from '@/services/Resource/ResourceService';
+
+@Service()
+export default class ViewsService implements IViewsService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  @Inject()
+  resourceService: ResourceService;
+
+  /**
+   * Listing resource views.
+   * @param {number} tenantId -
+   * @param {string} resourceModel -
+   */
+  public async listResourceViews(
+    tenantId: number,
+    resourceModelName: string
+  ): Promise<IView[]> {
+    // Validate the resource model name is valid.
+    const resourceModel = this.getResourceModelOrThrowError(
+      tenantId,
+      resourceModelName
+    );
+    // Default views.
+    const defaultViews = resourceModel.getDefaultViews();
+
+    return defaultViews;
+  }
+
+  /**
+   * Retrieve resource model from resource name or throw not found error.
+   * @param {number} tenantId
+   * @param {number} resourceModel
+   */
+  private getResourceModelOrThrowError(
+    tenantId: number,
+    resourceModel: string
+  ): IModel {
+    return this.resourceService.getResourceModel(tenantId, resourceModel);
+  }
+}
diff --git a/packages/server/src/services/Warehouses/Activate/BillWarehousesActivate.ts b/packages/server/src/services/Warehouses/Activate/BillWarehousesActivate.ts
new file mode 100644
index 000000000..d436e3e78
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Activate/BillWarehousesActivate.ts
@@ -0,0 +1,30 @@
+import { Service, Inject } from 'typedi';
+import { IWarehouse } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class BillActivateWarehouses {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Updates all credit note transactions with the primary warehouse.
+   * @param   {number} tenantId
+   * @param   {number} primaryWarehouse
+   * @returns {Promise<void>}
+   */
+  public updateBillsWithWarehouse = async (
+    tenantId: number,
+    primaryWarehouse: IWarehouse
+  ): Promise<void> => {
+    const { Bill, ItemEntry } = this.tenancy.models(tenantId);
+
+    // Updates the sale estimates with primary warehouse.
+    await Bill.query().update({ warehouseId: primaryWarehouse.id });
+
+    // Update the sale estimates entries with primary warehouse.
+    await ItemEntry.query().where('referenceType', 'Bill').update({
+      warehouseId: primaryWarehouse.id,
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Activate/CreditNoteWarehousesActivate.ts b/packages/server/src/services/Warehouses/Activate/CreditNoteWarehousesActivate.ts
new file mode 100644
index 000000000..262297dfe
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Activate/CreditNoteWarehousesActivate.ts
@@ -0,0 +1,30 @@
+import { Service, Inject } from 'typedi';
+import { IWarehouse } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class CreditNotesActivateWarehouses {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Updates all credit note transactions with the primary warehouse.
+   * @param   {number} tenantId
+   * @param   {number} primaryWarehouse
+   * @returns {Promise<void>}
+   */
+  public updateCreditsWithWarehouse = async (
+    tenantId: number,
+    primaryWarehouse: IWarehouse
+  ): Promise<void> => {
+    const { CreditNote, ItemEntry } = this.tenancy.models(tenantId);
+
+    // Updates the sale estimates with primary warehouse.
+    await CreditNote.query().update({ warehouseId: primaryWarehouse.id });
+
+    // Update the sale estimates entries with primary warehouse.
+    await ItemEntry.query().where('referenceType', 'CreditNote').update({
+      warehouseId: primaryWarehouse.id,
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Activate/EstimateWarehousesActivate.ts b/packages/server/src/services/Warehouses/Activate/EstimateWarehousesActivate.ts
new file mode 100644
index 000000000..e7fd2c5bf
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Activate/EstimateWarehousesActivate.ts
@@ -0,0 +1,30 @@
+import { Service, Inject } from 'typedi';
+import { IWarehouse } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class EstimatesActivateWarehouses {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Updates all inventory transactions with the primary warehouse.
+   * @param   {number} tenantId
+   * @param   {number} primaryWarehouse
+   * @returns {Promise<void>}
+   */
+  public updateEstimatesWithWarehouse = async (
+    tenantId: number,
+    primaryWarehouse: IWarehouse
+  ): Promise<void> => {
+    const { SaleEstimate, ItemEntry } = this.tenancy.models(tenantId);
+
+    // Updates the sale estimates with primary warehouse.
+    await SaleEstimate.query().update({ warehouseId: primaryWarehouse.id });
+
+    // Update the sale estimates entries with primary warehouse.
+    await ItemEntry.query().where('referenceType', 'SaleEstimate').update({
+      warehouseId: primaryWarehouse.id,
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Activate/InventoryTransactionsWarehousesActivate.ts b/packages/server/src/services/Warehouses/Activate/InventoryTransactionsWarehousesActivate.ts
new file mode 100644
index 000000000..0bc0b8e4f
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Activate/InventoryTransactionsWarehousesActivate.ts
@@ -0,0 +1,31 @@
+import { Service, Inject } from 'typedi';
+import { IWarehouse } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class InventoryActivateWarehouses {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Updates all inventory transactions with the primary warehouse.
+   * @param   {number} tenantId
+   * @param   {number} primaryWarehouse
+   * @returns {Promise<void>}
+   */
+  public updateInventoryTransactionsWithWarehouse = async (
+    tenantId: number,
+    primaryWarehouse: IWarehouse
+  ): Promise<void> => {
+    const { InventoryTransaction, InventoryCostLotTracker } =
+      this.tenancy.models(tenantId);
+
+    // Updates the inventory transactions with primary warehouse.
+    await InventoryTransaction.query().update({
+      warehouseId: primaryWarehouse.id,
+    });
+    await InventoryCostLotTracker.query().update({
+      warehouseId: primaryWarehouse.id,
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Activate/InvoiceWarehousesActivate.ts b/packages/server/src/services/Warehouses/Activate/InvoiceWarehousesActivate.ts
new file mode 100644
index 000000000..94244dfec
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Activate/InvoiceWarehousesActivate.ts
@@ -0,0 +1,30 @@
+import { Service, Inject } from 'typedi';
+import { IWarehouse } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class InvoicesActivateWarehouses {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Updates all inventory transactions with the primary warehouse.
+   * @param   {number} tenantId
+   * @param   {number} primaryWarehouse
+   * @returns {Promise<void>}
+   */
+  public updateInvoicesWithWarehouse = async (
+    tenantId: number,
+    primaryWarehouse: IWarehouse
+  ): Promise<void> => {
+    const { SaleInvoice, ItemEntry } = this.tenancy.models(tenantId);
+
+    // Updates the sale invoices with primary warehouse.
+    await SaleInvoice.query().update({ warehouseId: primaryWarehouse.id });
+
+    // Update the sale invoices entries with primary warehouse.
+    await ItemEntry.query().where('referenceType', 'SaleInvoice').update({
+      warehouseId: primaryWarehouse.id,
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Activate/ReceiptWarehousesActivate.ts b/packages/server/src/services/Warehouses/Activate/ReceiptWarehousesActivate.ts
new file mode 100644
index 000000000..722e9a535
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Activate/ReceiptWarehousesActivate.ts
@@ -0,0 +1,30 @@
+import { Service, Inject } from 'typedi';
+import { IWarehouse } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class ReceiptActivateWarehouses {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Updates all sale receipts transactions with the primary warehouse.
+   * @param   {number} tenantId
+   * @param   {number} primaryWarehouse
+   * @returns {Promise<void>}
+   */
+  public updateReceiptsWithWarehouse = async (
+    tenantId: number,
+    primaryWarehouse: IWarehouse
+  ): Promise<void> => {
+    const { SaleReceipt, ItemEntry } = this.tenancy.models(tenantId);
+
+    // Updates the vendor credits transactions with primary warehouse.
+    await SaleReceipt.query().update({ warehouseId: primaryWarehouse.id });
+
+    // Update the sale invoices entries with primary warehouse.
+    await ItemEntry.query().where('referenceType', 'SaleReceipt').update({
+      warehouseId: primaryWarehouse.id,
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Activate/VendorCreditWarehousesActivate.ts b/packages/server/src/services/Warehouses/Activate/VendorCreditWarehousesActivate.ts
new file mode 100644
index 000000000..4402c4076
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Activate/VendorCreditWarehousesActivate.ts
@@ -0,0 +1,30 @@
+import { Service, Inject } from 'typedi';
+import { IWarehouse } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class VendorCreditActivateWarehouses {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Updates all vendor credits transactions with the primary warehouse.
+   * @param   {number} tenantId
+   * @param   {number} primaryWarehouse
+   * @returns {Promise<void>}
+   */
+  public updateCreditsWithWarehouse = async (
+    tenantId: number,
+    primaryWarehouse: IWarehouse
+  ): Promise<void> => {
+    const { VendorCredit, ItemEntry } = this.tenancy.models(tenantId);
+
+    // Updates the vendor credits transactions with primary warehouse.
+    await VendorCredit.query().update({ warehouseId: primaryWarehouse.id });
+
+    // Update the sale invoices entries with primary warehouse.
+    await ItemEntry.query().where('referenceType', 'VendorCredit').update({
+      warehouseId: primaryWarehouse.id,
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/ActivateWarehouses.ts b/packages/server/src/services/Warehouses/ActivateWarehouses.ts
new file mode 100644
index 000000000..4636515b9
--- /dev/null
+++ b/packages/server/src/services/Warehouses/ActivateWarehouses.ts
@@ -0,0 +1,76 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+
+import { ServiceError } from '@/exceptions';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+import { CreateInitialWarehouse } from './CreateInitialWarehouse';
+import { WarehousesSettings } from './WarehousesSettings';
+
+import events from '@/subscribers/events';
+import { ERRORS } from './contants';
+
+@Service()
+export class ActivateWarehouses {
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  createInitialWarehouse: CreateInitialWarehouse;
+
+  @Inject()
+  settings: WarehousesSettings;
+
+  /**
+   * Throws error if the multi-warehouses is already activated.
+   * @param {boolean} isActivated
+   */
+  private throwIfWarehousesActivated = (isActivated: boolean) => {
+    if (isActivated) {
+      throw new ServiceError(ERRORS.MUTLI_WAREHOUSES_ALREADY_ACTIVATED);
+    }
+  };
+
+  /**
+   * Activates the multi-warehouses.
+   *
+   * - Creates a new warehouses and mark it as primary.
+   * - Seed warehouses items quantity.
+   * - Mutate inventory transactions with the primary warehouse.
+   * --------
+   * @param   {number} tenantId
+   * @returns {Promise<void>}
+   */
+  public activateWarehouses = (tenantId: number): Promise<void> => {
+    // Retrieve whether the multi-warehouses is active.
+    const isActivated = this.settings.isMultiWarehousesActive(tenantId);
+
+    // Throw error if the warehouses is already activated.
+    this.throwIfWarehousesActivated(isActivated);
+
+    // Activates multi-warehouses on unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onWarehouseActivate` event.
+      await this.eventPublisher.emitAsync(events.warehouse.onActivate, {
+        tenantId,
+        trx,
+      });
+      // Creates a primary warehouse on the storage..
+      const primaryWarehouse =
+        await this.createInitialWarehouse.createInitialWarehouse(tenantId);
+
+      // Marks the multi-warehouses is activated.
+      this.settings.markMutliwarehoussAsActivated(tenantId);
+
+      // Triggers `onWarehouseActivated` event.
+      await this.eventPublisher.emitAsync(events.warehouse.onActivated, {
+        tenantId,
+        primaryWarehouse,
+        trx,
+      });
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/ActivateWarehousesSubscriber.ts b/packages/server/src/services/Warehouses/ActivateWarehousesSubscriber.ts
new file mode 100644
index 000000000..165be4cbc
--- /dev/null
+++ b/packages/server/src/services/Warehouses/ActivateWarehousesSubscriber.ts
@@ -0,0 +1,58 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { IWarehousesActivatedPayload } from '@/interfaces';
+import { UpdateInventoryTransactionsWithWarehouse } from './UpdateInventoryTransactionsWithWarehouse';
+import { CreateInitialWarehousesItemsQuantity } from './CreateInitialWarehousesitemsQuantity';
+
+@Service()
+export class ActivateWarehousesSubscriber {
+  @Inject()
+  private updateInventoryTransactionsWithWarehouse: UpdateInventoryTransactionsWithWarehouse;
+
+  @Inject()
+  private createInitialWarehousesItemsQuantity: CreateInitialWarehousesItemsQuantity;
+
+  /**
+   * Attaches events with handlers.
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.warehouse.onActivated,
+      this.updateInventoryTransactionsWithWarehouseOnActivating
+    );
+    bus.subscribe(
+      events.warehouse.onActivated,
+      this.createInitialWarehousesItemsQuantityOnActivating
+    );
+    return bus;
+  }
+
+  /**
+   * Updates inventory transactiont to primary warehouse once
+   * multi-warehouses activated.
+   * @param {IWarehousesActivatedPayload}
+   */
+  private updateInventoryTransactionsWithWarehouseOnActivating = async ({
+    tenantId,
+    primaryWarehouse,
+  }: IWarehousesActivatedPayload) => {
+    await this.updateInventoryTransactionsWithWarehouse.run(
+      tenantId,
+      primaryWarehouse.id
+    );
+  };
+
+  /**
+   * Creates initial warehouses items quantity once the multi-warehouses activated.
+   * @param {IWarehousesActivatedPayload}
+   */
+  private createInitialWarehousesItemsQuantityOnActivating = async ({
+    tenantId,
+    primaryWarehouse,
+  }: IWarehousesActivatedPayload) => {
+    await this.createInitialWarehousesItemsQuantity.run(
+      tenantId,
+      primaryWarehouse.id
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/CRUDWarehouse.ts b/packages/server/src/services/Warehouses/CRUDWarehouse.ts
new file mode 100644
index 000000000..92eddba10
--- /dev/null
+++ b/packages/server/src/services/Warehouses/CRUDWarehouse.ts
@@ -0,0 +1,26 @@
+import { Inject, Service } from 'typedi';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './contants';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+export class CRUDWarehouse {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  getWarehouseOrThrowNotFound = async (tenantId: number, warehouseId: number) => {
+    const { Warehouse } = this.tenancy.models(tenantId);
+
+    const foundWarehouse = await Warehouse.query().findById(warehouseId);
+
+    if (!foundWarehouse) {
+      throw new ServiceError(ERRORS.WAREHOUSE_NOT_FOUND);
+    }
+    return foundWarehouse;
+  };
+
+  throwIfWarehouseNotFound = (warehouse) => {
+    if (!warehouse) {
+      throw new ServiceError(ERRORS.WAREHOUSE_NOT_FOUND);
+    }
+  }
+}
diff --git a/packages/server/src/services/Warehouses/CreateInitialWarehouse.ts b/packages/server/src/services/Warehouses/CreateInitialWarehouse.ts
new file mode 100644
index 000000000..db25e1914
--- /dev/null
+++ b/packages/server/src/services/Warehouses/CreateInitialWarehouse.ts
@@ -0,0 +1,26 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { CreateWarehouse } from './CreateWarehouse';
+
+@Service()
+export class CreateInitialWarehouse {
+  @Inject()
+  private createWarehouse: CreateWarehouse;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Creates a initial warehouse.
+   * @param {number} tenantId
+   */
+  public createInitialWarehouse = async (tenantId: number) => {
+    const { __ } = this.tenancy.i18n(tenantId);
+
+    return this.createWarehouse.createWarehouse(tenantId, {
+      name: __('warehouses.primary_warehouse'),
+      code: '10001',
+      primary: true,
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/CreateInitialWarehousesitemsQuantity.ts b/packages/server/src/services/Warehouses/CreateInitialWarehousesitemsQuantity.ts
new file mode 100644
index 000000000..876408fcd
--- /dev/null
+++ b/packages/server/src/services/Warehouses/CreateInitialWarehousesitemsQuantity.ts
@@ -0,0 +1,57 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import { IItem, IItemWarehouseQuantityChange } from '@/interfaces';
+import { WarehousesItemsQuantitySync } from './Integrations/WarehousesItemsQuantitySync';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class CreateInitialWarehousesItemsQuantity {
+  @Inject()
+  private warehousesItemsQuantitySync: WarehousesItemsQuantitySync;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Retrieves items warehouses quantity changes of the given inventory items.
+   * @param {IItem[]} items
+   * @param {IWarehouse} primaryWarehouse
+   * @returns {IItemWarehouseQuantityChange[]}
+   */
+  private getWarehousesItemsChanges = (
+    items: IItem[],
+    primaryWarehouseId: number
+  ): IItemWarehouseQuantityChange[] => {
+    return items
+      .filter((item: IItem) => item.quantityOnHand)
+      .map((item: IItem) => ({
+        itemId: item.id,
+        warehouseId: primaryWarehouseId,
+        amount: item.quantityOnHand,
+      }));
+  };
+
+  /**
+   * Creates initial warehouses items quantity.
+   * @param {number} tenantId
+   */
+  public run = async (
+    tenantId: number,
+    primaryWarehouseId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { Item } = this.tenancy.models(tenantId);
+
+    const items = await Item.query(trx).where('type', 'Inventory');
+
+    const warehousesChanges = this.getWarehousesItemsChanges(
+      items,
+      primaryWarehouseId
+    );
+    await this.warehousesItemsQuantitySync.mutateWarehousesItemsQuantity(
+      tenantId,
+      warehousesChanges,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/CreateWarehouse.ts b/packages/server/src/services/Warehouses/CreateWarehouse.ts
new file mode 100644
index 000000000..866c8b443
--- /dev/null
+++ b/packages/server/src/services/Warehouses/CreateWarehouse.ts
@@ -0,0 +1,83 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import {
+  ICreateWarehouseDTO,
+  IWarehouse,
+  IWarehouseCreatedPayload,
+  IWarehouseCreatePayload,
+} from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import { WarehouseValidator } from './WarehouseValidator';
+
+@Service()
+export class CreateWarehouse {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private validator: WarehouseValidator;
+
+  /**
+   * Authorize the warehouse before deleting.
+   * @param {number} tenantId -
+   * @param {ICreateWarehouseDTO} warehouseDTO -
+   */
+  public authorize = async (
+    tenantId: number,
+    warehouseDTO: ICreateWarehouseDTO
+  ) => {
+    if (warehouseDTO.code) {
+      await this.validator.validateWarehouseCodeUnique(
+        tenantId,
+        warehouseDTO.code
+      );
+    }
+  };
+
+  /**
+   * Creates a new warehouse on the system.
+   * @param {number} tenantId
+   * @param {ICreateWarehouseDTO} warehouseDTO
+   */
+  public createWarehouse = async (
+    tenantId: number,
+    warehouseDTO: ICreateWarehouseDTO
+  ): Promise<IWarehouse> => {
+    const { Warehouse } = this.tenancy.models(tenantId);
+
+    // Authorize warehouse before creating.
+    await this.authorize(tenantId, warehouseDTO);
+
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onWarehouseCreate` event.
+      await this.eventPublisher.emitAsync(events.warehouse.onEdit, {
+        tenantId,
+        warehouseDTO,
+        trx,
+      } as IWarehouseCreatePayload);
+
+      // Creates a new warehouse on the storage.
+      const warehouse = await Warehouse.query(trx).insertAndFetch({
+        ...warehouseDTO,
+      });
+      // Triggers `onWarehouseCreated` event.
+      await this.eventPublisher.emitAsync(events.warehouse.onCreated, {
+        tenantId,
+        warehouseDTO,
+        warehouse,
+        trx,
+      } as IWarehouseCreatedPayload);
+
+      return warehouse;
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/DeleteItemWarehousesQuantity.ts b/packages/server/src/services/Warehouses/DeleteItemWarehousesQuantity.ts
new file mode 100644
index 000000000..1e92e2162
--- /dev/null
+++ b/packages/server/src/services/Warehouses/DeleteItemWarehousesQuantity.ts
@@ -0,0 +1,25 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class DeleteItemWarehousesQuantity {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Deletes the given item warehouses quantities.
+   * @param {number} tenantId
+   * @param {number} itemId
+   * @param {Knex.Transaction} trx -
+   */
+  public deleteItemWarehousesQuantity = async (
+    tenantId: number,
+    itemId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const { ItemWarehouseQuantity } = this.tenancy.models(tenantId);
+
+    await ItemWarehouseQuantity.query(trx).where('itemId', itemId).delete();
+  };
+}
diff --git a/packages/server/src/services/Warehouses/DeleteWarehouse.ts b/packages/server/src/services/Warehouses/DeleteWarehouse.ts
new file mode 100644
index 000000000..392519cf3
--- /dev/null
+++ b/packages/server/src/services/Warehouses/DeleteWarehouse.ts
@@ -0,0 +1,86 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+import { IWarehouseDeletedPayload, IWarehouseDeletePayload } from '@/interfaces';
+import { CRUDWarehouse } from './CRUDWarehouse';
+import { WarehouseValidator } from './WarehouseValidator';
+import { ERRORS } from './contants';
+
+@Service()
+export class DeleteWarehouse extends CRUDWarehouse {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  @Inject()
+  validator: WarehouseValidator;
+
+  /**
+   * Validates the given warehouse before deleting.
+   * @param   {number} tenantId
+   * @param   {number} warehouseId
+   * @returns {Promise<void>}
+   */
+  public authorize = async (tenantId: number, warehouseId: number) => {
+    await this.validator.validateWarehouseNotOnlyWarehouse(
+      tenantId,
+      warehouseId
+    );
+  };
+
+  /**
+   * Deletes specific warehouse.
+   * @param   {number} tenantId
+   * @param   {number} warehouseId
+   * @returns {Promise<void>}
+   */
+  public deleteWarehouse = async (
+    tenantId: number,
+    warehouseId: number
+  ): Promise<void> => {
+    const { Warehouse } = this.tenancy.models(tenantId);
+
+    // Retrieves the old warehouse or throw not found service error.
+    const oldWarehouse = await Warehouse.query()
+      .findById(warehouseId)
+      .throwIfNotFound()
+      .queryAndThrowIfHasRelations({
+        type: ERRORS.WAREHOUSE_HAS_ASSOCIATED_TRANSACTIONS,
+      });
+
+    // Validates the given warehouse before deleting.
+    await this.authorize(tenantId, warehouseId);
+
+    // Creates a new warehouse under unit-of-work.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      const eventPayload = {
+        tenantId,
+        warehouseId,
+        oldWarehouse,
+        trx,
+      } as IWarehouseDeletePayload | IWarehouseDeletedPayload;
+
+      // Triggers `onWarehouseCreate`.
+      await this.eventPublisher.emitAsync(
+        events.warehouse.onDelete,
+        eventPayload
+      );
+      // Delets the given warehouse from the storage.
+      await Warehouse.query().findById(warehouseId).delete();
+
+      // Triggers `onWarehouseCreated`.
+      await this.eventPublisher.emitAsync(
+        events.warehouse.onDeleted,
+        eventPayload as IWarehouseDeletedPayload
+      );
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/EditWarehouse.ts b/packages/server/src/services/Warehouses/EditWarehouse.ts
new file mode 100644
index 000000000..285e9406d
--- /dev/null
+++ b/packages/server/src/services/Warehouses/EditWarehouse.ts
@@ -0,0 +1,82 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+import { IEditWarehouseDTO, IWarehouse } from '@/interfaces';
+import { WarehouseValidator } from './WarehouseValidator';
+
+@Service()
+export class EditWarehouse {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private validator: WarehouseValidator;
+
+  /**
+   * Authorize the warehouse before deleting.
+   * @param {number} tenantId -
+   * @param {ICreateWarehouseDTO} warehouseDTO -
+   */
+  public authorize = async (
+    tenantId: number,
+    warehouseDTO: IEditWarehouseDTO,
+    warehouseId: number
+  ) => {
+    if (warehouseDTO.code) {
+      await this.validator.validateWarehouseCodeUnique(
+        tenantId,
+        warehouseDTO.code,
+        warehouseId
+      );
+    }
+  };
+
+  /**
+   * Edits a new warehouse on the system.
+   * @param   {number} tenantId
+   * @param   {ICreateWarehouseDTO} warehouseDTO
+   * @returns {Promise<IWarehouse>}
+   */
+  public editWarehouse = async (
+    tenantId: number,
+    warehouseId: number,
+    warehouseDTO: IEditWarehouseDTO
+  ): Promise<IWarehouse> => {
+    const { Warehouse } = this.tenancy.models(tenantId);
+
+    // Authorize the warehouse DTO before editing.
+    await this.authorize(tenantId, warehouseDTO, warehouseId);
+
+    // Edits warehouse under unit-of-work.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onWarehouseEdit` event.
+      await this.eventPublisher.emitAsync(events.warehouse.onEdit, {
+        tenantId,
+        warehouseId,
+        warehouseDTO,
+        trx,
+      });
+      // Updates the given branch on the storage.
+      const warehouse = await Warehouse.query().patchAndFetchById(warehouseId, {
+        ...warehouseDTO,
+      });
+      // Triggers `onWarehouseEdited` event.
+      await this.eventPublisher.emitAsync(events.warehouse.onEdited, {
+        tenantId,
+        warehouse,
+        warehouseDTO,
+        trx,
+      });
+      return warehouse;
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/EventsProvider.ts b/packages/server/src/services/Warehouses/EventsProvider.ts
new file mode 100644
index 000000000..bdf02774b
--- /dev/null
+++ b/packages/server/src/services/Warehouses/EventsProvider.ts
@@ -0,0 +1,39 @@
+import {
+  BillsActivateWarehousesSubscriber,
+  CreditsActivateWarehousesSubscriber,
+  InvoicesActivateWarehousesSubscriber,
+  ReceiptsActivateWarehousesSubscriber,
+  EstimatesActivateWarehousesSubscriber,
+  InventoryActivateWarehousesSubscriber,
+  VendorCreditsActivateWarehousesSubscriber,
+} from './Subscribers/Activate';
+import {
+  BillWarehousesValidateSubscriber,
+  CreditNoteWarehousesValidateSubscriber,
+  SaleReceiptWarehousesValidateSubscriber,
+  SaleEstimateWarehousesValidateSubscriber,
+  SaleInvoicesWarehousesValidateSubscriber,
+  VendorCreditWarehousesValidateSubscriber,
+  InventoryAdjustmentWarehouseValidatorSubscriber,
+} from './Subscribers/Validators';
+import { DeleteItemWarehousesQuantitySubscriber } from './Subscribers/DeleteItemWarehousesQuantitySubscriber';
+
+export default () => [
+  BillsActivateWarehousesSubscriber,
+  CreditsActivateWarehousesSubscriber,
+  InvoicesActivateWarehousesSubscriber,
+  ReceiptsActivateWarehousesSubscriber,
+  EstimatesActivateWarehousesSubscriber,
+  InventoryActivateWarehousesSubscriber,
+  VendorCreditsActivateWarehousesSubscriber,
+
+  BillWarehousesValidateSubscriber,
+  CreditNoteWarehousesValidateSubscriber,
+  SaleReceiptWarehousesValidateSubscriber,
+  SaleEstimateWarehousesValidateSubscriber,
+  SaleInvoicesWarehousesValidateSubscriber,
+  VendorCreditWarehousesValidateSubscriber,
+  InventoryAdjustmentWarehouseValidatorSubscriber,
+
+  DeleteItemWarehousesQuantitySubscriber,
+];
diff --git a/packages/server/src/services/Warehouses/GetWarehouse.ts b/packages/server/src/services/Warehouses/GetWarehouse.ts
new file mode 100644
index 000000000..e403a1864
--- /dev/null
+++ b/packages/server/src/services/Warehouses/GetWarehouse.ts
@@ -0,0 +1,24 @@
+import { Inject, Service } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { CRUDWarehouse } from './CRUDWarehouse';
+
+@Service()
+export class GetWarehouse extends CRUDWarehouse {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieves warehouse details.
+   * @param  {number} tenantId
+   * @returns
+   */
+  public getWarehouse = async (tenantId: number, warehouseId: number) => {
+    const { Warehouse } = this.tenancy.models(tenantId);
+
+    const warehouse = await Warehouse.query().findById(warehouseId);
+
+    this.throwIfWarehouseNotFound(warehouse);
+
+    return warehouse;
+  };
+}
diff --git a/packages/server/src/services/Warehouses/GetWarehouses.ts b/packages/server/src/services/Warehouses/GetWarehouses.ts
new file mode 100644
index 000000000..631dbc205
--- /dev/null
+++ b/packages/server/src/services/Warehouses/GetWarehouses.ts
@@ -0,0 +1,21 @@
+import { Inject, Service } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class GetWarehouses {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieves warehouses list.
+   * @param  {number} tenantId 
+   * @returns 
+   */
+  public getWarehouses = async (tenantId: number) => {
+    const { Warehouse } = this.tenancy.models(tenantId);
+
+    const warehouses = await Warehouse.query().orderBy('name', 'DESC');
+
+    return warehouses;
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Integrations/ValidateItemEntriesWarehouseExistance.ts b/packages/server/src/services/Warehouses/Integrations/ValidateItemEntriesWarehouseExistance.ts
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/server/src/services/Warehouses/Integrations/ValidateWarehouseExistance.ts b/packages/server/src/services/Warehouses/Integrations/ValidateWarehouseExistance.ts
new file mode 100644
index 000000000..c8892670e
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Integrations/ValidateWarehouseExistance.ts
@@ -0,0 +1,79 @@
+import { Inject, Service } from 'typedi';
+import { chain, difference } from 'lodash';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class ValidateWarehouseExistance {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Validate transaction warehouse id existance.
+   * @param transDTO
+   * @param entries
+   */
+  public validateWarehouseIdExistance = (
+    transDTO: { warehouseId?: number },
+    entries: { warehouseId?: number }[] = []
+  ) => {
+    const notAssignedWarehouseEntries = entries.filter((e) => !e.warehouseId);
+
+    if (notAssignedWarehouseEntries.length > 0 && !transDTO.warehouseId) {
+      throw new ServiceError(ERRORS.WAREHOUSE_ID_NOT_FOUND);
+    }
+    if (entries.length === 0 && !transDTO.warehouseId) {
+      throw new ServiceError(ERRORS.WAREHOUSE_ID_NOT_FOUND);
+    }
+  };
+
+  /**
+   * Validate warehouse existance.
+   * @param {number} tenantId
+   * @param {number} warehouseId
+   */
+  public validateWarehouseExistance = (
+    tenantId: number,
+    warehouseId: number
+  ) => {
+    const { Warehouse } = this.tenancy.models(tenantId);
+
+    const warehouse = Warehouse.query().findById(warehouseId);
+
+    if (!warehouse) {
+      throw new ServiceError(ERRORS.WAREHOUSE_ID_NOT_FOUND);
+    }
+  };
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {{ warehouseId?: number }[]} entries
+   */
+  public validateItemEntriesWarehousesExistance = async (
+    tenantId: number,
+    entries: { warehouseId?: number }[]
+  ) => {
+    const { Warehouse } = this.tenancy.models(tenantId);
+
+    const entriesWarehousesIds = chain(entries)
+      .filter((e) => !!e.warehouseId)
+      .map((e) => e.warehouseId)
+      .uniq()
+      .value();
+
+    const warehouses = await Warehouse.query().whereIn(
+      'id',
+      entriesWarehousesIds
+    );
+    const warehousesIds = warehouses.map((e) => e.id);
+    const notFoundWarehousesIds = difference(
+      entriesWarehousesIds,
+      warehousesIds
+    );
+    if (notFoundWarehousesIds.length > 0) {
+      throw new ServiceError(ERRORS.WAREHOUSE_ID_NOT_FOUND);
+    }
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Integrations/WarehouseTransactionDTOTransform.ts b/packages/server/src/services/Warehouses/Integrations/WarehouseTransactionDTOTransform.ts
new file mode 100644
index 000000000..297ae5aa6
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Integrations/WarehouseTransactionDTOTransform.ts
@@ -0,0 +1,38 @@
+import { Service, Inject } from 'typedi';
+import { omit } from 'lodash';
+import * as R from 'ramda';
+import { WarehousesSettings } from '../WarehousesSettings';
+
+@Service()
+export class WarehouseTransactionDTOTransform {
+  @Inject()
+  private warehousesSettings: WarehousesSettings;
+
+  /**
+   * Excludes DTO warehouse id when mutli-warehouses feature is inactive.
+   * @param   {number} tenantId
+   * @returns {Promise<Omit<T, 'warehouseId'> | T>}
+   */
+  private excludeDTOWarehouseIdWhenInactive = <
+    T extends { warehouseId?: number }
+  >(
+    tenantId: number,
+    DTO: T
+  ): Omit<T, 'warehouseId'> | T => {
+    const isActive = this.warehousesSettings.isMultiWarehousesActive(tenantId);
+
+    return !isActive ? omit(DTO, ['warehouseId']) : DTO;
+  };
+
+  /**
+   *
+   * @param   {number} tenantId
+   * @param   {T} DTO -
+   * @returns {Omit<T, 'warehouseId'> | T}
+   */
+  public transformDTO =
+    <T extends { warehouseId?: number }>(tenantId: number) =>
+    (DTO: T): Omit<T, 'warehouseId'> | T => {
+      return this.excludeDTOWarehouseIdWhenInactive<T>(tenantId, DTO);
+    };
+}
diff --git a/packages/server/src/services/Warehouses/Integrations/WarehousesDTOValidators.ts b/packages/server/src/services/Warehouses/Integrations/WarehousesDTOValidators.ts
new file mode 100644
index 000000000..6e2d71067
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Integrations/WarehousesDTOValidators.ts
@@ -0,0 +1,66 @@
+import { Service, Inject } from 'typedi';
+import { isEmpty } from 'lodash';
+import { ValidateWarehouseExistance } from './ValidateWarehouseExistance';
+import { WarehousesSettings } from '../WarehousesSettings';
+
+interface IWarehouseTransactionDTO {
+  warehouseId?: number|null;
+  entries?: { warehouseId?: number|null }[];
+}
+
+@Service()
+export class WarehousesDTOValidators {
+  @Inject()
+  private validateWarehouseExistanceService: ValidateWarehouseExistance;
+
+  @Inject()
+  private warehousesSettings: WarehousesSettings;
+
+  /**
+   * Validates the warehouse existance of sale invoice transaction.
+   * @param {number} tenantId
+   * @param {ISaleInvoiceCreateDTO | ISaleInvoiceEditDTO} saleInvoiceDTO
+   */
+  public validateDTOWarehouseExistance = async (
+    tenantId: number,
+    DTO: IWarehouseTransactionDTO
+  ) => {
+    // Validates the sale invoice warehouse id existance.
+    this.validateWarehouseExistanceService.validateWarehouseIdExistance(
+      DTO,
+      DTO.entries
+    );
+    // Validate the sale invoice warehouse existance on the storage.
+    if (DTO.warehouseId) {
+      this.validateWarehouseExistanceService.validateWarehouseExistance(
+        tenantId,
+        DTO.warehouseId
+      );
+    }
+    // Validate the sale invoice entries warehouses existance on the storage.
+    if (!isEmpty(DTO.entries)) {
+      await this.validateWarehouseExistanceService.validateItemEntriesWarehousesExistance(
+        tenantId,
+        DTO.entries
+      );
+    }
+  };
+
+  /**
+   * Validate the warehouse existance of
+   * @param   {number} tenantId
+   * @param   {IWarehouseTransactionDTO} saleInvoiceDTO
+   * @returns
+   */
+  public validateDTOWarehouseWhenActive = async (
+    tenantId: number,
+    DTO: IWarehouseTransactionDTO
+  ): Promise<void> => {
+    const isActive = this.warehousesSettings.isMultiWarehousesActive(tenantId);
+
+    // Can't continue if the multi-warehouses feature is inactive.
+    if (!isActive) return;
+
+    return this.validateDTOWarehouseExistance(tenantId, DTO);
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Integrations/WarehousesItemsQuantity.ts b/packages/server/src/services/Warehouses/Integrations/WarehousesItemsQuantity.ts
new file mode 100644
index 000000000..cbf00c909
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Integrations/WarehousesItemsQuantity.ts
@@ -0,0 +1,117 @@
+import {
+  IInventoryTransaction,
+  IItemWarehouseQuantityChange,
+} from '@/interfaces';
+import { set, get, chain, toPairs } from 'lodash';
+
+export class WarehousesItemsQuantity {
+  balanceMap: { [warehouseId: number]: { [itemId: number]: number } } = {};
+  /**
+   *
+   * @param   {number} warehouseId
+   * @param   {number} itemId
+   * @returns {number}
+   */
+  public get = (warehouseId: number, itemId: number): number => {
+    return get(this.balanceMap, `${warehouseId}.${itemId}`, 0);
+  };
+
+  /**
+   *
+   * @param   {number} warehouseId
+   * @param   {number} itemId
+   * @param   {number} amount
+   * @returns {WarehousesItemsQuantity}
+   */
+  public set = (warehouseId: number, itemId: number, amount: number) => {
+    if (!get(this.balanceMap, warehouseId)) {
+      set(this.balanceMap, warehouseId, {});
+    }
+    set(this.balanceMap, `${warehouseId}.${itemId}`, amount);
+
+    return this;
+  };
+
+  /**
+   *
+   * @param   {number} warehouseId
+   * @param   {number} itemId
+   * @param   {number} amount
+   * @returns {WarehousesItemsQuantity}
+   */
+  public increment = (warehouseId: number, itemId: number, amount: number) => {
+    const oldAmount = this.get(warehouseId, itemId);
+
+    return this.set(warehouseId, itemId, oldAmount + amount);
+  };
+
+  /**
+   *
+   * @param   {number} warehouseId
+   * @param   {number} itemId
+   * @param   {number} amount
+   * @returns {WarehousesItemsQuantity}
+   */
+  public decrement = (warehouseId: number, itemId: number, amount: number) => {
+    const oldAmount = this.get(warehouseId, itemId);
+
+    return this.set(warehouseId, itemId, oldAmount - amount);
+  };
+
+  /**
+   *
+   * @returns {WarehousesItemsQuantity}
+   */
+  public reverse = () => {
+    const collection = this.toArray();
+
+    collection.forEach((change) => {
+      this.set(change.warehouseId, change.itemId, change.amount * -1);
+    });
+    return this;
+  };
+
+  /**
+   *
+   * @returns {IItemWarehouseQuantityChange[]}
+   */
+  public toArray = (): IItemWarehouseQuantityChange[] => {
+    return chain(this.balanceMap)
+      .toPairs()
+      .map(([warehouseId, item]) => {
+        const pairs = toPairs(item);
+
+        return pairs.map(([itemId, amount]) => ({
+          itemId: parseInt(itemId),
+          warehouseId: parseInt(warehouseId),
+          amount,
+        }));
+      })
+      .flatten()
+      .value();
+  };
+
+  /**
+   *
+   * @param   {IInventoryTransaction[]} inventoryTransactions
+   * @returns {WarehousesItemsQuantity}
+   */
+  static fromInventoryTransaction = (
+    inventoryTransactions: IInventoryTransaction[]
+  ): WarehousesItemsQuantity => {
+    const warehouseTransactions = inventoryTransactions.filter(
+      (transaction) => transaction.warehouseId
+    );
+    const warehouseItemsQuantity = new WarehousesItemsQuantity();
+
+    warehouseTransactions.forEach((transaction: IInventoryTransaction) => {
+      const change =
+        transaction.direction === 'IN'
+          ? warehouseItemsQuantity.increment
+          : warehouseItemsQuantity.decrement;
+
+      change(transaction.warehouseId, transaction.itemId, transaction.quantity);
+    });
+    return warehouseItemsQuantity;
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Integrations/WarehousesItemsQuantitySynSubscriber.ts b/packages/server/src/services/Warehouses/Integrations/WarehousesItemsQuantitySynSubscriber.ts
new file mode 100644
index 000000000..d1b8e3836
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Integrations/WarehousesItemsQuantitySynSubscriber.ts
@@ -0,0 +1,74 @@
+import events from '@/subscribers/events';
+import { Service, Inject } from 'typedi';
+import { WarehousesItemsQuantitySync } from './WarehousesItemsQuantitySync';
+import {
+  IInventoryTransactionsCreatedPayload,
+  IInventoryTransactionsDeletedPayload,
+} from '@/interfaces';
+import { WarehousesSettings } from '../WarehousesSettings';
+
+@Service()
+export class WarehousesItemsQuantitySyncSubscriber {
+  @Inject()
+  private warehousesItemsQuantitySync: WarehousesItemsQuantitySync;
+
+  @Inject()
+  private warehousesSettings: WarehousesSettings;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.inventory.onInventoryTransactionsCreated,
+      this.syncWarehousesItemsQuantityOnInventoryTransCreated
+    );
+    bus.subscribe(
+      events.inventory.onInventoryTransactionsDeleted,
+      this.syncWarehousesItemsQuantityOnInventoryTransDeleted
+    );
+    return bus;
+  }
+
+  /**
+   * Syncs warehouses items quantity once inventory transactions created.
+   * @param {IInventoryTransactionsCreatedPayload}
+   */
+  private syncWarehousesItemsQuantityOnInventoryTransCreated = async ({
+    tenantId,
+    inventoryTransactions,
+    trx,
+  }: IInventoryTransactionsCreatedPayload) => {
+    const isActive = this.warehousesSettings.isMultiWarehousesActive(tenantId);
+
+    // Can't continue if the warehouses features is not active.
+    if (!isActive) return;
+
+    await this.warehousesItemsQuantitySync.mutateWarehousesItemsQuantityFromTransactions(
+      tenantId,
+      inventoryTransactions,
+      trx
+    );
+  };
+
+  /**
+   * Syncs warehouses items quantity once inventory transactions deleted.
+   * @param {IInventoryTransactionsDeletedPayload}
+   */
+  private syncWarehousesItemsQuantityOnInventoryTransDeleted = async ({
+    tenantId,
+    oldInventoryTransactions,
+    trx,
+  }: IInventoryTransactionsDeletedPayload) => {
+    const isActive = this.warehousesSettings.isMultiWarehousesActive(tenantId);
+
+    // Can't continue if the warehouses feature is not active yet.
+    if (!isActive) return;
+
+    await this.warehousesItemsQuantitySync.reverseWarehousesItemsQuantityFromTransactions(
+      tenantId,
+      oldInventoryTransactions,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Integrations/WarehousesItemsQuantitySync.ts b/packages/server/src/services/Warehouses/Integrations/WarehousesItemsQuantitySync.ts
new file mode 100644
index 000000000..ed1166397
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Integrations/WarehousesItemsQuantitySync.ts
@@ -0,0 +1,131 @@
+import { Knex } from 'knex';
+import { Service, Inject } from 'typedi';
+import { omit } from 'lodash';
+import {
+  IInventoryTransaction,
+  IItemWarehouseQuantityChange,
+} from '@/interfaces';
+import { WarehousesItemsQuantity } from './WarehousesItemsQuantity';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class WarehousesItemsQuantitySync {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Retrieves the reversed warehouses items quantity changes.
+   * @param   {IInventoryTransaction[]} inventoryTransactions
+   * @returns {IItemWarehouseQuantityChange[]}
+   */
+  public getReverseWarehousesItemsQuantityChanges = (
+    inventoryTransactions: IInventoryTransaction[]
+  ): IItemWarehouseQuantityChange[] => {
+    const warehouseItemsQuantity =
+      WarehousesItemsQuantity.fromInventoryTransaction(inventoryTransactions);
+
+    return warehouseItemsQuantity.reverse().toArray();
+  };
+
+  /**
+   * Retrieves the warehouses items changes from the given inventory tranasctions.
+   * @param   {IInventoryTransaction[]} inventoryTransactions
+   * @returns {IItemWarehouseQuantityChange[]}
+   */
+  public getWarehousesItemsQuantityChange = (
+    inventoryTransactions: IInventoryTransaction[]
+  ): IItemWarehouseQuantityChange[] => {
+    const warehouseItemsQuantity =
+      WarehousesItemsQuantity.fromInventoryTransaction(inventoryTransactions);
+
+    return warehouseItemsQuantity.toArray();
+  };
+
+  /**
+   * Mutates warehouses items quantity on hand on the storage.
+   * @param {number} tenantId
+   * @param {IItemWarehouseQuantityChange[]} warehousesItemsQuantity
+   * @param {Knex.Transaction} trx
+   */
+  public mutateWarehousesItemsQuantity = async (
+    tenantId: number,
+    warehousesItemsQuantity: IItemWarehouseQuantityChange[],
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const mutationsOpers = warehousesItemsQuantity.map(
+      (change: IItemWarehouseQuantityChange) =>
+        this.mutateWarehouseItemQuantity(tenantId, change, trx)
+    );
+    await Promise.all(mutationsOpers);
+  };
+
+  /**
+   * Mutates the warehouse item quantity.
+   * @param {number} tenantId
+   * @param {number} warehouseItemQuantity
+   * @param {Knex.Transaction} trx
+   */
+  public mutateWarehouseItemQuantity = async (
+    tenantId: number,
+    warehouseItemQuantity: IItemWarehouseQuantityChange,
+    trx: Knex.Transaction
+  ): Promise<void> => {
+    const { ItemWarehouseQuantity } = this.tenancy.models(tenantId);
+
+    const itemWarehouseQuantity = await ItemWarehouseQuantity.query(trx)
+      .where('itemId', warehouseItemQuantity.itemId)
+      .where('warehouseId', warehouseItemQuantity.warehouseId)
+      .first();
+
+    if (itemWarehouseQuantity) {
+      await ItemWarehouseQuantity.changeAmount(
+        {
+          itemId: warehouseItemQuantity.itemId,
+          warehouseId: warehouseItemQuantity.warehouseId,
+        },
+        'quantityOnHand',
+        warehouseItemQuantity.amount,
+        trx
+      );
+    } else {
+      await ItemWarehouseQuantity.query(trx).insert({
+        ...omit(warehouseItemQuantity, ['amount']),
+        quantityOnHand: warehouseItemQuantity.amount,
+      });
+    }
+  };
+
+  /**
+   * Mutates warehouses items quantity from inventory transactions.
+   * @param {number} tenantId -
+   * @param {IInventoryTransaction[]} inventoryTransactions -
+   * @param {Knex.Transaction}
+   */
+  public mutateWarehousesItemsQuantityFromTransactions = async (
+    tenantId: number,
+    inventoryTransactions: IInventoryTransaction[],
+    trx?: Knex.Transaction
+  ) => {
+    const changes = this.getWarehousesItemsQuantityChange(
+      inventoryTransactions
+    );
+    await this.mutateWarehousesItemsQuantity(tenantId, changes, trx);
+  };
+
+  /**
+   * Reverses warehouses items quantity from inventory transactions.
+   * @param {number} tenantId
+   * @param {IInventoryTransaction[]} inventoryTransactions
+   * @param {Knex.Transaction} trx
+   */
+  public reverseWarehousesItemsQuantityFromTransactions = async (
+    tenantId: number,
+    inventoryTransactions: IInventoryTransaction[],
+    trx?: Knex.Transaction
+  ) => {
+    const changes = this.getReverseWarehousesItemsQuantityChanges(
+      inventoryTransactions
+    );
+    await this.mutateWarehousesItemsQuantity(tenantId, changes, trx);
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Integrations/constants.ts b/packages/server/src/services/Warehouses/Integrations/constants.ts
new file mode 100644
index 000000000..f1799f58d
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Integrations/constants.ts
@@ -0,0 +1,4 @@
+export const ERRORS = {
+  WAREHOUSE_ID_NOT_FOUND: 'WAREHOUSE_ID_NOT_FOUND',
+  ITEM_ENTRY_WAREHOUSE_ID_NOT_FOUND: 'ITEM_ENTRY_WAREHOUSE_ID_NOT_FOUND',
+};
diff --git a/packages/server/src/services/Warehouses/Items/GetItemWarehouses.ts b/packages/server/src/services/Warehouses/Items/GetItemWarehouses.ts
new file mode 100644
index 000000000..14ee97a2c
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Items/GetItemWarehouses.ts
@@ -0,0 +1,37 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { GetItemWarehouseTransformer } from './GettItemWarehouseTransformer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export class GetItemWarehouses {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieves the item warehouses.
+   * @param {number} tenantId
+   * @param {number} itemId
+   * @returns
+   */
+  public getItemWarehouses = async (tenantId: number, itemId: number) => {
+    const { ItemWarehouseQuantity, Item } = this.tenancy.models(tenantId);
+
+    // Retrieves specific item or throw not found service error.
+    const item = await Item.query().findById(itemId).throwIfNotFound();
+
+    const itemWarehouses = await ItemWarehouseQuantity.query()
+      .where('itemId', itemId)
+      .withGraphFetched('warehouse');
+
+    // Retrieves the transformed items warehouses.
+    return this.transformer.transform(
+      tenantId,
+      itemWarehouses,
+      new GetItemWarehouseTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Items/GettItemWarehouseTransformer.ts b/packages/server/src/services/Warehouses/Items/GettItemWarehouseTransformer.ts
new file mode 100644
index 000000000..25ae36ca4
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Items/GettItemWarehouseTransformer.ts
@@ -0,0 +1,42 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from 'utils';
+
+export class GetItemWarehouseTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'warehouseId',
+      'warehouseName',
+      'warehouseCode',
+      'quantityOnHandFormatted',
+    ];
+  };
+
+  public excludeAttributes = (): string[] => {
+    return ['warehouse'];
+  };
+
+  /**
+   * Formatted sell price.
+   * @param item
+   * @returns {string}
+   */
+  public quantityOnHandFormatted(item): string {
+    return formatNumber(item.quantityOnHand, { money: false });
+  }
+
+  public warehouseCode(item): string {
+    return item.warehouse.code;
+  }
+
+  public warehouseName(item): string {
+    return item.warehouse.name;
+  }
+
+  public warehouseId(item): number {
+    return item.warehouse.id;
+  }
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Activate/BillWarehousesActivateSubscriber.ts b/packages/server/src/services/Warehouses/Subscribers/Activate/BillWarehousesActivateSubscriber.ts
new file mode 100644
index 000000000..3f7ae4ae1
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Activate/BillWarehousesActivateSubscriber.ts
@@ -0,0 +1,36 @@
+import { Service, Inject } from 'typedi';
+import { IWarehousesActivatedPayload } from '@/interfaces';
+import events from '@/subscribers/events';
+import { BillActivateWarehouses } from '../../Activate/BillWarehousesActivate';
+
+@Service()
+export class BillsActivateWarehousesSubscriber {
+  @Inject()
+  private billsActivateWarehouses: BillActivateWarehouses;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.warehouse.onActivated,
+      this.updateBillsWithWarehouseOnActivated
+    );
+    return bus;
+  }
+
+  /**
+   * Updates all inventory transactions with the primary warehouse once
+   * multi-warehouses feature is activated.
+   * @param {IWarehousesActivatedPayload}
+   */
+  private updateBillsWithWarehouseOnActivated = async ({
+    tenantId,
+    primaryWarehouse,
+  }: IWarehousesActivatedPayload) => {
+    await this.billsActivateWarehouses.updateBillsWithWarehouse(
+      tenantId,
+      primaryWarehouse
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Activate/CreditNoteWarehousesActivateSubscriber.ts b/packages/server/src/services/Warehouses/Subscribers/Activate/CreditNoteWarehousesActivateSubscriber.ts
new file mode 100644
index 000000000..71619e603
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Activate/CreditNoteWarehousesActivateSubscriber.ts
@@ -0,0 +1,36 @@
+import { Service, Inject } from 'typedi';
+import { IWarehousesActivatedPayload } from '@/interfaces';
+import events from '@/subscribers/events';
+import { CreditNotesActivateWarehouses } from '../../Activate/CreditNoteWarehousesActivate';
+
+@Service()
+export class CreditsActivateWarehousesSubscriber {
+  @Inject()
+  private creditsActivateWarehouses: CreditNotesActivateWarehouses;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.warehouse.onActivated,
+      this.updateInvoicesWithWarehouseOnActivated
+    );
+    return bus;
+  }
+
+  /**
+   * Updates all inventory transactions with the primary warehouse once
+   * multi-warehouses feature is activated.
+   * @param {IWarehousesActivatedPayload}
+   */
+  private updateInvoicesWithWarehouseOnActivated = async ({
+    tenantId,
+    primaryWarehouse,
+  }: IWarehousesActivatedPayload) => {
+    await this.creditsActivateWarehouses.updateCreditsWithWarehouse(
+      tenantId,
+      primaryWarehouse
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Activate/EstimateWarehousesActivateSubscriber.ts b/packages/server/src/services/Warehouses/Subscribers/Activate/EstimateWarehousesActivateSubscriber.ts
new file mode 100644
index 000000000..cb3ed9810
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Activate/EstimateWarehousesActivateSubscriber.ts
@@ -0,0 +1,36 @@
+import { Service, Inject } from 'typedi';
+import { IWarehousesActivatedPayload } from '@/interfaces';
+import events from '@/subscribers/events';
+import { EstimatesActivateWarehouses } from '../../Activate/EstimateWarehousesActivate';
+
+@Service()
+export class EstimatesActivateWarehousesSubscriber {
+  @Inject()
+  private estimatesActivateWarehouses: EstimatesActivateWarehouses;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.warehouse.onActivated,
+      this.updateEstimatessWithWarehouseOnActivated
+    );
+    return bus;
+  }
+
+  /**
+   * Updates all inventory transactions with the primary warehouse once
+   * multi-warehouses feature is activated.
+   * @param {IWarehousesActivatedPayload}
+   */
+  private updateEstimatessWithWarehouseOnActivated = async ({
+    tenantId,
+    primaryWarehouse,
+  }: IWarehousesActivatedPayload) => {
+    await this.estimatesActivateWarehouses.updateEstimatesWithWarehouse(
+      tenantId,
+      primaryWarehouse
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Activate/InventoryTransactionsWarehousesActivateSubscriber.ts b/packages/server/src/services/Warehouses/Subscribers/Activate/InventoryTransactionsWarehousesActivateSubscriber.ts
new file mode 100644
index 000000000..12914fa38
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Activate/InventoryTransactionsWarehousesActivateSubscriber.ts
@@ -0,0 +1,36 @@
+import { Service, Inject } from 'typedi';
+import { IWarehousesActivatedPayload } from '@/interfaces';
+import events from '@/subscribers/events';
+import { InventoryActivateWarehouses } from '../../Activate/InventoryTransactionsWarehousesActivate';
+
+@Service()
+export class InventoryActivateWarehousesSubscriber {
+  @Inject()
+  private inventoryActivateWarehouses: InventoryActivateWarehouses;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.warehouse.onActivated,
+      this.updateInventoryTransactionsWithWarehouseOnActivated
+    );
+    return bus;
+  }
+
+  /**
+   * Updates all inventory transactions with the primary warehouse once
+   * multi-warehouses feature is activated.
+   * @param {IWarehousesActivatedPayload}
+   */
+  private updateInventoryTransactionsWithWarehouseOnActivated = async ({
+    tenantId,
+    primaryWarehouse,
+  }: IWarehousesActivatedPayload) => {
+    await this.inventoryActivateWarehouses.updateInventoryTransactionsWithWarehouse(
+      tenantId,
+      primaryWarehouse
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Activate/InvoiceWarehousesActivateSubscriber.ts b/packages/server/src/services/Warehouses/Subscribers/Activate/InvoiceWarehousesActivateSubscriber.ts
new file mode 100644
index 000000000..8d2c82fc4
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Activate/InvoiceWarehousesActivateSubscriber.ts
@@ -0,0 +1,36 @@
+import { Service, Inject } from 'typedi';
+import { IWarehousesActivatedPayload } from '@/interfaces';
+import events from '@/subscribers/events';
+import { InvoicesActivateWarehouses } from '../../Activate/InvoiceWarehousesActivate';
+
+@Service()
+export class InvoicesActivateWarehousesSubscriber {
+  @Inject()
+  private invoicesActivateWarehouses: InvoicesActivateWarehouses;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.warehouse.onActivated,
+      this.updateInvoicesWithWarehouseOnActivated
+    );
+    return bus;
+  }
+
+  /**
+   * Updates all inventory transactions with the primary warehouse once
+   * multi-warehouses feature is activated.
+   * @param {IWarehousesActivatedPayload}
+   */
+  private updateInvoicesWithWarehouseOnActivated = async ({
+    tenantId,
+    primaryWarehouse,
+  }: IWarehousesActivatedPayload) => {
+    await this.invoicesActivateWarehouses.updateInvoicesWithWarehouse(
+      tenantId,
+      primaryWarehouse
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Activate/ReceiptWarehousesActivateSubscriber.ts b/packages/server/src/services/Warehouses/Subscribers/Activate/ReceiptWarehousesActivateSubscriber.ts
new file mode 100644
index 000000000..3e9077a7c
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Activate/ReceiptWarehousesActivateSubscriber.ts
@@ -0,0 +1,36 @@
+import { Service, Inject } from 'typedi';
+import { IWarehousesActivatedPayload } from '@/interfaces';
+import events from '@/subscribers/events';
+import { ReceiptActivateWarehouses } from '../../Activate/ReceiptWarehousesActivate';
+
+@Service()
+export class ReceiptsActivateWarehousesSubscriber {
+  @Inject()
+  private receiptsActivateWarehouses: ReceiptActivateWarehouses;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.warehouse.onActivated,
+      this.updateInventoryTransactionsWithWarehouseOnActivated
+    );
+    return bus;
+  }
+
+  /**
+   * Updates all receipts transactions with the primary warehouse once
+   * multi-warehouses feature is activated.
+   * @param {IWarehousesActivatedPayload}
+   */
+  private updateInventoryTransactionsWithWarehouseOnActivated = async ({
+    tenantId,
+    primaryWarehouse,
+  }: IWarehousesActivatedPayload) => {
+    await this.receiptsActivateWarehouses.updateReceiptsWithWarehouse(
+      tenantId,
+      primaryWarehouse
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Activate/VendorCreditWarehousesActivateSubscriber.ts b/packages/server/src/services/Warehouses/Subscribers/Activate/VendorCreditWarehousesActivateSubscriber.ts
new file mode 100644
index 000000000..ace6d4e11
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Activate/VendorCreditWarehousesActivateSubscriber.ts
@@ -0,0 +1,36 @@
+import { Service, Inject } from 'typedi';
+import { IWarehousesActivatedPayload } from '@/interfaces';
+import events from '@/subscribers/events';
+import { VendorCreditActivateWarehouses } from '../../Activate/VendorCreditWarehousesActivate';
+
+@Service()
+export class VendorCreditsActivateWarehousesSubscriber {
+  @Inject()
+  private creditsActivateWarehouses: VendorCreditActivateWarehouses;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.warehouse.onActivated,
+      this.updateCreditsWithWarehouseOnActivated
+    );
+    return bus;
+  }
+
+  /**
+   * Updates all inventory transactions with the primary warehouse once
+   * multi-warehouses feature is activated.
+   * @param {IWarehousesActivatedPayload}
+   */
+  private updateCreditsWithWarehouseOnActivated = async ({
+    tenantId,
+    primaryWarehouse,
+  }: IWarehousesActivatedPayload) => {
+    await this.creditsActivateWarehouses.updateCreditsWithWarehouse(
+      tenantId,
+      primaryWarehouse
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Activate/index.ts b/packages/server/src/services/Warehouses/Subscribers/Activate/index.ts
new file mode 100644
index 000000000..16febf17c
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Activate/index.ts
@@ -0,0 +1,8 @@
+/* eslint-disable import/extensions */
+export * from './BillWarehousesActivateSubscriber';
+export * from './CreditNoteWarehousesActivateSubscriber';
+export * from './EstimateWarehousesActivateSubscriber';
+export * from './InventoryTransactionsWarehousesActivateSubscriber';
+export * from './VendorCreditWarehousesActivateSubscriber';
+export * from './ReceiptWarehousesActivateSubscriber';
+export * from './InvoiceWarehousesActivateSubscriber';
diff --git a/packages/server/src/services/Warehouses/Subscribers/DeleteItemWarehousesQuantitySubscriber.ts b/packages/server/src/services/Warehouses/Subscribers/DeleteItemWarehousesQuantitySubscriber.ts
new file mode 100644
index 000000000..1f925c34f
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/DeleteItemWarehousesQuantitySubscriber.ts
@@ -0,0 +1,36 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import { DeleteItemWarehousesQuantity } from '../DeleteItemWarehousesQuantity';
+import { IItemEventDeletingPayload } from '@/interfaces';
+
+@Service()
+export class DeleteItemWarehousesQuantitySubscriber {
+  @Inject()
+  private deleteItemWarehousesQuantity: DeleteItemWarehousesQuantity;
+
+  /**
+   * Attaches events.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.item.onDeleting,
+      this.deleteItemWarehouseQuantitiesOnItemDelete
+    );
+  }
+
+  /**
+   * Deletes the given item warehouses quantities once the item deleting.
+   * @param {IItemEventDeletingPayload} payload -
+   */
+  private deleteItemWarehouseQuantitiesOnItemDelete = async ({
+    tenantId,
+    oldItem,
+    trx,
+  }: IItemEventDeletingPayload) => {
+    await this.deleteItemWarehousesQuantity.deleteItemWarehousesQuantity(
+      tenantId,
+      oldItem.id,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Validators/InventoryAdjustment/InventoryAdjustmentWarehouseValidatorSubscriber.ts b/packages/server/src/services/Warehouses/Subscribers/Validators/InventoryAdjustment/InventoryAdjustmentWarehouseValidatorSubscriber.ts
new file mode 100644
index 000000000..527474c8d
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Validators/InventoryAdjustment/InventoryAdjustmentWarehouseValidatorSubscriber.ts
@@ -0,0 +1,35 @@
+import { Inject, Service } from 'typedi';
+import { IInventoryAdjustmentCreatingPayload } from '@/interfaces';
+import events from '@/subscribers/events';
+import { WarehousesDTOValidators } from '../../../Integrations/WarehousesDTOValidators';
+
+@Service()
+export class InventoryAdjustmentWarehouseValidatorSubscriber {
+  @Inject()
+  private warehouseDTOValidator: WarehousesDTOValidators;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.inventoryAdjustment.onQuickCreating,
+      this.validateAdjustmentWarehouseExistanceOnCreating
+    );
+    return bus;
+  }
+
+  /**
+   * Validate warehouse existance of sale invoice once creating.
+   * @param {IBillCreatingPayload}
+   */
+  private validateAdjustmentWarehouseExistanceOnCreating = async ({
+    quickAdjustmentDTO,
+    tenantId,
+  }: IInventoryAdjustmentCreatingPayload) => {
+    await this.warehouseDTOValidator.validateDTOWarehouseWhenActive(
+      tenantId,
+      quickAdjustmentDTO
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Validators/Purchases/BillWarehousesSubscriber.ts b/packages/server/src/services/Warehouses/Subscribers/Validators/Purchases/BillWarehousesSubscriber.ts
new file mode 100644
index 000000000..d071b3d53
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Validators/Purchases/BillWarehousesSubscriber.ts
@@ -0,0 +1,53 @@
+import { Inject, Service } from 'typedi';
+import { IBillCreatingPayload, IBillEditingPayload } from '@/interfaces';
+import events from '@/subscribers/events';
+import { WarehousesDTOValidators } from '../../../Integrations/WarehousesDTOValidators';
+
+@Service()
+export class BillWarehousesValidateSubscriber {
+  @Inject()
+  private warehouseDTOValidator: WarehousesDTOValidators;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.bill.onCreating,
+      this.validateBillWarehouseExistanceOnCreating
+    );
+    bus.subscribe(
+      events.bill.onEditing,
+      this.validateSaleEstimateWarehouseExistanceOnEditing
+    );
+    return bus;
+  }
+
+  /**
+   * Validate warehouse existance of sale invoice once creating.
+   * @param {IBillCreatingPayload}
+   */
+  private validateBillWarehouseExistanceOnCreating = async ({
+    billDTO,
+    tenantId,
+  }: IBillCreatingPayload) => {
+    await this.warehouseDTOValidator.validateDTOWarehouseWhenActive(
+      tenantId,
+      billDTO
+    );
+  };
+
+  /**
+   * Validate warehouse existance of sale invoice once editing.
+   * @param {IBillEditingPayload}
+   */
+  private validateSaleEstimateWarehouseExistanceOnEditing = async ({
+    tenantId,
+    billDTO,
+  }: IBillEditingPayload) => {
+    await this.warehouseDTOValidator.validateDTOWarehouseWhenActive(
+      tenantId,
+      billDTO
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Validators/Purchases/VendorCreditWarehousesSubscriber.ts b/packages/server/src/services/Warehouses/Subscribers/Validators/Purchases/VendorCreditWarehousesSubscriber.ts
new file mode 100644
index 000000000..425bcd89f
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Validators/Purchases/VendorCreditWarehousesSubscriber.ts
@@ -0,0 +1,56 @@
+import { Inject, Service } from 'typedi';
+import {
+  IVendorCreditCreatingPayload,
+  IVendorCreditEditingPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import { WarehousesDTOValidators } from '../../../Integrations/WarehousesDTOValidators';
+
+@Service()
+export class VendorCreditWarehousesValidateSubscriber {
+  @Inject()
+  warehouseDTOValidator: WarehousesDTOValidators;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.vendorCredit.onCreating,
+      this.validateVendorCreditWarehouseExistanceOnCreating
+    );
+    bus.subscribe(
+      events.vendorCredit.onEditing,
+      this.validateSaleEstimateWarehouseExistanceOnEditing
+    );
+    return bus;
+  }
+
+  /**
+   * Validate warehouse existance of sale invoice once creating.
+   * @param {IVendorCreditCreatingPayload}
+   */
+  private validateVendorCreditWarehouseExistanceOnCreating = async ({
+    vendorCreditCreateDTO,
+    tenantId,
+  }: IVendorCreditCreatingPayload) => {
+    await this.warehouseDTOValidator.validateDTOWarehouseWhenActive(
+      tenantId,
+      vendorCreditCreateDTO
+    );
+  };
+
+  /**
+   * Validate warehouse existance of sale invoice once editing.
+   * @param {IVendorCreditEditingPayload}
+   */
+  private validateSaleEstimateWarehouseExistanceOnEditing = async ({
+    tenantId,
+    vendorCreditDTO,
+  }: IVendorCreditEditingPayload) => {
+    await this.warehouseDTOValidator.validateDTOWarehouseWhenActive(
+      tenantId,
+      vendorCreditDTO
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Validators/Sales/CreditNoteWarehousesSubscriber.ts b/packages/server/src/services/Warehouses/Subscribers/Validators/Sales/CreditNoteWarehousesSubscriber.ts
new file mode 100644
index 000000000..4a6f65c1e
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Validators/Sales/CreditNoteWarehousesSubscriber.ts
@@ -0,0 +1,56 @@
+import { Inject, Service } from 'typedi';
+import {
+  ICreditNoteCreatingPayload,
+  ICreditNoteEditingPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import { WarehousesDTOValidators } from '../../../Integrations/WarehousesDTOValidators';
+
+@Service()
+export class CreditNoteWarehousesValidateSubscriber {
+  @Inject()
+  warehouseDTOValidator: WarehousesDTOValidators;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.creditNote.onCreating,
+      this.validateCreditNoteWarehouseExistanceOnCreating
+    );
+    bus.subscribe(
+      events.creditNote.onEditing,
+      this.validateCreditNoteWarehouseExistanceOnEditing
+    );
+    return bus;
+  }
+
+  /**
+   * Validate warehouse existance of sale invoice once creating.
+   * @param {ICreditNoteCreatingPayload}
+   */
+  private validateCreditNoteWarehouseExistanceOnCreating = async ({
+    creditNoteDTO,
+    tenantId,
+  }: ICreditNoteCreatingPayload) => {
+    await this.warehouseDTOValidator.validateDTOWarehouseWhenActive(
+      tenantId,
+      creditNoteDTO
+    );
+  };
+
+  /**
+   * Validate warehouse existance of sale invoice once editing.
+   * @param {ICreditNoteEditingPayload}
+   */
+  private validateCreditNoteWarehouseExistanceOnEditing = async ({
+    tenantId,
+    creditNoteEditDTO,
+  }: ICreditNoteEditingPayload) => {
+    await this.warehouseDTOValidator.validateDTOWarehouseWhenActive(
+      tenantId,
+      creditNoteEditDTO
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Validators/Sales/SaleEstimateWarehousesSubscriber.ts b/packages/server/src/services/Warehouses/Subscribers/Validators/Sales/SaleEstimateWarehousesSubscriber.ts
new file mode 100644
index 000000000..402ecb04a
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Validators/Sales/SaleEstimateWarehousesSubscriber.ts
@@ -0,0 +1,56 @@
+import { Inject, Service } from 'typedi';
+import {
+  ISaleEstimateCreatingPayload,
+  ISaleEstimateEditingPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import { WarehousesDTOValidators } from '../../../Integrations/WarehousesDTOValidators';
+
+@Service()
+export class SaleEstimateWarehousesValidateSubscriber {
+  @Inject()
+  warehouseDTOValidator: WarehousesDTOValidators;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleEstimate.onCreating,
+      this.validateSaleEstimateWarehouseExistanceOnCreating
+    );
+    bus.subscribe(
+      events.saleEstimate.onEditing,
+      this.validateSaleEstimateWarehouseExistanceOnEditing
+    );
+    return bus;
+  }
+
+  /**
+   * Validate warehouse existance of sale invoice once creating.
+   * @param {ISaleEstimateCreatingPayload}
+   */
+  private validateSaleEstimateWarehouseExistanceOnCreating = async ({
+    estimateDTO,
+    tenantId,
+  }: ISaleEstimateCreatingPayload) => {
+    await this.warehouseDTOValidator.validateDTOWarehouseWhenActive(
+      tenantId,
+      estimateDTO
+    );
+  };
+
+  /**
+   * Validate warehouse existance of sale invoice once editing.
+   * @param {ISaleEstimateEditingPayload}
+   */
+  private validateSaleEstimateWarehouseExistanceOnEditing = async ({
+    tenantId,
+    estimateDTO,
+  }: ISaleEstimateEditingPayload) => {
+    await this.warehouseDTOValidator.validateDTOWarehouseWhenActive(
+      tenantId,
+      estimateDTO
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Validators/Sales/SaleInvoicesWarehousesSubscriber.ts b/packages/server/src/services/Warehouses/Subscribers/Validators/Sales/SaleInvoicesWarehousesSubscriber.ts
new file mode 100644
index 000000000..bc04b7228
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Validators/Sales/SaleInvoicesWarehousesSubscriber.ts
@@ -0,0 +1,56 @@
+import { Inject, Service } from 'typedi';
+import {
+  ISaleInvoiceCreatingPaylaod,
+  ISaleInvoiceEditingPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import { WarehousesDTOValidators } from '../../../Integrations/WarehousesDTOValidators';
+
+@Service()
+export class SaleInvoicesWarehousesValidateSubscriber {
+  @Inject()
+  warehousesDTOValidator: WarehousesDTOValidators;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleInvoice.onCreating,
+      this.validateSaleInvoiceWarehouseExistanceOnCreating
+    );
+    bus.subscribe(
+      events.saleInvoice.onEditing,
+      this.validateSaleInvoiceWarehouseExistanceOnEditing
+    );
+    return bus;
+  }
+
+  /**
+   * Validate warehouse existance of sale invoice once creating.
+   * @param {ISaleInvoiceCreatingPaylaod}
+   */
+  private validateSaleInvoiceWarehouseExistanceOnCreating = async ({
+    saleInvoiceDTO,
+    tenantId,
+  }: ISaleInvoiceCreatingPaylaod) => {
+    await this.warehousesDTOValidator.validateDTOWarehouseWhenActive(
+      tenantId,
+      saleInvoiceDTO
+    );
+  };
+
+  /**
+   * Validate warehouse existance of sale invoice once editing.
+   * @param {ISaleInvoiceEditingPayload}
+   */
+  private validateSaleInvoiceWarehouseExistanceOnEditing = async ({
+    tenantId,
+    saleInvoiceDTO,
+  }: ISaleInvoiceEditingPayload) => {
+    await this.warehousesDTOValidator.validateDTOWarehouseWhenActive(
+      tenantId,
+      saleInvoiceDTO
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Validators/Sales/SaleReceiptWarehousesSubscriber.ts b/packages/server/src/services/Warehouses/Subscribers/Validators/Sales/SaleReceiptWarehousesSubscriber.ts
new file mode 100644
index 000000000..a32620706
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Validators/Sales/SaleReceiptWarehousesSubscriber.ts
@@ -0,0 +1,56 @@
+import { Inject, Service } from 'typedi';
+import {
+  ISaleReceiptCreatingPayload,
+  ISaleReceiptEditingPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import { WarehousesDTOValidators } from '../../../Integrations/WarehousesDTOValidators';
+
+@Service()
+export class SaleReceiptWarehousesValidateSubscriber {
+  @Inject()
+  private warehousesDTOValidator: WarehousesDTOValidators;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleReceipt.onCreating,
+      this.validateSaleReceiptWarehouseExistanceOnCreating
+    );
+    bus.subscribe(
+      events.saleReceipt.onEditing,
+      this.validateSaleReceiptWarehouseExistanceOnEditing
+    );
+    return bus;
+  }
+
+  /**
+   * Validate warehouse existance of sale invoice once creating.
+   * @param {ISaleReceiptCreatingPayload}
+   */
+  private validateSaleReceiptWarehouseExistanceOnCreating = async ({
+    saleReceiptDTO,
+    tenantId,
+  }: ISaleReceiptCreatingPayload) => {
+    await this.warehousesDTOValidator.validateDTOWarehouseWhenActive(
+      tenantId,
+      saleReceiptDTO
+    );
+  };
+
+  /**
+   * Validate warehouse existance of sale invoice once editing.
+   * @param {ISaleReceiptEditingPayload}
+   */
+  private validateSaleReceiptWarehouseExistanceOnEditing = async ({
+    tenantId,
+    saleReceiptDTO,
+  }: ISaleReceiptEditingPayload) => {
+    await this.warehousesDTOValidator.validateDTOWarehouseWhenActive(
+      tenantId,
+      saleReceiptDTO
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/Subscribers/Validators/index.ts b/packages/server/src/services/Warehouses/Subscribers/Validators/index.ts
new file mode 100644
index 000000000..f0d4daa1d
--- /dev/null
+++ b/packages/server/src/services/Warehouses/Subscribers/Validators/index.ts
@@ -0,0 +1,9 @@
+export * from './Purchases/BillWarehousesSubscriber';
+export * from './Purchases/VendorCreditWarehousesSubscriber';
+
+export * from './Sales/SaleEstimateWarehousesSubscriber';
+export * from './Sales/CreditNoteWarehousesSubscriber';
+export * from './Sales/SaleInvoicesWarehousesSubscriber';
+export * from './Sales/SaleReceiptWarehousesSubscriber';
+
+export * from './InventoryAdjustment/InventoryAdjustmentWarehouseValidatorSubscriber';
\ No newline at end of file
diff --git a/packages/server/src/services/Warehouses/UpdateInventoryTransactionsWithWarehouse.ts b/packages/server/src/services/Warehouses/UpdateInventoryTransactionsWithWarehouse.ts
new file mode 100644
index 000000000..82d8e3a8a
--- /dev/null
+++ b/packages/server/src/services/Warehouses/UpdateInventoryTransactionsWithWarehouse.ts
@@ -0,0 +1,21 @@
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Service, Inject } from 'typedi';
+
+@Service()
+export class UpdateInventoryTransactionsWithWarehouse {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Updates all inventory transactions with primary warehouse.
+   * @param {number} tenantId -
+   * @param {number} warehouseId -
+   */
+  public run = async (tenantId: number, primaryWarehouseId: number) => {
+    const { InventoryTransaction } = this.tenancy.models(tenantId);
+
+    await InventoryTransaction.query().update({
+      warehouseId: primaryWarehouseId,
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehouseMarkPrimary.ts b/packages/server/src/services/Warehouses/WarehouseMarkPrimary.ts
new file mode 100644
index 000000000..4b11e1b93
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehouseMarkPrimary.ts
@@ -0,0 +1,64 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import { CRUDWarehouse } from './CRUDWarehouse';
+import {
+  IWarehouseMarkAsPrimaryPayload,
+  IWarehouseMarkedAsPrimaryPayload,
+} from '@/interfaces';
+
+@Service()
+export class WarehouseMarkPrimary extends CRUDWarehouse {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Marks the given warehouse as primary.
+   * @param   {number} tenantId
+   * @param   {number} warehouseId
+   * @returns {Promise<IWarehouse>}
+   */
+  public markAsPrimary = async (tenantId: number, warehouseId: number) => {
+    const { Warehouse } = this.tenancy.models(tenantId);
+
+    const oldWarehouse = await this.getWarehouseOrThrowNotFound(
+      tenantId,
+      warehouseId
+    );
+    // Updates the branches under unit-of-work enivrement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onWarehouseMarkPrimary` event.
+      await this.eventPublisher.emitAsync(events.warehouse.onMarkPrimary, {
+        tenantId,
+        oldWarehouse,
+        trx,
+      } as IWarehouseMarkAsPrimaryPayload);
+      // marks all warehouses as not primary.
+      await Warehouse.query(trx).update({ primary: false });
+
+      // Marks the particular branch as primary.
+      const markedWarehouse = await Warehouse.query(trx).patchAndFetchById(
+        warehouseId,
+        { primary: true }
+      );
+      // Triggers `onWarehouseMarkedPrimary` event.
+      await this.eventPublisher.emitAsync(events.warehouse.onMarkedPrimary, {
+        tenantId,
+        oldWarehouse,
+        markedWarehouse,
+        trx,
+      } as IWarehouseMarkedAsPrimaryPayload);
+
+      return markedWarehouse;
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehouseValidator.ts b/packages/server/src/services/Warehouses/WarehouseValidator.ts
new file mode 100644
index 000000000..3ce99283c
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehouseValidator.ts
@@ -0,0 +1,57 @@
+import { Inject, Service } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ServiceError, ServiceErrors } from '@/exceptions';
+import { ERRORS } from './contants';
+
+@Service()
+export class WarehouseValidator {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {number} warehouseId
+   */
+  public validateWarehouseNotOnlyWarehouse = async (
+    tenantId: number,
+    warehouseId: number
+  ) => {
+    const { Warehouse } = this.tenancy.models(tenantId);
+
+    const warehouses = await Warehouse.query().whereNot('id', warehouseId);
+
+    if (warehouses.length === 0) {
+      throw new ServiceError(ERRORS.COULD_NOT_DELETE_ONLY_WAERHOUSE);
+    }
+  };
+
+  /**
+   * 
+   * @param tenantId 
+   * @param code 
+   * @param exceptWarehouseId 
+   */
+  public validateWarehouseCodeUnique = async (
+    tenantId: number,
+    code: string,
+    exceptWarehouseId?: number
+  ) => {
+    const { Warehouse } = this.tenancy.models(tenantId);
+
+    const warehouse = await Warehouse.query()
+      .onBuild((query) => {
+        query.select(['id']);
+        query.where('code', code);
+
+        if (exceptWarehouseId) {
+          query.whereNot('id', exceptWarehouseId);
+        }
+      })
+      .first();
+
+    if (warehouse) {
+      throw new ServiceError(ERRORS.WAREHOUSE_CODE_NOT_UNIQUE);
+    }
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesApplication.ts b/packages/server/src/services/Warehouses/WarehousesApplication.ts
new file mode 100644
index 000000000..0577fcbbb
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesApplication.ts
@@ -0,0 +1,137 @@
+import { ICreateWarehouseDTO, IEditWarehouseDTO, IWarehouse } from '@/interfaces';
+import { Inject, Service } from 'typedi';
+import { ActivateWarehouses } from './ActivateWarehouses';
+import { CreateWarehouse } from './CreateWarehouse';
+import { DeleteWarehouse } from './DeleteWarehouse';
+import { EditWarehouse } from './EditWarehouse';
+import { GetWarehouse } from './GetWarehouse';
+import { GetWarehouses } from './GetWarehouses';
+import { GetItemWarehouses } from './Items/GetItemWarehouses';
+import { WarehouseMarkPrimary } from './WarehouseMarkPrimary';
+
+@Service()
+export class WarehousesApplication {
+  @Inject()
+  private createWarehouseService: CreateWarehouse;
+
+  @Inject()
+  private editWarehouseService: EditWarehouse;
+
+  @Inject()
+  private deleteWarehouseService: DeleteWarehouse;
+
+  @Inject()
+  private getWarehouseService: GetWarehouse;
+
+  @Inject()
+  private getWarehousesService: GetWarehouses;
+
+  @Inject()
+  private activateWarehousesService: ActivateWarehouses;
+
+  @Inject()
+  private markWarehousePrimaryService: WarehouseMarkPrimary;
+
+  @Inject()
+  private getItemWarehousesService: GetItemWarehouses;
+
+  /**
+   * Creates a new warehouse.
+   * @param   {number} tenantId
+   * @param   {ICreateWarehouseDTO} createWarehouseDTO
+   * @returns
+   */
+  public createWarehouse = (
+    tenantId: number,
+    createWarehouseDTO: ICreateWarehouseDTO
+  ) => {
+    return this.createWarehouseService.createWarehouse(
+      tenantId,
+      createWarehouseDTO
+    );
+  };
+
+  /**
+   * Edits the given warehouse.
+   * @param   {number} tenantId
+   * @param   {number} warehouseId
+   * @param   {IEditWarehouseDTO} editWarehouseDTO
+   * @returns {Promise<void>}
+   */
+  public editWarehouse = (
+    tenantId: number,
+    warehouseId: number,
+    editWarehouseDTO: IEditWarehouseDTO
+  ) => {
+    return this.editWarehouseService.editWarehouse(
+      tenantId,
+      warehouseId,
+      editWarehouseDTO
+    );
+  };
+
+  /**
+   * Deletes the given warehouse.
+   * @param {number} tenantId
+   * @param {number} warehouseId
+   */
+  public deleteWarehouse = (tenantId: number, warehouseId: number) => {
+    return this.deleteWarehouseService.deleteWarehouse(tenantId, warehouseId);
+  };
+
+  /**
+   * Retrieves the specific warehouse.
+   * @param   {number} tenantId
+   * @param   {number} warehouseId
+   * @returns
+   */
+  public getWarehouse = (tenantId: number, warehouseId: number) => {
+    return this.getWarehouseService.getWarehouse(tenantId, warehouseId);
+  };
+
+  /**
+   *
+   * @param   {number} tenantId
+   * @returns
+   */
+  public getWarehouses = (tenantId: number) => {
+    return this.getWarehousesService.getWarehouses(tenantId);
+  };
+
+  /**
+   * Activates the warehouses feature.
+   * @param   {number} tenantId
+   * @returns {Promise<void>}
+   */
+  public activateWarehouses = (tenantId: number) => {
+    return this.activateWarehousesService.activateWarehouses(tenantId);
+  };
+
+  /**
+   * Mark the given warehouse as primary.
+   * @param   {number} tenantId -
+   * @returns {Promise<IWarehouse>}
+   */
+  public markWarehousePrimary = (
+    tenantId: number,
+    warehouseId: number
+  ): Promise<IWarehouse> => {
+    return this.markWarehousePrimaryService.markAsPrimary(
+      tenantId,
+      warehouseId
+    );
+  };
+
+  /**
+   * Retrieves the specific item warehouses quantity. 
+   * @param {number} tenantId 
+   * @param {number} itemId 
+   * @returns 
+   */
+  public getItemWarehouses = (
+    tenantId: number,
+    itemId: number
+  ): Promise<any> => {
+    return this.getItemWarehousesService.getItemWarehouses(tenantId, itemId);
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesService.ts b/packages/server/src/services/Warehouses/WarehousesService.ts
new file mode 100644
index 000000000..67a7405d8
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesService.ts
@@ -0,0 +1,36 @@
+import { Service } from 'typedi';
+
+@Service()
+export class WarehousesService {
+  /**
+   *
+   * @param {number} tenantId
+   * @param {number} warehouseId
+   */
+  getWarehouse = (tenantId: number, warehouseId: number) => {};
+
+  /**
+   *
+   * @param {number} tenantId
+   */
+  getWarehouses = (tenantId: number) => {};
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {number} warehouseId
+   */
+  deleteWarehouse = (tenantId: number, warehouseId: number) => {};
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {number} warehouseId
+   * @param {IEditWarehouseDTO} warehouseDTO
+   */
+  editWarehouse = (
+    tenantId: number,
+    warehouseId: number,
+    warehouseDTO: IEditWarehouseDTO
+  ) => {};
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesSettings.ts b/packages/server/src/services/Warehouses/WarehousesSettings.ts
new file mode 100644
index 000000000..512efce05
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesSettings.ts
@@ -0,0 +1,29 @@
+import { Service, Inject } from 'typedi';
+import { Features } from '@/interfaces';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+@Service()
+export class WarehousesSettings {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  /**
+   * Marks multi-warehouses as activated.
+   */
+  public markMutliwarehoussAsActivated = (tenantId: number) => {
+    const settings = this.tenancy.settings(tenantId);
+
+    settings.set({ group: 'features', key: Features.WAREHOUSES, value: 1 });
+  };
+
+  /**
+   * Detarmines multi-warehouses is active.
+   * @param   {number} tenantId
+   * @returns {boolean}
+   */
+  public isMultiWarehousesActive = (tenantId: number) => {
+    const settings = this.tenancy.settings(tenantId);
+
+    return settings.get({ group: 'features', key: Features.WAREHOUSES });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/CRUDWarehouseTransfer.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/CRUDWarehouseTransfer.ts
new file mode 100644
index 000000000..9a1800792
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/CRUDWarehouseTransfer.ts
@@ -0,0 +1,32 @@
+import { Service, Inject } from 'typedi';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+
+@Service()
+export class CRUDWarehouseTransfer {
+  @Inject()
+  tenancy: HasTenancyService;
+
+
+  throwIfTransferNotFound = (warehouseTransfer) => {
+    if (!warehouseTransfer) {
+      throw new ServiceError(ERRORS.WAREHOUSE_TRANSFER_NOT_FOUND);
+    }
+  }
+
+  public getWarehouseTransferOrThrowNotFound = async (
+    tenantId: number,
+    branchId: number
+  ) => {
+    const { WarehouseTransfer } = this.tenancy.models(tenantId);
+
+    const foundTransfer = await WarehouseTransfer.query().findById(branchId);
+
+    if (!foundTransfer) {
+      throw new ServiceError(ERRORS.WAREHOUSE_TRANSFER_NOT_FOUND);
+    }
+    return foundTransfer;
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/CommandWarehouseTransfer.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/CommandWarehouseTransfer.ts
new file mode 100644
index 000000000..0afe58ff9
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/CommandWarehouseTransfer.ts
@@ -0,0 +1,79 @@
+import { Inject } from 'typedi';
+import {
+  ICreateWarehouseTransferDTO,
+  IEditWarehouseTransferDTO,
+  IItem,
+} from '@/interfaces';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+import { CRUDWarehouseTransfer } from './CRUDWarehouseTransfer';
+
+export class CommandWarehouseTransfer extends CRUDWarehouseTransfer {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  itemsEntries: ItemsEntriesService;
+
+  /**
+   * Validate the from/to warehouses should not be the same.
+   * @param {ICreateWarehouseTransferDTO|IEditWarehouseTransferDTO} warehouseTransferDTO
+   */
+  protected validateWarehouseFromToNotSame = (
+    warehouseTransferDTO:
+      | ICreateWarehouseTransferDTO
+      | IEditWarehouseTransferDTO
+  ) => {
+    if (
+      warehouseTransferDTO.fromWarehouseId ===
+      warehouseTransferDTO.toWarehouseId
+    ) {
+      throw new ServiceError(ERRORS.WAREHOUSES_TRANSFER_SHOULD_NOT_BE_SAME);
+    }
+  };
+
+  /**
+   * Validates entries items should be inventory.
+   * @param   {IItem[]} items
+   * @returns {void}
+   */
+  protected validateItemsShouldBeInventory = (items: IItem[]): void => {
+    const nonInventoryItems = items.filter((item) => item.type !== 'inventory');
+
+    if (nonInventoryItems.length > 0) {
+      throw new ServiceError(
+        ERRORS.WAREHOUSE_TRANSFER_ITEMS_SHOULD_BE_INVENTORY
+      );
+    }
+  };
+
+  protected getToWarehouseOrThrow = async (
+    tenantId: number,
+    fromWarehouseId: number
+  ) => {
+    const { Warehouse } = this.tenancy.models(tenantId);
+
+    const warehouse = await Warehouse.query().findById(fromWarehouseId);
+
+    if (!warehouse) {
+      throw new ServiceError(ERRORS.TO_WAREHOUSE_NOT_FOUND);
+    }
+    return warehouse;
+  };
+
+  protected getFromWarehouseOrThrow = async (
+    tenantId: number,
+    fromWarehouseId: number
+  ) => {
+    const { Warehouse } = this.tenancy.models(tenantId);
+
+    const warehouse = await Warehouse.query().findById(fromWarehouseId);
+
+    if (!warehouse) {
+      throw new ServiceError(ERRORS.FROM_WAREHOUSE_NOT_FOUND);
+    }
+    return warehouse;
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/CreateWarehouseTransfer.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/CreateWarehouseTransfer.ts
new file mode 100644
index 000000000..b9d7c0012
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/CreateWarehouseTransfer.ts
@@ -0,0 +1,204 @@
+import { Knex } from 'knex';
+import { omit, get, isNumber } from 'lodash';
+import * as R from 'ramda';
+import {
+  ICreateWarehouseTransferDTO,
+  IWarehouseTransfer,
+  IWarehouseTransferCreate,
+  IWarehouseTransferCreated,
+  IWarehouseTransferEntryDTO,
+  IInventoryItemCostMeta,
+} from '@/interfaces';
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
+import { CommandWarehouseTransfer } from './CommandWarehouseTransfer';
+import { InventoryItemCostService } from '@/services/Inventory/InventoryCostsService';
+import { WarehouseTransferAutoIncrement } from './WarehouseTransferAutoIncrement';
+
+@Service()
+export class CreateWarehouseTransfer extends CommandWarehouseTransfer {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private itemsEntries: ItemsEntriesService;
+
+  @Inject()
+  private inventoryItemCost: InventoryItemCostService;
+
+  @Inject()
+  private autoIncrementOrders: WarehouseTransferAutoIncrement;
+
+  /**
+   * Transformes the givne new warehouse transfer DTO to model.
+   * @param   {ICreateWarehouseTransferDTO} warehouseTransferDTO
+   * @returns {IWarehouseTransfer}
+   */
+  private transformDTOToModel = async (
+    tenantId: number,
+    warehouseTransferDTO: ICreateWarehouseTransferDTO
+  ): Promise<IWarehouseTransfer> => {
+    const entries = await this.transformEntries(
+      tenantId,
+      warehouseTransferDTO,
+      warehouseTransferDTO.entries
+    );
+    // Retrieves the auto-increment the warehouse transfer number.
+    const autoNextNumber =
+      this.autoIncrementOrders.getNextTransferNumber(tenantId);
+
+    // Warehouse transfer order transaction number.
+    const transactionNumber =
+      warehouseTransferDTO.transactionNumber || autoNextNumber;
+
+    return {
+      ...omit(warehouseTransferDTO, ['transferDelivered', 'transferInitiated']),
+      transactionNumber,
+      ...(warehouseTransferDTO.transferDelivered
+        ? {
+            transferDeliveredAt: new Date(),
+          }
+        : {}),
+      ...(warehouseTransferDTO.transferDelivered ||
+      warehouseTransferDTO.transferInitiated
+        ? {
+            transferInitiatedAt: new Date(),
+          }
+        : {}),
+      entries,
+    };
+  };
+
+  /**
+   * Assoc average cost to the entry that has no cost.
+   * @param {Promise<Map<number, IInventoryItemCostMeta>} inventoryItemsCostMap -
+   * @param {IWarehouseTransferEntryDTO} entry -
+   */
+  private transformEntryAssocAverageCost = R.curry(
+    (
+      inventoryItemsCostMap: Map<number, IInventoryItemCostMeta>,
+      entry: IWarehouseTransferEntryDTO
+    ): IWarehouseTransferEntryDTO => {
+      const itemValuation = inventoryItemsCostMap.get(entry.itemId);
+      const itemCost = get(itemValuation, 'average', 0);
+
+      return isNumber(entry.cost) ? entry : R.assoc('cost', itemCost, entry);
+    }
+  );
+
+  /**
+   * Transformes warehouse transfer entries.
+   * @param    {number} tenantId
+   * @param    {ICreateWarehouseTransferDTO} warehouseTransferDTO
+   * @param    {IWarehouseTransferEntryDTO[]} entries
+   * @returns  {Promise<IWarehouseTransferEntryDTO[]>}
+   */
+  public transformEntries = async (
+    tenantId: number,
+    warehouseTransferDTO: ICreateWarehouseTransferDTO,
+    entries: IWarehouseTransferEntryDTO[]
+  ): Promise<IWarehouseTransferEntryDTO[]> => {
+    const inventoryItemsIds = warehouseTransferDTO.entries.map((e) => e.itemId);
+
+    // Retrieves the inventory items valuation map.
+    const inventoryItemsCostMap =
+      await this.inventoryItemCost.getItemsInventoryValuation(
+        tenantId,
+        inventoryItemsIds,
+        warehouseTransferDTO.date
+      );
+    // Assoc average cost to the entry.
+    const assocAverageCost = this.transformEntryAssocAverageCost(
+      inventoryItemsCostMap
+    );
+    return R.map(assocAverageCost)(entries);
+  };
+
+  /**
+   * Authorize warehouse transfer before creating.
+   * @param {number} tenantId
+   * @param {ICreateWarehouseTransferDTO} warehouseTransferDTO
+   */
+  public authorize = async (
+    tenantId: number,
+    warehouseTransferDTO: ICreateWarehouseTransferDTO
+  ) => {
+    // Validate warehouse from and to should not be the same.
+    this.validateWarehouseFromToNotSame(warehouseTransferDTO);
+
+    // Retrieves the from warehouse or throw not found service error.
+    const fromWarehouse = await this.getFromWarehouseOrThrow(
+      tenantId,
+      warehouseTransferDTO.fromWarehouseId
+    );
+    // Retrieves the to warehouse or throw not found service error.
+    const toWarehouse = await this.getToWarehouseOrThrow(
+      tenantId,
+      warehouseTransferDTO.toWarehouseId
+    );
+    // Validates the not found entries items ids.
+    const items = await this.itemsEntries.validateItemsIdsExistance(
+      tenantId,
+      warehouseTransferDTO.entries
+    );
+    // Validate the items entries should be inventory type.
+    this.validateItemsShouldBeInventory(items);
+  };
+
+  /**
+   * Creates a new warehouse transfer transaction.
+   * @param   {number} tenantId -
+   * @param   {ICreateWarehouseTransferDTO} warehouseDTO -
+   * @returns {Promise<IWarehouseTransferCreate>}
+   */
+  public createWarehouseTransfer = async (
+    tenantId: number,
+    warehouseTransferDTO: ICreateWarehouseTransferDTO
+  ): Promise<IWarehouseTransfer> => {
+    const { WarehouseTransfer } = this.tenancy.models(tenantId);
+
+    // Authorize warehouse transfer before creating.
+    await this.authorize(tenantId, warehouseTransferDTO);
+
+    // Transformes the warehouse transfer DTO to model.
+    const warehouseTransferModel = await this.transformDTOToModel(
+      tenantId,
+      warehouseTransferDTO
+    );
+    // Create warehouse transfer under unit-of-work.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onWarehouseTransferCreate` event.
+      await this.eventPublisher.emitAsync(events.warehouseTransfer.onCreate, {
+        trx,
+        warehouseTransferDTO,
+        tenantId,
+      } as IWarehouseTransferCreate);
+
+      // Stores the warehouse transfer transaction graph to the storage.
+      const warehouseTransfer = await WarehouseTransfer.query(
+        trx
+      ).upsertGraphAndFetch({
+        ...warehouseTransferModel,
+      });
+      // Triggers `onWarehouseTransferCreated` event.
+      await this.eventPublisher.emitAsync(events.warehouseTransfer.onCreated, {
+        trx,
+        warehouseTransfer,
+        warehouseTransferDTO,
+        tenantId,
+      } as IWarehouseTransferCreated);
+
+      return warehouseTransfer;
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/DeleteWarehouseTransfer.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/DeleteWarehouseTransfer.ts
new file mode 100644
index 000000000..3a40e5163
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/DeleteWarehouseTransfer.ts
@@ -0,0 +1,67 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import {
+  IWarehouseTransferDeletedPayload,
+  IWarehouseTransferDeletePayload,
+} from '@/interfaces';
+import { CRUDWarehouseTransfer } from './CRUDWarehouseTransfer';
+
+@Service()
+export class DeleteWarehouseTransfer extends CRUDWarehouseTransfer {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Deletes warehouse transfer transaction.
+   * @param   {number} tenantId
+   * @param   {number} warehouseTransferId
+   * @returns {Promise<void>}
+   */
+  public deleteWarehouseTransfer = async (
+    tenantId: number,
+    warehouseTransferId: number
+  ): Promise<void> => {
+    const { WarehouseTransfer, WarehouseTransferEntry } =
+      this.tenancy.models(tenantId);
+
+    // Retrieve the old warehouse transfer or throw not found service error.
+    const oldWarehouseTransfer = await WarehouseTransfer.query()
+      .findById(warehouseTransferId)
+      .throwIfNotFound();
+
+    // Deletes the warehouse transfer under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onWarehouseTransferCreate` event.
+      await this.eventPublisher.emitAsync(events.warehouseTransfer.onDelete, {
+        tenantId,
+        oldWarehouseTransfer,
+        trx,
+      } as IWarehouseTransferDeletePayload);
+
+      // Delete warehouse transfer entries.
+      await WarehouseTransferEntry.query(trx)
+        .where('warehouseTransferId', warehouseTransferId)
+        .delete();
+
+      // Delete warehouse transfer.
+      await WarehouseTransfer.query(trx).findById(warehouseTransferId).delete();
+
+      // Triggers `onWarehouseTransferDeleted` event
+      await this.eventPublisher.emitAsync(events.warehouseTransfer.onDeleted, {
+        tenantId,
+        oldWarehouseTransfer,
+        trx,
+      } as IWarehouseTransferDeletedPayload);
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/EditWarehouseTransfer.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/EditWarehouseTransfer.ts
new file mode 100644
index 000000000..f12d62a31
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/EditWarehouseTransfer.ts
@@ -0,0 +1,95 @@
+import { Service, Inject } from 'typedi';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import { Knex } from 'knex';
+import events from '@/subscribers/events';
+import {
+  IEditWarehouseTransferDTO,
+  IWarehouseTransfer,
+  IWarehouseTransferEditPayload,
+  IWarehouseTransferEditedPayload,
+} from '@/interfaces';
+import { CommandWarehouseTransfer } from './CommandWarehouseTransfer';
+
+@Service()
+export class EditWarehouseTransfer extends CommandWarehouseTransfer {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  /**
+   * Edits warehouse transfer.
+   * @param   {number} tenantId
+   * @param   {number} warehouseTransferId
+   * @param   {IEditWarehouseTransferDTO} editWarehouseDTO
+   * @returns {Promise<IWarehouseTransfer>}
+   */
+  public editWarehouseTransfer = async (
+    tenantId: number,
+    warehouseTransferId: number,
+    editWarehouseDTO: IEditWarehouseTransferDTO
+  ): Promise<IWarehouseTransfer> => {
+    const { WarehouseTransfer } = this.tenancy.models(tenantId);
+
+    // Retrieves the old warehouse transfer transaction.
+    const oldWarehouseTransfer = await WarehouseTransfer.query()
+      .findById(warehouseTransferId)
+      .throwIfNotFound();
+
+    // Validate warehouse from and to should not be the same.
+    this.validateWarehouseFromToNotSame(editWarehouseDTO);
+
+    // Retrieves the from warehouse or throw not found service error.
+    const fromWarehouse = await this.getFromWarehouseOrThrow(
+      tenantId,
+      editWarehouseDTO.fromWarehouseId
+    );
+    // Retrieves the to warehouse or throw not found service error.
+    const toWarehouse = await this.getToWarehouseOrThrow(
+      tenantId,
+      editWarehouseDTO.toWarehouseId
+    );
+    // Validates the not found entries items ids.
+    const items = await this.itemsEntries.validateItemsIdsExistance(
+      tenantId,
+      editWarehouseDTO.entries
+    );
+    // Validate the items entries should be inventory type.
+    this.validateItemsShouldBeInventory(items);
+
+    // Edits warehouse transfer transaction under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onWarehouseTransferEdit` event.
+      await this.eventPublisher.emitAsync(events.warehouseTransfer.onEdit, {
+        tenantId,
+        editWarehouseDTO,
+        oldWarehouseTransfer,
+        trx,
+      } as IWarehouseTransferEditPayload);
+
+      // Updates warehouse transfer graph on the storage.
+      const warehouseTransfer = await WarehouseTransfer.query(
+        trx
+      ).upsertGraphAndFetch({
+        id: warehouseTransferId,
+        ...editWarehouseDTO,
+      });
+      // Triggers `onWarehouseTransferEdit` event
+      await this.eventPublisher.emitAsync(events.warehouseTransfer.onEdited, {
+        tenantId,
+        editWarehouseDTO,
+        warehouseTransfer,
+        oldWarehouseTransfer,
+        trx,
+      } as IWarehouseTransferEditedPayload);
+
+      return warehouseTransfer;
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/GetWarehouseTransfer.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/GetWarehouseTransfer.ts
new file mode 100644
index 000000000..80f350578
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/GetWarehouseTransfer.ts
@@ -0,0 +1,45 @@
+import { Service, Inject } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { IWarehouseTransfer } from '@/interfaces';
+import { CRUDWarehouseTransfer } from './CRUDWarehouseTransfer';
+import { WarehouseTransferTransformer } from './WarehouseTransferTransfomer';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export class GetWarehouseTransfer extends CRUDWarehouseTransfer {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieves the specific warehouse transfer transaction.
+   * @param   {number} tenantId
+   * @param   {number} warehouseTransferId
+   * @param   {IEditWarehouseTransferDTO} editWarehouseDTO
+   * @returns {Promise<IWarehouseTransfer>}
+   */
+  public getWarehouseTransfer = async (
+    tenantId: number,
+    warehouseTransferId: number
+  ): Promise<IWarehouseTransfer> => {
+    const { WarehouseTransfer } = this.tenancy.models(tenantId);
+
+    // Retrieves the old warehouse transfer transaction.
+    const warehouseTransfer = await WarehouseTransfer.query()
+      .findById(warehouseTransferId)
+      .withGraphFetched('entries.item')
+      .withGraphFetched('fromWarehouse')
+      .withGraphFetched('toWarehouse');
+
+    this.throwIfTransferNotFound(warehouseTransfer);
+
+    // Retrieves the transfromed warehouse transfers.
+    return this.transformer.transform(
+      tenantId,
+      warehouseTransfer,
+      new WarehouseTransferTransformer()
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/GetWarehouseTransfers.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/GetWarehouseTransfers.ts
new file mode 100644
index 000000000..43635a55a
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/GetWarehouseTransfers.ts
@@ -0,0 +1,72 @@
+import * as R from 'ramda';
+import { Service, Inject } from 'typedi';
+import DynamicListingService from '@/services/DynamicListing/DynamicListService';
+import { IGetWarehousesTransfersFilterDTO } from '@/interfaces';
+import { WarehouseTransferTransformer } from './WarehouseTransferTransfomer';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+
+@Service()
+export class GetWarehouseTransfers {
+  @Inject()
+  private dynamicListService: DynamicListingService;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Parses the sale invoice list filter DTO.
+   * @param filterDTO
+   * @returns
+   */
+  private parseListFilterDTO(filterDTO) {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  }
+
+  /**
+   * Retrieves warehouse transfers paginated list.
+   * @param   {number} tenantId
+   * @param   {IGetWarehousesTransfersFilterDTO} filterDTO
+   * @returns {}
+   */
+  public getWarehouseTransfers = async (
+    tenantId: number,
+    filterDTO: IGetWarehousesTransfersFilterDTO
+  ) => {
+    const { WarehouseTransfer } = this.tenancy.models(tenantId);
+
+    // Parses stringified filter roles.
+    const filter = this.parseListFilterDTO(filterDTO);
+
+    // Dynamic list service.
+    const dynamicFilter = await this.dynamicListService.dynamicList(
+      tenantId,
+      WarehouseTransfer,
+      filter
+    );
+    const { results, pagination } = await WarehouseTransfer.query()
+      .onBuild((query) => {
+        query.withGraphFetched('entries.item');
+        query.withGraphFetched('fromWarehouse');
+        query.withGraphFetched('toWarehouse');
+
+        dynamicFilter.buildQuery()(query);
+      })
+      .pagination(filter.page - 1, filter.pageSize);
+
+    // Retrieves the transformed warehouse transfers
+    const warehousesTransfers = await this.transformer.transform(
+      tenantId,
+      results,
+      new WarehouseTransferTransformer()
+    );
+    return {
+      warehousesTransfers,
+      pagination,
+      filter,
+    };
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/InitiateWarehouseTransfer.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/InitiateWarehouseTransfer.ts
new file mode 100644
index 000000000..4e40455bb
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/InitiateWarehouseTransfer.ts
@@ -0,0 +1,92 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import {
+  IWarehouseTransfer,
+  IWarehouseTransferEditedPayload,
+  IWarehouseTransferInitiatePayload,
+} from '@/interfaces';
+import { CommandWarehouseTransfer } from './CommandWarehouseTransfer';
+import { ServiceError } from '@/exceptions';
+import { ERRORS } from './constants';
+
+@Service()
+export class InitiateWarehouseTransfer extends CommandWarehouseTransfer {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Validate the given warehouse transfer not already initiated.
+   * @param {IWarehouseTransfer} warehouseTransfer
+   */
+  private validateWarehouseTransferNotAlreadyInitiated = (
+    warehouseTransfer: IWarehouseTransfer
+  ) => {
+    if (warehouseTransfer.transferInitiatedAt) {
+      throw new ServiceError(ERRORS.WAREHOUSE_TRANSFER_ALREADY_INITIATED);
+    }
+  };
+
+  /**
+   * Initiate warehouse transfer.
+   * @param   {number} tenantId
+   * @param   {number} warehouseTransferId
+   * @returns {Promise<IWarehouseTransfer>}
+   */
+  public initiateWarehouseTransfer = async (
+    tenantId: number,
+    warehouseTransferId: number
+  ): Promise<IWarehouseTransfer> => {
+    const { WarehouseTransfer } = this.tenancy.models(tenantId);
+
+    // Retrieves the old warehouse transfer transaction.
+    const oldWarehouseTransfer = await WarehouseTransfer.query()
+      .findById(warehouseTransferId)
+      .throwIfNotFound(warehouseTransferId);
+
+    // Validate the given warehouse transfer not already initiated.
+    this.validateWarehouseTransferNotAlreadyInitiated(oldWarehouseTransfer);
+
+    // Edits warehouse transfer transaction under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onWarehouseTransferInitiate` event.
+      await this.eventPublisher.emitAsync(events.warehouseTransfer.onInitiate, {
+        tenantId,
+        oldWarehouseTransfer,
+        trx,
+      } as IWarehouseTransferInitiatePayload);
+
+      // Updates warehouse transfer graph on the storage.
+      const warehouseTransferUpdated = await WarehouseTransfer.query(trx)
+        .findById(warehouseTransferId)
+        .patch({
+          transferInitiatedAt: new Date(),
+        });
+      // Fetches the warehouse transfer with entries.
+      const warehouseTransfer = await WarehouseTransfer.query(trx)
+        .findById(warehouseTransferId)
+        .withGraphFetched('entries');
+
+      // Triggers `onWarehouseTransferEdit` event
+      await this.eventPublisher.emitAsync(
+        events.warehouseTransfer.onInitiated,
+        {
+          tenantId,
+          warehouseTransfer,
+          oldWarehouseTransfer,
+          trx,
+        } as IWarehouseTransferEditedPayload
+      );
+      return warehouseTransfer;
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/TransferredWarehouseTransfer.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/TransferredWarehouseTransfer.ts
new file mode 100644
index 000000000..6e5f52722
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/TransferredWarehouseTransfer.ts
@@ -0,0 +1,107 @@
+import { Service, Inject } from 'typedi';
+import { Knex } from 'knex';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import UnitOfWork from '@/services/UnitOfWork';
+import events from '@/subscribers/events';
+import {
+  IWarehouseTransfer,
+  IWarehouseTransferTransferingPayload,
+  IWarehouseTransferTransferredPayload,
+} from '@/interfaces';
+import { CommandWarehouseTransfer } from './CommandWarehouseTransfer';
+import { ERRORS } from './constants';
+import { ServiceError } from '@/exceptions';
+
+@Service()
+export class TransferredWarehouseTransfer extends CommandWarehouseTransfer {
+  @Inject()
+  tenancy: HasTenancyService;
+
+  @Inject()
+  uow: UnitOfWork;
+
+  @Inject()
+  eventPublisher: EventPublisher;
+
+  /**
+   * Validate the warehouse transfer not already transferred.
+   * @param {IWarehouseTransfer} warehouseTransfer
+   */
+  private validateWarehouseTransferNotTransferred = (
+    warehouseTransfer: IWarehouseTransfer
+  ) => {
+    if (warehouseTransfer.transferDeliveredAt) {
+      throw new ServiceError(ERRORS.WAREHOUSE_TRANSFER_ALREAD_TRANSFERRED);
+    }
+  };
+
+  /**
+   * Validate the warehouse transfer should be initiated.
+   * @param {IWarehouseTransfer} warehouseTransfer
+   */
+  private validateWarehouseTranbsferShouldInitiated = (
+    warehouseTransfer: IWarehouseTransfer
+  ) => {
+    if (!warehouseTransfer.transferInitiatedAt) {
+      throw new ServiceError(ERRORS.WAREHOUSE_TRANSFER_NOT_INITIATED);
+    }
+  };
+
+  /**
+   * Transferred warehouse transfer.
+   * @param   {number} tenantId
+   * @param   {number} warehouseTransferId
+   * @returns {Promise<IWarehouseTransfer>}
+   */
+  public transferredWarehouseTransfer = async (
+    tenantId: number,
+    warehouseTransferId: number
+  ): Promise<IWarehouseTransfer> => {
+    const { WarehouseTransfer } = this.tenancy.models(tenantId);
+
+    // Retrieves the old warehouse transfer transaction.
+    const oldWarehouseTransfer = await WarehouseTransfer.query()
+      .findById(warehouseTransferId)
+      .throwIfNotFound();
+
+    // Validate the warehouse transfer not already transferred.
+    this.validateWarehouseTransferNotTransferred(oldWarehouseTransfer);
+
+    // Validate the warehouse transfer should be initiated.
+    this.validateWarehouseTranbsferShouldInitiated(oldWarehouseTransfer);
+
+    // Edits warehouse transfer transaction under unit-of-work envirement.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onWarehouseTransferInitiate` event.
+      await this.eventPublisher.emitAsync(events.warehouseTransfer.onTransfer, {
+        tenantId,
+        oldWarehouseTransfer,
+        trx,
+      } as IWarehouseTransferTransferingPayload);
+
+      // Updates warehouse transfer graph on the storage.
+      const warehouseTransferUpdated = await WarehouseTransfer.query(trx)
+        .findById(warehouseTransferId)
+        .patch({
+          transferDeliveredAt: new Date(),
+        });
+      // Fetches the warehouse transfer with entries.
+      const warehouseTransfer = await WarehouseTransfer.query(trx)
+        .findById(warehouseTransferId)
+        .withGraphFetched('entries');
+
+      // Triggers `onWarehouseTransferEdit` event
+      await this.eventPublisher.emitAsync(
+        events.warehouseTransfer.onTransferred,
+        {
+          tenantId,
+          warehouseTransfer,
+          oldWarehouseTransfer,
+          trx,
+        } as IWarehouseTransferTransferredPayload
+      );
+      return warehouseTransfer;
+    });
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferApplication.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferApplication.ts
new file mode 100644
index 000000000..4e27b5092
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferApplication.ts
@@ -0,0 +1,152 @@
+import {
+  ICreateWarehouseTransferDTO,
+  IEditWarehouseTransferDTO,
+  IGetWarehousesTransfersFilterDTO,
+  IWarehouseTransfer,
+} from '@/interfaces';
+import { Service, Inject } from 'typedi';
+import { CreateWarehouseTransfer } from './CreateWarehouseTransfer';
+import { DeleteWarehouseTransfer } from './DeleteWarehouseTransfer';
+import { EditWarehouseTransfer } from './EditWarehouseTransfer';
+import { GetWarehouseTransfer } from './GetWarehouseTransfer';
+import { GetWarehouseTransfers } from './GetWarehouseTransfers';
+import { InitiateWarehouseTransfer } from './InitiateWarehouseTransfer';
+import { TransferredWarehouseTransfer } from './TransferredWarehouseTransfer';
+
+@Service()
+export class WarehouseTransferApplication {
+  @Inject()
+  private createWarehouseTransferService: CreateWarehouseTransfer;
+
+  @Inject()
+  private editWarehouseTransferService: EditWarehouseTransfer;
+
+  @Inject()
+  private deleteWarehouseTransferService: DeleteWarehouseTransfer;
+
+  @Inject()
+  private getWarehouseTransferService: GetWarehouseTransfer;
+
+  @Inject()
+  private getWarehousesTransfersService: GetWarehouseTransfers;
+
+  @Inject()
+  private initiateWarehouseTransferService: InitiateWarehouseTransfer;
+
+  @Inject()
+  private transferredWarehouseTransferService: TransferredWarehouseTransfer;
+
+  /**
+   * Creates a warehouse transfer transaction.
+   * @param   {number} tenantId
+   * @param   {ICreateWarehouseTransferDTO} createWarehouseTransferDTO
+   * @returns {}
+   */
+  public createWarehouseTransfer = (
+    tenantId: number,
+    createWarehouseTransferDTO: ICreateWarehouseTransferDTO
+  ): Promise<IWarehouseTransfer> => {
+    return this.createWarehouseTransferService.createWarehouseTransfer(
+      tenantId,
+      createWarehouseTransferDTO
+    );
+  };
+
+  /**
+   * Edits warehouse transfer transaction.
+   * @param {number} tenantId -
+   * @param {number} warehouseTransferId - number
+   * @param {IEditWarehouseTransferDTO} editWarehouseTransferDTO
+   */
+  public editWarehouseTransfer = (
+    tenantId: number,
+    warehouseTransferId: number,
+    editWarehouseTransferDTO: IEditWarehouseTransferDTO
+  ): Promise<IWarehouseTransfer> => {
+    return this.editWarehouseTransferService.editWarehouseTransfer(
+      tenantId,
+      warehouseTransferId,
+      editWarehouseTransferDTO
+    );
+  };
+
+  /**
+   * Deletes warehouse transfer transaction.
+   * @param   {number} tenantId
+   * @param   {number} warehouseTransferId
+   * @returns {Promise<void>}
+   */
+  public deleteWarehouseTransfer = (
+    tenantId: number,
+    warehouseTransferId: number
+  ): Promise<void> => {
+    return this.deleteWarehouseTransferService.deleteWarehouseTransfer(
+      tenantId,
+      warehouseTransferId
+    );
+  };
+
+  /**
+   * Retrieves warehouse transfer transaction.
+   * @param   {number} tenantId
+   * @param   {number} warehouseTransferId
+   * @returns {Promise<IWarehouseTransfer>}
+   */
+  public getWarehouseTransfer = (
+    tenantId: number,
+    warehouseTransferId: number
+  ): Promise<IWarehouseTransfer> => {
+    return this.getWarehouseTransferService.getWarehouseTransfer(
+      tenantId,
+      warehouseTransferId
+    );
+  };
+
+  /**
+   * Retrieves warehouses trans
+   * @param   {number} tenantId
+   * @param   {IGetWarehousesTransfersFilterDTO} filterDTO
+   * @returns {Promise<IWarehouseTransfer>}
+   */
+  public getWarehousesTransfers = (
+    tenantId: number,
+    filterDTO: IGetWarehousesTransfersFilterDTO
+  ) => {
+    return this.getWarehousesTransfersService.getWarehouseTransfers(
+      tenantId,
+      filterDTO
+    );
+  };
+
+  /**
+   * Marks the warehouse transfer order as transfered.
+   * @param   {number} tenantId
+   * @param   {number} warehouseTransferId
+   * @returns {Promise<IWarehouseTransfer>}
+   */
+  public transferredWarehouseTransfer = (
+    tenantId: number,
+    warehouseTransferId: number
+  ): Promise<IWarehouseTransfer> => {
+    return this.transferredWarehouseTransferService.transferredWarehouseTransfer(
+      tenantId,
+      warehouseTransferId
+    );
+  };
+
+  /**
+   * Marks the warehouse transfer order as initiated.
+   * @param   {number} tenantId
+   * @param   {number} warehouseTransferId
+   * @returns {Promise<IWarehouseTransfer>}
+   */
+  public initiateWarehouseTransfer = (
+    tenantId: number,
+    warehouseTransferId: number
+  ): Promise<IWarehouseTransfer> => {
+    return this.initiateWarehouseTransferService.initiateWarehouseTransfer(
+      tenantId,
+      warehouseTransferId
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferAutoIncrement.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferAutoIncrement.ts
new file mode 100644
index 000000000..85daa5e7d
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferAutoIncrement.ts
@@ -0,0 +1,31 @@
+import { Inject, Service } from 'typedi';
+import AutoIncrementOrdersService from '../../Sales/AutoIncrementOrdersService';
+
+@Service()
+export class WarehouseTransferAutoIncrement {
+  @Inject()
+  private autoIncrementOrdersService: AutoIncrementOrdersService;
+
+  /**
+   * Retrieve the next unique invoice number.
+   * @param  {number} tenantId - Tenant id.
+   * @return {string}
+   */
+  public getNextTransferNumber(tenantId: number): string {
+    return this.autoIncrementOrdersService.getNextTransactionNumber(
+      tenantId,
+      'warehouse_transfers'
+    );
+  }
+
+  /**
+   * Increment the invoice next number.
+   * @param {number} tenantId -
+   */
+  public incrementNextTransferNumber(tenantId: number) {
+    return this.autoIncrementOrdersService.incrementSettingsNextNumber(
+      tenantId,
+      'warehouse_transfers'
+    );
+  }
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferAutoIncrementSubscriber.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferAutoIncrementSubscriber.ts
new file mode 100644
index 000000000..1bbbd9536
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferAutoIncrementSubscriber.ts
@@ -0,0 +1,33 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { IWarehouseTransferCreated } from '@/interfaces';
+import { WarehouseTransferAutoIncrement } from './WarehouseTransferAutoIncrement';
+
+@Service()
+export class WarehouseTransferAutoIncrementSubscriber {
+  @Inject()
+  private warehouseTransferAutoIncrement: WarehouseTransferAutoIncrement;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.warehouseTransfer.onCreated,
+      this.incrementTransferAutoIncrementOnCreated
+    );
+    return bus;
+  };
+
+  /**
+   * Writes inventory transactions once warehouse transfer created.
+   * @param {IInventoryTransactionsCreatedPayload} -
+   */
+  private incrementTransferAutoIncrementOnCreated = async ({
+    tenantId,
+  }: IWarehouseTransferCreated) => {
+    await this.warehouseTransferAutoIncrement.incrementNextTransferNumber(
+      tenantId
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferInventoryTransactionsSubscriber.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferInventoryTransactionsSubscriber.ts
new file mode 100644
index 000000000..80f1ef29e
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferInventoryTransactionsSubscriber.ts
@@ -0,0 +1,155 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  IWarehouseTransferEditedPayload,
+  IWarehouseTransferDeletedPayload,
+  IWarehouseTransferCreated,
+  IWarehouseTransferInitiatedPayload,
+  IWarehouseTransferTransferredPayload,
+} from '@/interfaces';
+import { WarehouseTransferInventoryTransactions } from './WriteInventoryTransactions';
+
+@Service()
+export class WarehouseTransferInventoryTransactionsSubscriber {
+  @Inject()
+  private warehouseTransferInventoryTransactions: WarehouseTransferInventoryTransactions;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.warehouseTransfer.onCreated,
+      this.writeInventoryTransactionsOnWarehouseTransferCreated
+    );
+    bus.subscribe(
+      events.warehouseTransfer.onEdited,
+      this.rewriteInventoryTransactionsOnWarehouseTransferEdited
+    );
+    bus.subscribe(
+      events.warehouseTransfer.onDeleted,
+      this.revertInventoryTransactionsOnWarehouseTransferDeleted
+    );
+    bus.subscribe(
+      events.warehouseTransfer.onInitiated,
+      this.writeInventoryTransactionsOnTransferInitiated
+    );
+    bus.subscribe(
+      events.warehouseTransfer.onTransferred,
+      this.writeInventoryTransactionsOnTransferred
+    );
+    return bus;
+  };
+
+  /**
+   * Writes inventory transactions once warehouse transfer created.
+   * @param {IInventoryTransactionsCreatedPayload} -
+   */
+  private writeInventoryTransactionsOnWarehouseTransferCreated = async ({
+    warehouseTransfer,
+    tenantId,
+    trx,
+  }: IWarehouseTransferCreated) => {
+    // Can't continue if the warehouse transfer is not initiated yet.
+    if (!warehouseTransfer.isInitiated) return;
+
+    // Write all inventory transaction if warehouse transfer initiated and transferred.
+    if (warehouseTransfer.isInitiated && warehouseTransfer.isTransferred) {
+      await this.warehouseTransferInventoryTransactions.writeAllInventoryTransactions(
+        tenantId,
+        warehouseTransfer,
+        false,
+        trx
+      );
+      // Write initiate inventory transaction if warehouse transfer initited and transferred yet.
+    } else if (warehouseTransfer.isInitiated) {
+      await this.warehouseTransferInventoryTransactions.writeInitiateInventoryTransactions(
+        tenantId,
+        warehouseTransfer,
+        false,
+        trx
+      );
+    }
+  };
+
+  /**
+   * Rewrite inventory transactions once warehouse transfer edited.
+   * @param {IWarehouseTransferEditedPayload} -
+   */
+  private rewriteInventoryTransactionsOnWarehouseTransferEdited = async ({
+    tenantId,
+    warehouseTransfer,
+    trx,
+  }: IWarehouseTransferEditedPayload) => {
+    // Can't continue if the warehouse transfer is not initiated yet.
+    if (!warehouseTransfer.isInitiated) return;
+
+    // Write all inventory transaction if warehouse transfer initiated and transferred.
+    if (warehouseTransfer.isInitiated && warehouseTransfer.isTransferred) {
+      await this.warehouseTransferInventoryTransactions.writeAllInventoryTransactions(
+        tenantId,
+        warehouseTransfer,
+        true,
+        trx
+      );
+      // Write initiate inventory transaction if warehouse transfer initited and transferred yet.
+    } else if (warehouseTransfer.isInitiated) {
+      await this.warehouseTransferInventoryTransactions.writeInitiateInventoryTransactions(
+        tenantId,
+        warehouseTransfer,
+        true,
+        trx
+      );
+    }
+  };
+
+  /**
+   * Reverts inventory transactions once warehouse transfer deleted.
+   * @parma {IWarehouseTransferDeletedPayload} -
+   */
+  private revertInventoryTransactionsOnWarehouseTransferDeleted = async ({
+    tenantId,
+    oldWarehouseTransfer,
+    trx,
+  }: IWarehouseTransferDeletedPayload) => {
+    await this.warehouseTransferInventoryTransactions.revertInventoryTransactions(
+      tenantId,
+      oldWarehouseTransfer.id,
+      trx
+    );
+  };
+
+  /**
+   * Write inventory transactions of warehouse transfer once the transfer initiated.
+   * @param {IWarehouseTransferInitiatedPayload}
+   */
+  private writeInventoryTransactionsOnTransferInitiated = async ({
+    trx,
+    warehouseTransfer,
+    tenantId,
+  }: IWarehouseTransferInitiatedPayload) => {
+    await this.warehouseTransferInventoryTransactions.writeInitiateInventoryTransactions(
+      tenantId,
+      warehouseTransfer,
+      false,
+      trx
+    );
+  };
+
+  /**
+   * Write inventory transactions of warehouse transfer once the transfer completed.
+   * @param {IWarehouseTransferTransferredPayload}
+   */
+  private writeInventoryTransactionsOnTransferred = async ({
+    trx,
+    warehouseTransfer,
+    tenantId,
+  }: IWarehouseTransferTransferredPayload) => {
+    await this.warehouseTransferInventoryTransactions.writeTransferredInventoryTransactions(
+      tenantId,
+      warehouseTransfer,
+      false,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferItemTransformer.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferItemTransformer.ts
new file mode 100644
index 000000000..970cd9f64
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferItemTransformer.ts
@@ -0,0 +1,38 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+
+export class WarehouseTransferItemTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return ['formattedQuantity', 'formattedCost', 'formattedTotal'];
+  };
+
+  /**
+   *
+   * @param entry
+   * @returns
+   */
+  public formattedTotal = (entry) => {
+    return this.formatMoney(entry.total);
+  };
+
+  /**
+   *
+   * @param entry
+   * @returns
+   */
+  public formattedQuantity = (entry) => {
+    return this.formatNumber(entry.quantity);
+  };
+
+  /**
+   *
+   * @param entry
+   * @returns
+   */
+  public formattedCost = (entry) => {
+    return this.formatMoney(entry.cost);
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferTransfomer.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferTransfomer.ts
new file mode 100644
index 000000000..605fe457e
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/WarehouseTransferTransfomer.ts
@@ -0,0 +1,28 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { WarehouseTransferItemTransformer } from './WarehouseTransferItemTransformer';
+
+export class WarehouseTransferTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return ['formattedDate', 'entries'];
+  };
+
+  /**
+   *
+   * @param transfer
+   * @returns
+   */
+  protected formattedDate = (transfer) => {
+    return this.formatDate(transfer.date);
+  };
+
+  /**
+   *
+   */
+  protected entries = (transfer) => {
+    return this.item(transfer.entries, new WarehouseTransferItemTransformer());
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/WriteInventoryTransactions.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/WriteInventoryTransactions.ts
new file mode 100644
index 000000000..5d8c1676f
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/WriteInventoryTransactions.ts
@@ -0,0 +1,176 @@
+import { Knex } from 'knex';
+import {
+  IWarehouseTransfer,
+  IInventoryTransaction,
+  IWarehouseTransferEntry,
+} from '@/interfaces';
+import { Inject, Service } from 'typedi';
+import InventoryService from '@/services/Inventory/Inventory';
+
+@Service()
+export class WarehouseTransferInventoryTransactions {
+  @Inject()
+  private inventory: InventoryService;
+
+  /**
+   * Writes all (initiate and transfer) inventory transactions.
+   * @param   {number} tenantId
+   * @param   {IWarehouseTransfer} warehouseTransfer
+   * @param   {Boolean} override
+   * @param   {Knex.Transaction} trx - Knex transcation.
+   * @returns {Promise<void>}
+   */
+  public writeAllInventoryTransactions = async (
+    tenantId: number,
+    warehouseTransfer: IWarehouseTransfer,
+    override?: boolean,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const inventoryTransactions =
+      this.getWarehouseTransferInventoryTransactions(warehouseTransfer);
+
+    await this.inventory.recordInventoryTransactions(
+      tenantId,
+      inventoryTransactions,
+      override,
+      trx
+    );
+  };
+
+  /**
+   * Writes initiate inventory transactions of warehouse transfer transaction.
+   * @param   {number} tenantId
+   * @param   {IWarehouseTransfer} warehouseTransfer
+   * @param   {boolean} override
+   * @param   {Knex.Transaction} trx - Knex transaction.
+   * @returns {Promise<void>}
+   */
+  public writeInitiateInventoryTransactions = async (
+    tenantId: number,
+    warehouseTransfer: IWarehouseTransfer,
+    override?: boolean,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const inventoryTransactions =
+      this.getWarehouseFromTransferInventoryTransactions(warehouseTransfer);
+
+    await this.inventory.recordInventoryTransactions(
+      tenantId,
+      inventoryTransactions,
+      override,
+      trx
+    );
+  };
+
+  /**
+   * Writes transferred inventory transaction of warehouse transfer transaction.
+   * @param   {number} tenantId
+   * @param   {IWarehouseTransfer} warehouseTransfer
+   * @param   {boolean} override
+   * @param   {Knex.Transaction} trx - Knex transaction.
+   * @returns {Promise<void>}
+   */
+  public writeTransferredInventoryTransactions = async (
+    tenantId: number,
+    warehouseTransfer: IWarehouseTransfer,
+    override?: boolean,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    const inventoryTransactions =
+      this.getWarehouseToTransferInventoryTransactions(warehouseTransfer);
+
+    await this.inventory.recordInventoryTransactions(
+      tenantId,
+      inventoryTransactions,
+      override,
+      trx
+    );
+  };
+
+  /**
+   * Reverts warehouse transfer inventory transactions.
+   * @param   {number} tenatnId
+   * @param   {number} warehouseTransferId
+   * @param   {Knex.Transaction} trx
+   * @returns {Promise<void>}
+   */
+  public revertInventoryTransactions = async (
+    tenantId: number,
+    warehouseTransferId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> => {
+    await this.inventory.deleteInventoryTransactions(
+      tenantId,
+      warehouseTransferId,
+      'WarehouseTransfer',
+      trx
+    );
+  };
+
+  /**
+   * Retrieves the inventory transactions of the given warehouse transfer.
+   * @param   {IWarehouseTransfer} warehouseTransfer
+   * @returns {IInventoryTransaction[]}
+   */
+  private getWarehouseFromTransferInventoryTransactions = (
+    warehouseTransfer: IWarehouseTransfer
+  ): IInventoryTransaction[] => {
+    const commonEntry = {
+      date: warehouseTransfer.date,
+      transactionType: 'WarehouseTransfer',
+      transactionId: warehouseTransfer.id,
+    };
+    return warehouseTransfer.entries.map((entry: IWarehouseTransferEntry) => ({
+      ...commonEntry,
+      entryId: entry.id,
+      itemId: entry.itemId,
+      quantity: entry.quantity,
+      rate: entry.cost,
+      direction: 'OUT',
+      warehouseId: warehouseTransfer.fromWarehouseId,
+    }));
+  };
+
+  /**
+   *
+   * @param   {IWarehouseTransfer} warehouseTransfer
+   * @returns {IInventoryTransaction[]}
+   */
+  private getWarehouseToTransferInventoryTransactions = (
+    warehouseTransfer: IWarehouseTransfer
+  ): IInventoryTransaction[] => {
+    const commonEntry = {
+      date: warehouseTransfer.date,
+      transactionType: 'WarehouseTransfer',
+      transactionId: warehouseTransfer.id,
+    };
+    return warehouseTransfer.entries.map((entry: IWarehouseTransferEntry) => ({
+      ...commonEntry,
+      entryId: entry.id,
+      itemId: entry.itemId,
+      quantity: entry.quantity,
+      rate: entry.cost,
+      direction: 'IN',
+      warehouseId: warehouseTransfer.toWarehouseId,
+    }));
+  };
+
+  /**
+   *
+   * @param   {IWarehouseTransfer} warehouseTransfer
+   * @returns {IInventoryTransaction[]}
+   */
+  private getWarehouseTransferInventoryTransactions = (
+    warehouseTransfer: IWarehouseTransfer
+  ): IInventoryTransaction[] => {
+    // Retrieve the to inventory transactions of warehouse transfer.
+    const toTransactions =
+      this.getWarehouseToTransferInventoryTransactions(warehouseTransfer);
+
+    // Retrieve the from inventory transactions of warehouse transfer.
+    const fromTransactions =
+      this.getWarehouseFromTransferInventoryTransactions(warehouseTransfer);
+
+    return [...toTransactions, ...fromTransactions];
+  };
+}
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfers/constants.ts b/packages/server/src/services/Warehouses/WarehousesTransfers/constants.ts
new file mode 100644
index 000000000..b147c1f08
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfers/constants.ts
@@ -0,0 +1,57 @@
+export const ERRORS = {
+  WAREHOUSE_TRANSFER_NOT_FOUND: 'WAREHOUSE_TRANSFER_NOT_FOUND',
+  WAREHOUSES_TRANSFER_SHOULD_NOT_BE_SAME:
+    'WAREHOUSES_TRANSFER_SHOULD_NOT_BE_SAME',
+
+  FROM_WAREHOUSE_NOT_FOUND: 'FROM_WAREHOUSE_NOT_FOUND',
+  TO_WAREHOUSE_NOT_FOUND: 'TO_WAREHOUSE_NOT_FOUND',
+  WAREHOUSE_TRANSFER_ITEMS_SHOULD_BE_INVENTORY:
+    'WAREHOUSE_TRANSFER_ITEMS_SHOULD_BE_INVENTORY',
+
+  WAREHOUSE_TRANSFER_ALREAD_TRANSFERRED:
+    'WAREHOUSE_TRANSFER_ALREADY_TRANSFERRED',
+
+  WAREHOUSE_TRANSFER_ALREADY_INITIATED: 'WAREHOUSE_TRANSFER_ALREADY_INITIATED',
+  WAREHOUSE_TRANSFER_NOT_INITIATED: 'WAREHOUSE_TRANSFER_NOT_INITIATED',
+};
+
+// Warehouse transfers default views.
+export const DEFAULT_VIEWS = [
+  {
+    name: 'warehouse_transfer.view.draft.name',
+    slug: 'draft',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'status', comparator: 'equals', value: 'draft' },
+    ],
+    columns: [],
+  },
+  {
+    name: 'warehouse_transfer.view.in_transit.name',
+    slug: 'in-transit',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'in-transit',
+      },
+    ],
+    columns: [],
+  },
+  {
+    name: 'warehouse_transfer.view.transferred.name',
+    slug: 'transferred',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        index: 1,
+        fieldKey: 'status',
+        comparator: 'equals',
+        value: 'tansferred',
+      },
+    ],
+    columns: [],
+  },
+];
diff --git a/packages/server/src/services/Warehouses/WarehousesTransfersService.ts b/packages/server/src/services/Warehouses/WarehousesTransfersService.ts
new file mode 100644
index 000000000..d6d04f2ff
--- /dev/null
+++ b/packages/server/src/services/Warehouses/WarehousesTransfersService.ts
@@ -0,0 +1,23 @@
+import { Service, Inject } from 'typedi';
+
+
+export class WarehousesTransfersService {
+  createWarehouseTranser = (
+    tenantId: number,
+    createWarehouseTransfer: ICreateWarehouseTransferDTO
+  ) => {};
+
+  editWarehouseTranser = (
+    tenantId: number,
+    editWarehouseTransfer: IEditWarehouseTransferDTO
+  ) => {};
+
+  deleteWarehouseTranser = (
+    tenantId: number,
+    warehouseTransferId: number
+  ) => {};
+
+  getWarehouseTransfer = (tenantId: number, warehouseTransferId: number) => {};
+
+  getWarehouseTransfers = (tenantId: number) => {};
+}
diff --git a/packages/server/src/services/Warehouses/contants.ts b/packages/server/src/services/Warehouses/contants.ts
new file mode 100644
index 000000000..e41d9b3ff
--- /dev/null
+++ b/packages/server/src/services/Warehouses/contants.ts
@@ -0,0 +1,7 @@
+export const ERRORS = {
+  WAREHOUSE_NOT_FOUND: 'WAREHOUSE_NOT_FOUND',
+  MUTLI_WAREHOUSES_ALREADY_ACTIVATED: 'MUTLI_WAREHOUSES_ALREADY_ACTIVATED',
+  COULD_NOT_DELETE_ONLY_WAERHOUSE: 'COULD_NOT_DELETE_ONLY_WAERHOUSE',
+  WAREHOUSE_CODE_NOT_UNIQUE: 'WAREHOUSE_CODE_NOT_UNIQUE',
+  WAREHOUSE_HAS_ASSOCIATED_TRANSACTIONS: 'WAREHOUSE_HAS_ASSOCIATED_TRANSACTIONS'
+};
\ No newline at end of file
diff --git a/packages/server/src/subscribers/Authentication/ResetLoginThrottle.ts b/packages/server/src/subscribers/Authentication/ResetLoginThrottle.ts
new file mode 100644
index 000000000..781241fa1
--- /dev/null
+++ b/packages/server/src/subscribers/Authentication/ResetLoginThrottle.ts
@@ -0,0 +1,27 @@
+import { Container, Service } from 'typedi';
+import events from '@/subscribers/events';
+
+@Service()
+export default class ResetLoginThrottleSubscriber {
+  /**
+   * Attaches events with handlers.
+   * @param bus 
+   */
+  public attach(bus) {
+    bus.subscribe(events.auth.login, this.resetLoginThrottleOnceSuccessLogin);
+  }
+
+  /**
+   * Resets the login throttle once the login success.
+   */
+  private async resetLoginThrottleOnceSuccessLogin(payload) {
+    const { emailOrPhone, password, user } = payload;
+
+    const loginThrottler = Container.get('rateLimiter.login');
+
+    // Reset the login throttle by the given email and phone number.
+    await loginThrottler.reset(user.email);
+    await loginThrottler.reset(user.phoneNumber);
+    await loginThrottler.reset(emailOrPhone);
+  }
+}
diff --git a/packages/server/src/subscribers/Authentication/SendResetPasswordMail.ts b/packages/server/src/subscribers/Authentication/SendResetPasswordMail.ts
new file mode 100644
index 000000000..4dc7c09b3
--- /dev/null
+++ b/packages/server/src/subscribers/Authentication/SendResetPasswordMail.ts
@@ -0,0 +1,25 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+
+@Service()
+export default class AuthenticationSubscriber {
+  @Inject('agenda')
+  agenda: any;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(events.auth.sendResetPassword, this.sendPasswordMail);
+  }
+
+  /**
+   * Sends reset password mail once the reset password success.
+   */
+  public sendPasswordMail = (payload) => {
+    const { user, token } = payload;
+
+    // Send reset password mail.
+    this.agenda.now('reset-password-mail', { user, token });
+  };
+}
diff --git a/packages/server/src/subscribers/Authentication/SendWelcomeMail.ts b/packages/server/src/subscribers/Authentication/SendWelcomeMail.ts
new file mode 100644
index 000000000..ea9bf9de3
--- /dev/null
+++ b/packages/server/src/subscribers/Authentication/SendWelcomeMail.ts
@@ -0,0 +1,28 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+
+@Service()
+export default class AuthSendWelcomeMailSubscriber {
+  @Inject('agenda')
+  agenda: any;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(events.auth.register, this.sendWelcomeEmailOnceUserRegister);
+  }
+
+  /**
+   * Sends welcome email once the user register.
+   */
+  private sendWelcomeEmailOnceUserRegister = async (payload) => {
+    const { registerDTO, tenant, user } = payload;
+
+    // Send welcome mail to the user.
+    await this.agenda.now('welcome-email', {
+      organizationId: tenant.organizationId,
+      user,
+    });
+  };
+}
diff --git a/packages/server/src/subscribers/Bills/WriteInventoryTransactions.ts b/packages/server/src/subscribers/Bills/WriteInventoryTransactions.ts
new file mode 100644
index 000000000..300d38e0f
--- /dev/null
+++ b/packages/server/src/subscribers/Bills/WriteInventoryTransactions.ts
@@ -0,0 +1,79 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import BillsService from '@/services/Purchases/Bills';
+import {
+  IBillCreatedPayload,
+  IBillEditedPayload,
+  IBIllEventDeletedPayload,
+} from '@/interfaces';
+
+@Service()
+export default class BillWriteInventoryTransactionsSubscriber {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  billsService: BillsService;
+
+  /**
+   * Attaches events with handles.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.bill.onCreated,
+      this.handleWritingInventoryTransactions
+    );
+    bus.subscribe(
+      events.bill.onEdited,
+      this.handleOverwritingInventoryTransactions
+    );
+    bus.subscribe(
+      events.bill.onDeleted,
+      this.handleRevertInventoryTransactions
+    );
+  }
+
+  /**
+   * Handles writing the inventory transactions once bill created.
+   */
+  private handleWritingInventoryTransactions = async ({
+    tenantId,
+    billId,
+    trx,
+  }: IBillCreatedPayload) => {
+    await this.billsService.recordInventoryTransactions(
+      tenantId,
+      billId,
+      false,
+      trx
+    );
+  };
+
+  /**
+   * Handles the overwriting the inventory transactions once bill edited.
+   */
+  private handleOverwritingInventoryTransactions = async ({
+    tenantId,
+    billId,
+    trx,
+  }: IBillEditedPayload) => {
+    await this.billsService.recordInventoryTransactions(
+      tenantId,
+      billId,
+      true,
+      trx
+    );
+  };
+
+  /**
+   * Handles the reverting the inventory transactions once the bill deleted.
+   */
+  private handleRevertInventoryTransactions = async ({
+    tenantId,
+    billId,
+    trx,
+  }: IBIllEventDeletedPayload) => {
+    await this.billsService.revertInventoryTransactions(tenantId, billId, trx);
+  };
+}
diff --git a/packages/server/src/subscribers/Bills/WriteJournalEntries.ts b/packages/server/src/subscribers/Bills/WriteJournalEntries.ts
new file mode 100644
index 000000000..bb9589f54
--- /dev/null
+++ b/packages/server/src/subscribers/Bills/WriteJournalEntries.ts
@@ -0,0 +1,79 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import BillsService from '@/services/Purchases/Bills';
+import {
+  IBillCreatedPayload,
+  IBillEditedPayload,
+  IBIllEventDeletedPayload,
+} from '@/interfaces';
+
+@Service()
+export default class BillWriteGLEntriesSubscriber {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  billsService: BillsService;
+
+  /**
+   * Attachs events with handles.
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.bill.onCreated,
+      this.handlerWriteJournalEntriesOnCreate
+    );
+    bus.subscribe(
+      events.bill.onEdited,
+      this.handleOverwriteJournalEntriesOnEdit
+    );
+    bus.subscribe(events.bill.onDeleted, this.handlerDeleteJournalEntries);
+  }
+
+  /**
+   * Handles writing journal entries once bill created.
+   * @param {IBillCreatedPayload} payload -
+   */
+  private handlerWriteJournalEntriesOnCreate = async ({
+    tenantId,
+    billId,
+    trx,
+  }: IBillCreatedPayload) => {
+    await this.billsService.recordJournalTransactions(
+      tenantId,
+      billId,
+      false,
+      trx
+    );
+  };
+
+  /**
+   * Handles the overwriting journal entries once bill edited.
+   * @param {IBillEditedPayload} payload -
+   */
+  private handleOverwriteJournalEntriesOnEdit = async ({
+    tenantId,
+    billId,
+    trx,
+  }: IBillEditedPayload) => {
+    await this.billsService.recordJournalTransactions(
+      tenantId,
+      billId,
+      true,
+      trx
+    );
+  };
+
+  /**
+   * Handles revert journal entries on bill deleted.
+   * @param {IBIllEventDeletedPayload} payload -
+   */
+  private handlerDeleteJournalEntries = async ({
+    tenantId,
+    billId,
+    trx,
+  }: IBIllEventDeletedPayload) => {
+    await this.billsService.revertJournalEntries(tenantId, billId, trx);
+  };
+}
diff --git a/packages/server/src/subscribers/Bills/index.ts b/packages/server/src/subscribers/Bills/index.ts
new file mode 100644
index 000000000..720561be2
--- /dev/null
+++ b/packages/server/src/subscribers/Bills/index.ts
@@ -0,0 +1,22 @@
+import { Container } from 'typedi';
+import { EventSubscriber, On } from 'event-dispatch';
+
+import events from '@/subscribers/events';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import BillsService from '@/services/Purchases/Bills';
+
+@EventSubscriber()
+export default class BillSubscriber {
+  tenancy: TenancyService;
+  billsService: BillsService;
+  logger: any;
+
+  /**
+   * Constructor method.
+   */
+  constructor() {
+    this.tenancy = Container.get(TenancyService);
+    this.billsService = Container.get(BillsService);
+    this.logger = Container.get('logger');
+  }
+}
diff --git a/packages/server/src/subscribers/Cashflow/OwnerContributionCashflow.ts b/packages/server/src/subscribers/Cashflow/OwnerContributionCashflow.ts
new file mode 100644
index 000000000..6a2fb8379
--- /dev/null
+++ b/packages/server/src/subscribers/Cashflow/OwnerContributionCashflow.ts
@@ -0,0 +1,37 @@
+import { Container } from 'typedi';
+import { EventSubscriber, On } from 'event-dispatch';
+import { map, head } from 'lodash';
+import events from '@/subscribers/events';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import SaleInvoicesCost from '@/services/Sales/SalesInvoicesCost';
+import InventoryItemsQuantitySync from '@/services/Inventory/InventoryItemsQuantitySync';
+import InventoryService from '@/services/Inventory/Inventory';
+
+@EventSubscriber()
+export class OwnerContributionCashflowSubscriber {
+  depends: number = 0;
+  startingDate: Date;
+  saleInvoicesCost: SaleInvoicesCost;
+  tenancy: TenancyService;
+  itemsQuantitySync: InventoryItemsQuantitySync;
+  inventoryService: InventoryService;
+  agenda: any;
+
+  /**
+   * Constructor method.
+   */
+  constructor() {
+    this.tenancy = Container.get(TenancyService);
+  }
+
+  /**
+   * Marks items cost compute running state.
+   */
+  @On(events.cashflow.onOwnerContributionCreate)
+  async writeOwnerContributionJournalEntries({
+    
+  }) {
+
+  }
+
+}
diff --git a/packages/server/src/subscribers/Inventory/Inventory.ts b/packages/server/src/subscribers/Inventory/Inventory.ts
new file mode 100644
index 000000000..117cffd8f
--- /dev/null
+++ b/packages/server/src/subscribers/Inventory/Inventory.ts
@@ -0,0 +1,197 @@
+import { Inject, Service } from 'typedi';
+import { map, head } from 'lodash';
+
+import events from '@/subscribers/events';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import SaleInvoicesCost from '@/services/Sales/SalesInvoicesCost';
+import InventoryItemsQuantitySync from '@/services/Inventory/InventoryItemsQuantitySync';
+import InventoryService from '@/services/Inventory/Inventory';
+import {
+  IComputeItemCostJobCompletedPayload,
+  IInventoryTransactionsCreatedPayload,
+  IInventoryTransactionsDeletedPayload,
+} from '@/interfaces';
+import { runAfterTransaction } from '@/services/UnitOfWork/TransactionsHooks';
+
+@Service()
+export default class InventorySubscriber {
+  @Inject()
+  saleInvoicesCost: SaleInvoicesCost;
+
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  itemsQuantitySync: InventoryItemsQuantitySync;
+
+  @Inject()
+  inventoryService: InventoryService;
+
+  @Inject('agenda')
+  agenda: any;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.inventory.onInventoryTransactionsCreated,
+      this.handleScheduleItemsCostOnInventoryTransactionsCreated
+    );
+    bus.subscribe(
+      events.inventory.onInventoryTransactionsCreated,
+      this.syncItemsQuantityOnceInventoryTransactionsCreated
+    );
+    bus.subscribe(
+      events.inventory.onComputeItemCostJobScheduled,
+      this.markGlobalSettingsComputeItems
+    );
+    bus.subscribe(
+      events.inventory.onInventoryCostEntriesWritten,
+      this.markGlobalSettingsComputeItemsCompeted
+    );
+    bus.subscribe(
+      events.inventory.onComputeItemCostJobCompleted,
+      this.onComputeItemCostJobFinished
+    );
+    bus.subscribe(
+      events.inventory.onInventoryTransactionsDeleted,
+      this.handleScheduleItemsCostOnInventoryTransactionsDeleted
+    );
+    bus.subscribe(
+      events.inventory.onInventoryTransactionsDeleted,
+      this.syncItemsQuantityOnceInventoryTransactionsDeleted
+    );
+  }
+
+  /**
+   * Sync inventory items quantity once inventory transactions created.
+   * @param {IInventoryTransactionsCreatedPayload} payload -
+   */
+  private syncItemsQuantityOnceInventoryTransactionsCreated = async ({
+    tenantId,
+    inventoryTransactions,
+    trx,
+  }: IInventoryTransactionsCreatedPayload) => {
+    const itemsQuantityChanges = this.itemsQuantitySync.getItemsQuantityChanges(
+      inventoryTransactions
+    );
+
+    await this.itemsQuantitySync.changeItemsQuantity(
+      tenantId,
+      itemsQuantityChanges,
+      trx
+    );
+  };
+
+  /**
+   * Handles schedule compute inventory items cost once inventory transactions created.
+   * @param {IInventoryTransactionsCreatedPayload} payload -
+   */
+  private handleScheduleItemsCostOnInventoryTransactionsCreated = async ({
+    tenantId,
+    inventoryTransactions,
+    trx
+  }: IInventoryTransactionsCreatedPayload) => {
+    const inventoryItemsIds = map(inventoryTransactions, 'itemId');
+
+    runAfterTransaction(trx, async () => {
+      try {
+        await this.saleInvoicesCost.computeItemsCostByInventoryTransactions(
+          tenantId,
+          inventoryTransactions
+        );
+      } catch (error) {
+        console.error(error);
+      }
+    });
+  };
+
+  /**
+   * Marks items cost compute running state.
+   */
+  private markGlobalSettingsComputeItems = async ({ tenantId }) => {
+    await this.inventoryService.markItemsCostComputeRunning(tenantId, true);
+  };
+
+  /**
+   * Marks items cost compute as completed.
+   */
+  private markGlobalSettingsComputeItemsCompeted = async ({ tenantId }) => {
+    await this.inventoryService.markItemsCostComputeRunning(tenantId, false);
+  };
+
+  /**
+   * Handle run writing the journal entries once the compute items jobs completed.
+   */
+  private onComputeItemCostJobFinished = async ({
+    itemId,
+    tenantId,
+    startingDate,
+  }: IComputeItemCostJobCompletedPayload) => {
+    const dependsComputeJobs = await this.agenda.jobs({
+      name: 'compute-item-cost',
+      nextRunAt: { $ne: null },
+      'data.tenantId': tenantId,
+    });
+    // There is no scheduled compute jobs waiting.
+    if (dependsComputeJobs.length === 0) {
+      await this.saleInvoicesCost.scheduleWriteJournalEntries(
+        tenantId,
+        startingDate
+      );
+    }
+  };
+
+  /**
+   * Sync inventory items quantity once inventory transactions deleted.
+   */
+  private syncItemsQuantityOnceInventoryTransactionsDeleted = async ({
+    tenantId,
+    oldInventoryTransactions,
+    trx,
+  }: IInventoryTransactionsDeletedPayload) => {
+    const itemsQuantityChanges =
+      this.itemsQuantitySync.getReverseItemsQuantityChanges(
+        oldInventoryTransactions
+      );
+    await this.itemsQuantitySync.changeItemsQuantity(
+      tenantId,
+      itemsQuantityChanges,
+      trx
+    );
+  };
+
+  /**
+   * Schedules compute items cost once the inventory transactions deleted.
+   */
+  private handleScheduleItemsCostOnInventoryTransactionsDeleted = async ({
+    tenantId,
+    transactionType,
+    transactionId,
+    oldInventoryTransactions,
+    trx,
+  }: IInventoryTransactionsDeletedPayload) => {
+    // Ignore compute item cost with theses transaction types.
+    const ignoreWithTransactionTypes = ['OpeningItem'];
+
+    if (ignoreWithTransactionTypes.indexOf(transactionType) !== -1) {
+      return;
+    }
+    const inventoryItemsIds = map(oldInventoryTransactions, 'itemId');
+    const startingDates = map(oldInventoryTransactions, 'date');
+    const startingDate: Date = head(startingDates);
+
+    runAfterTransaction(trx, async () => {
+      try {
+        await this.saleInvoicesCost.scheduleComputeCostByItemsIds(
+          tenantId,
+          inventoryItemsIds,
+          startingDate
+        );
+      } catch (error) {
+        console.error(error);
+      }
+    });
+  };
+}
diff --git a/packages/server/src/subscribers/Inventory/InventoryAdjustment.ts b/packages/server/src/subscribers/Inventory/InventoryAdjustment.ts
new file mode 100644
index 000000000..7db1a0069
--- /dev/null
+++ b/packages/server/src/subscribers/Inventory/InventoryAdjustment.ts
@@ -0,0 +1,134 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import InventoryAdjustmentService from '@/services/Inventory/InventoryAdjustmentService';
+import InventoryAdjustmentsGL from '@/services/Inventory/InventoryAdjustmentGL';
+import {
+  IInventoryAdjustmentEventCreatedPayload,
+  IInventoryAdjustmentEventDeletedPayload,
+  IInventoryAdjustmentEventPublishedPayload,
+} from '@/interfaces';
+
+@Service()
+export default class InventoryAdjustmentsSubscriber {
+  @Inject()
+  private inventoryAdjustment: InventoryAdjustmentService;
+
+  @Inject()
+  private inventoryAdjustmentGL: InventoryAdjustmentsGL;
+
+  /**
+   * Attaches events with handles.
+   * @param bus
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.inventoryAdjustment.onQuickCreated,
+      this.handleWriteInventoryTransactionsOncePublished
+    );
+    bus.subscribe(
+      events.inventoryAdjustment.onQuickCreated,
+      this.handleGLEntriesOnceIncrementAdjustmentCreated
+    );
+    bus.subscribe(
+      events.inventoryAdjustment.onPublished,
+      this.handleGLEntriesOnceIncrementAdjustmentCreated
+    );
+    bus.subscribe(
+      events.inventoryAdjustment.onPublished,
+      this.handleWriteInventoryTransactionsOncePublished
+    );
+    bus.subscribe(
+      events.inventoryAdjustment.onDeleted,
+      this.handleRevertInventoryTransactionsOnceDeleted
+    );
+    bus.subscribe(
+      events.inventoryAdjustment.onDeleted,
+      this.revertAdjustmentGLEntriesOnceDeleted
+    );
+  }
+
+  /**
+   * Handles writing increment inventory adjustment GL entries.
+   */
+  private handleGLEntriesOnceIncrementAdjustmentCreated = async ({
+    tenantId,
+    inventoryAdjustmentId,
+    inventoryAdjustment,
+    trx,
+  }: IInventoryAdjustmentEventCreatedPayload) => {
+    // Can't continue if the inventory adjustment is not published.
+    if (!inventoryAdjustment.isPublished) {
+      return;
+    }
+    // Can't continue if the inventory adjustment direction is not `IN`.
+    if (inventoryAdjustment.type !== 'increment') {
+      return;
+    }
+    await this.inventoryAdjustmentGL.writeAdjustmentGLEntries(
+      tenantId,
+      inventoryAdjustmentId,
+      trx
+    );
+  };
+
+  /**
+   * Handles writing inventory transactions once the quick adjustment created.
+   * @param {IInventoryAdjustmentEventPublishedPayload} payload
+   * @param {IInventoryAdjustmentEventCreatedPayload} payload -
+   */
+  private handleWriteInventoryTransactionsOncePublished = async ({
+    tenantId,
+    inventoryAdjustment,
+    trx,
+  }:
+    | IInventoryAdjustmentEventPublishedPayload
+    | IInventoryAdjustmentEventCreatedPayload) => {
+    await this.inventoryAdjustment.writeInventoryTransactions(
+      tenantId,
+      inventoryAdjustment,
+      false,
+      trx
+    );
+  };
+
+  /**
+   * Handles reverting invetory transactions once the inventory adjustment deleted.
+   * @param {IInventoryAdjustmentEventDeletedPayload} payload -
+   */
+  private handleRevertInventoryTransactionsOnceDeleted = async ({
+    tenantId,
+    inventoryAdjustmentId,
+    oldInventoryAdjustment,
+    trx,
+  }: IInventoryAdjustmentEventDeletedPayload) => {
+    // Can't continue if the inventory adjustment is not published.
+    if (!oldInventoryAdjustment.isPublished) {
+      return;
+    }
+    // Reverts the inventory transactions of adjustment transaction.
+    await this.inventoryAdjustment.revertInventoryTransactions(
+      tenantId,
+      inventoryAdjustmentId,
+      trx
+    );
+  };
+
+  /**
+   * Reverts the inventory adjustment GL entries once the transaction deleted.
+   * @param {IInventoryAdjustmentEventDeletedPayload} payload -
+   */
+  private revertAdjustmentGLEntriesOnceDeleted = async ({
+    tenantId,
+    inventoryAdjustmentId,
+    oldInventoryAdjustment,
+  }: IInventoryAdjustmentEventDeletedPayload) => {
+    // Can't continue if the inventory adjustment is not published.
+    if (!oldInventoryAdjustment.isPublished) {
+      return;
+    }
+    await this.inventoryAdjustmentGL.revertAdjustmentGLEntries(
+      tenantId,
+      inventoryAdjustmentId
+    );
+  };
+}
diff --git a/packages/server/src/subscribers/Items/ItemSubscriber.ts b/packages/server/src/subscribers/Items/ItemSubscriber.ts
new file mode 100644
index 000000000..728da6888
--- /dev/null
+++ b/packages/server/src/subscribers/Items/ItemSubscriber.ts
@@ -0,0 +1,18 @@
+import events from '@/subscribers/events';
+import { EventSubscriber } from '@/lib/EventPublisher/EventPublisher';
+import { Service } from 'typedi';
+
+@Service()
+export default class ItemSubscriber extends EventSubscriber {
+  /**
+   * Attaches the events with handles.
+   * @param bus 
+   */
+  attach(bus) {
+    bus.subscribe(events.item.onCreated, this.handleItemCreated);
+  }
+
+  handleItemCreated() {
+   
+  }
+}
diff --git a/packages/server/src/subscribers/LandedCost/index.ts b/packages/server/src/subscribers/LandedCost/index.ts
new file mode 100644
index 000000000..b5642036e
--- /dev/null
+++ b/packages/server/src/subscribers/LandedCost/index.ts
@@ -0,0 +1,37 @@
+import { Container } from 'typedi';
+import { On, EventSubscriber } from 'event-dispatch';
+import events from '@/subscribers/events';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import BillsService from '@/services/Purchases/Bills';
+
+@EventSubscriber()
+export default class BillLandedCostSubscriber {
+  logger: any;
+  tenancy: TenancyService;
+  billsService: BillsService;
+
+  /**
+   * Constructor method.
+   */
+  constructor() {
+    this.logger = Container.get('logger');
+    this.tenancy = Container.get(TenancyService);
+    this.billsService = Container.get(BillsService);
+  }
+
+  /**
+   * Marks the rewrite bill journal entries once the landed cost transaction 
+   * be deleted or created.
+   */
+  @On(events.billLandedCost.onCreated)
+  @On(events.billLandedCost.onDeleted)
+  public async handleRewriteBillJournalEntries({
+    tenantId,
+    billId,
+    bilLandedCostId,
+  }) {
+    // Overwrite the journal entries for the given bill transaction.
+    this.logger.info('[bill] overwriting bill journal entries.', { tenantId });
+    await this.billsService.recordJournalTransactions(tenantId, billId, true);
+  }
+}
diff --git a/packages/server/src/subscribers/Organization/BuildSmsNotification.ts b/packages/server/src/subscribers/Organization/BuildSmsNotification.ts
new file mode 100644
index 000000000..d516dd393
--- /dev/null
+++ b/packages/server/src/subscribers/Organization/BuildSmsNotification.ts
@@ -0,0 +1,26 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { IOrganizationBuildEventPayload } from '@/interfaces';
+
+@Service()
+export default class OrgBuildSmsNotificationSubscriber {
+  @Inject('agenda')
+  agenda: any;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(events.organization.build, this.sendWelcomeSmsNotification);
+  }
+
+  /**
+   * Sends welcome SMS once the organization build completed.
+   */
+  public sendWelcomeSmsNotification = async ({
+    tenantId,
+    systemUser,
+  }: IOrganizationBuildEventPayload) => {
+    // await this.agenda.now('welcome-sms', { tenant, user });
+  };
+}
diff --git a/packages/server/src/subscribers/Organization/SyncTenantAdminUser.ts b/packages/server/src/subscribers/Organization/SyncTenantAdminUser.ts
new file mode 100644
index 000000000..d09a621da
--- /dev/null
+++ b/packages/server/src/subscribers/Organization/SyncTenantAdminUser.ts
@@ -0,0 +1,27 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import OrganizationService from '@/services/Organization/OrganizationService';
+import { IOrganizationBuildEventPayload } from '@/interfaces';
+
+@Service()
+export default class OrgSyncTenantAdminUserSubscriber {
+  @Inject()
+  organizationService: OrganizationService;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(events.organization.build, this.assignSystemUserAsAdminRole);
+  }
+
+  /**
+   * Assign the autorized system user as admin role.
+   */
+  public assignSystemUserAsAdminRole = async ({
+    tenantId,
+    systemUser,
+  }: IOrganizationBuildEventPayload) => {
+    await this.organizationService.syncSystemUserToTenant(tenantId, systemUser);
+  };
+}
diff --git a/packages/server/src/subscribers/PaymentMades/PaymentSyncBillBalance.ts b/packages/server/src/subscribers/PaymentMades/PaymentSyncBillBalance.ts
new file mode 100644
index 000000000..2b65f6a65
--- /dev/null
+++ b/packages/server/src/subscribers/PaymentMades/PaymentSyncBillBalance.ts
@@ -0,0 +1,71 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import BillPaymentsService from '@/services/Purchases/BillPayments/BillPayments';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import {
+  IBillPaymentEventCreatedPayload,
+  IBillPaymentEventDeletedPayload,
+  IBillPaymentEventEditedPayload,
+} from '@/interfaces';
+
+@Service()
+export default class PaymentSyncBillBalance {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  billPaymentsService: BillPaymentsService;
+
+  /**
+   *
+   * @param bus
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.billPayment.onCreated,
+      this.handleBillsIncrementPaymentAmount
+    );
+    bus.subscribe(
+      events.billPayment.onEdited,
+      this.handleBillsIncrementPaymentAmount
+    );
+    bus.subscribe(
+      events.billPayment.onDeleted,
+      this.handleBillDecrementPaymentAmount
+    );
+  }
+  /**
+   * Handle bill payment amount increment/decrement once bill payment created or edited.
+   */
+  private handleBillsIncrementPaymentAmount = async ({
+    tenantId,
+    billPayment,
+    oldBillPayment,
+    billPaymentId,
+    trx,
+  }: IBillPaymentEventCreatedPayload | IBillPaymentEventEditedPayload) => {
+    this.billPaymentsService.saveChangeBillsPaymentAmount(
+      tenantId,
+      billPayment.entries,
+      oldBillPayment?.entries || null,
+      trx
+    );
+  };
+
+  /**
+   * Handle revert bill payment amount once bill payment deleted.
+   */
+  private handleBillDecrementPaymentAmount = async ({
+    tenantId,
+    billPaymentId,
+    oldBillPayment,
+    trx,
+  }: IBillPaymentEventDeletedPayload) => {
+    this.billPaymentsService.saveChangeBillsPaymentAmount(
+      tenantId,
+      oldBillPayment.entries.map((entry) => ({ ...entry, paymentAmount: 0 })),
+      oldBillPayment.entries,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/subscribers/PaymentReceive/AutoSerialIncrement.ts b/packages/server/src/subscribers/PaymentReceive/AutoSerialIncrement.ts
new file mode 100644
index 000000000..0109b6c80
--- /dev/null
+++ b/packages/server/src/subscribers/PaymentReceive/AutoSerialIncrement.ts
@@ -0,0 +1,36 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import { EventSubscriber } from '@/lib/EventPublisher/EventPublisher';
+import PaymentReceiveService from '@/services/Sales/PaymentReceives/PaymentsReceives';
+import { IPaymentReceiveCreatedPayload } from '@/interfaces';
+
+@Service()
+export default class PaymentReceiveAutoSerialSubscriber extends EventSubscriber {
+  @Inject()
+  paymentReceivesService: PaymentReceiveService;
+
+  /**
+   * Attaches the events with handles.
+   * @param bus
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.paymentReceive.onCreated,
+      this.handlePaymentNextNumberIncrement
+    );
+  }
+
+  /**
+   * Handles increment next number of payment receive once be created.
+   * @param {IPaymentReceiveCreatedPayload} payload -
+   */
+  private handlePaymentNextNumberIncrement = async ({
+    tenantId,
+    paymentReceiveId,
+    trx,
+  }: IPaymentReceiveCreatedPayload) => {
+    await this.paymentReceivesService.incrementNextPaymentReceiveNumber(
+      tenantId
+    );
+  };
+}
diff --git a/packages/server/src/subscribers/PaymentReceive/PaymentReceiveSyncInvoices.ts b/packages/server/src/subscribers/PaymentReceive/PaymentReceiveSyncInvoices.ts
new file mode 100644
index 000000000..5dcd14528
--- /dev/null
+++ b/packages/server/src/subscribers/PaymentReceive/PaymentReceiveSyncInvoices.ts
@@ -0,0 +1,89 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import PaymentReceiveService from '@/services/Sales/PaymentReceives/PaymentsReceives';
+import {
+  IPaymentReceiveCreatedPayload,
+  IPaymentReceiveDeletedPayload,
+  IPaymentReceiveEditedPayload,
+} from '@/interfaces';
+
+@Service()
+export default class PaymentReceiveSyncInvoices {
+  @Inject()
+  paymentReceivesService: PaymentReceiveService;
+
+  /**
+   * Attaches the events to handles.
+   * @param bus
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.paymentReceive.onCreated,
+      this.handleInvoiceIncrementPaymentOnceCreated
+    );
+    bus.subscribe(
+      events.paymentReceive.onEdited,
+      this.handleInvoiceIncrementPaymentOnceEdited
+    );
+    bus.subscribe(
+      events.paymentReceive.onDeleted,
+      this.handleInvoiceDecrementPaymentAmount
+    );
+  }
+
+  /**
+   * Handle sale invoice increment/decrement payment amount
+   * once created, edited or deleted.
+   */
+  private handleInvoiceIncrementPaymentOnceCreated = async ({
+    tenantId,
+    paymentReceiveId,
+    paymentReceive,
+    trx,
+  }: IPaymentReceiveCreatedPayload) => {
+    await this.paymentReceivesService.saveChangeInvoicePaymentAmount(
+      tenantId,
+      paymentReceive.entries,
+      null,
+      trx
+    );
+  };
+
+  /**
+   * Handle sale invoice increment/decrement payment amount once edited.
+   */
+  private handleInvoiceIncrementPaymentOnceEdited = async ({
+    tenantId,
+    paymentReceiveId,
+    paymentReceive,
+    oldPaymentReceive,
+    trx,
+  }: IPaymentReceiveEditedPayload) => {
+    await this.paymentReceivesService.saveChangeInvoicePaymentAmount(
+      tenantId,
+      paymentReceive.entries,
+      oldPaymentReceive?.entries || null,
+      trx
+    );
+  };
+
+  /**
+   * Handle revert invoices payment amount once payment receive deleted.
+   */
+  private handleInvoiceDecrementPaymentAmount = async ({
+    tenantId,
+    paymentReceiveId,
+    oldPaymentReceive,
+    trx,
+  }: IPaymentReceiveDeletedPayload) => {
+    await this.paymentReceivesService.saveChangeInvoicePaymentAmount(
+      tenantId,
+      oldPaymentReceive.entries.map((entry) => ({
+        ...entry,
+        paymentAmount: 0,
+      })),
+      oldPaymentReceive.entries,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/subscribers/PaymentReceive/SendSmsNotificationToCustomer.ts b/packages/server/src/subscribers/PaymentReceive/SendSmsNotificationToCustomer.ts
new file mode 100644
index 000000000..4520c01f2
--- /dev/null
+++ b/packages/server/src/subscribers/PaymentReceive/SendSmsNotificationToCustomer.ts
@@ -0,0 +1,40 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import PaymentReceiveNotifyBySms from '@/services/Sales/PaymentReceives/PaymentReceiveSmsNotify';
+import { IPaymentReceiveCreatedPayload } from '@/interfaces';
+import { runAfterTransaction } from '@/services/UnitOfWork/TransactionsHooks';
+
+@Service()
+export default class SendSmsNotificationPaymentReceive {
+  @Inject()
+  paymentReceiveSmsNotify: PaymentReceiveNotifyBySms;
+
+  /**
+   * Attach events.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.paymentReceive.onCreated,
+      this.handleNotifyViaSmsOncePaymentPublish
+    );
+  }
+
+  /**
+   * Handles send SMS notification after payment transaction creation.
+   */
+  private handleNotifyViaSmsOncePaymentPublish = ({
+    tenantId,
+    paymentReceiveId,
+    trx,
+  }: IPaymentReceiveCreatedPayload) => {
+    // Notify via Sms after transactions complete running.
+    runAfterTransaction(trx, async () => {
+      try {
+        await this.paymentReceiveSmsNotify.notifyViaSmsNotificationAfterCreation(
+          tenantId,
+          paymentReceiveId
+        );
+      } catch (error) {}
+    });
+  };
+}
diff --git a/packages/server/src/subscribers/PaymentReceive/WriteGLEntries.ts b/packages/server/src/subscribers/PaymentReceive/WriteGLEntries.ts
new file mode 100644
index 000000000..bffe4260f
--- /dev/null
+++ b/packages/server/src/subscribers/PaymentReceive/WriteGLEntries.ts
@@ -0,0 +1,77 @@
+import { Inject, Service } from 'typedi';
+import {
+  IPaymentReceiveCreatedPayload,
+  IPaymentReceiveDeletedPayload,
+  IPaymentReceiveEditedPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import { PaymentReceiveGLEntries } from '@/services/Sales/PaymentReceives/PaymentReceiveGLEntries';
+
+@Service()
+export default class PaymentReceivesWriteGLEntriesSubscriber {
+  @Inject()
+  private paymentReceiveGLEntries: PaymentReceiveGLEntries;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.paymentReceive.onCreated,
+      this.handleWriteJournalEntriesOnceCreated
+    );
+    bus.subscribe(
+      events.paymentReceive.onEdited,
+      this.handleOverwriteJournalEntriesOnceEdited
+    );
+    bus.subscribe(
+      events.paymentReceive.onDeleted,
+      this.handleRevertJournalEntriesOnceDeleted
+    );
+  }
+
+  /**
+   * Handle journal entries writing once the payment receive created.
+   */
+  private handleWriteJournalEntriesOnceCreated = async ({
+    tenantId,
+    paymentReceiveId,
+    trx,
+  }: IPaymentReceiveCreatedPayload) => {
+    await this.paymentReceiveGLEntries.writePaymentGLEntries(
+      tenantId,
+      paymentReceiveId,
+      trx
+    );
+  };
+
+  /**
+   * Handle journal entries writing once the payment receive edited.
+   */
+  private handleOverwriteJournalEntriesOnceEdited = async ({
+    tenantId,
+    paymentReceive,
+    trx,
+  }: IPaymentReceiveEditedPayload) => {
+    await this.paymentReceiveGLEntries.rewritePaymentGLEntries(
+      tenantId,
+      paymentReceive.id,
+      trx
+    );
+  };
+
+  /**
+   * Handles revert journal entries once deleted.
+   */
+  private handleRevertJournalEntriesOnceDeleted = async ({
+    tenantId,
+    paymentReceiveId,
+    trx,
+  }: IPaymentReceiveDeletedPayload) => {
+    await this.paymentReceiveGLEntries.revertPaymentGLEntries(
+      tenantId,
+      paymentReceiveId,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/subscribers/SaleEstimate/AutoIncrementSerial.ts b/packages/server/src/subscribers/SaleEstimate/AutoIncrementSerial.ts
new file mode 100644
index 000000000..8cc9300fc
--- /dev/null
+++ b/packages/server/src/subscribers/SaleEstimate/AutoIncrementSerial.ts
@@ -0,0 +1,38 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import SettingsService from '@/services/Settings/SettingsService';
+import { ISaleEstimateCreatedPayload } from '@/interfaces';
+
+@Service()
+export default class SaleEstimateAutoSerialSubscriber {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  settingsService: SettingsService;
+
+  /**
+   * Attaches events to handles.events.saleEstimate.onCreated
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleEstimate.onCreated,
+      this.handleEstimateNextNumberIncrement
+    );
+  }
+
+  /**
+   * Handle sale estimate increment next number once be created.
+   */
+  private handleEstimateNextNumberIncrement = async ({
+    tenantId,
+    saleEstimateId,
+    trx,
+  }: ISaleEstimateCreatedPayload) => {
+    await this.settingsService.incrementNextNumber(tenantId, {
+      key: 'next_number',
+      group: 'sales_estimates',
+    });
+  };
+}
diff --git a/packages/server/src/subscribers/SaleEstimate/SmsNotifications.ts b/packages/server/src/subscribers/SaleEstimate/SmsNotifications.ts
new file mode 100644
index 000000000..a7475c7bc
--- /dev/null
+++ b/packages/server/src/subscribers/SaleEstimate/SmsNotifications.ts
@@ -0,0 +1,43 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import SaleEstimateNotifyBySms from '@/services/Sales/Estimates/SaleEstimateSmsNotify';
+import { ISaleEstimateCreatedPayload } from '@/interfaces';
+import { runAfterTransaction } from '@/services/UnitOfWork/TransactionsHooks';
+
+@Service()
+export default class SaleEstimateSmsNotificationSubscriber {
+  @Inject()
+  saleEstimateNotifyBySms: SaleEstimateNotifyBySms;
+
+  /**
+   * Attaches events to handles.events.saleEstimate.onCreated
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleEstimate.onCreated,
+      this.handleNotifySmSNotificationAfterCreation
+    );
+  }
+
+  /**
+   * Notify via SMS notification after sale estimate creation.
+   */
+  private handleNotifySmSNotificationAfterCreation = async ({
+    tenantId,
+    saleEstimateId,
+    saleEstimate,
+    trx,
+  }: ISaleEstimateCreatedPayload) => {
+    // Can't continue if estimate is not delivered.
+    if (!saleEstimate.isDelivered) return;
+
+    runAfterTransaction(trx, async () => {
+      try {
+        await this.saleEstimateNotifyBySms.notifyViaSmsNotificationAfterCreation(
+          tenantId,
+          saleEstimateId
+        );
+      } catch (error) {}
+    });
+  };
+}
diff --git a/packages/server/src/subscribers/SaleInvoices/AutoIncrementSerial.ts b/packages/server/src/subscribers/SaleInvoices/AutoIncrementSerial.ts
new file mode 100644
index 000000000..fd458738b
--- /dev/null
+++ b/packages/server/src/subscribers/SaleInvoices/AutoIncrementSerial.ts
@@ -0,0 +1,31 @@
+import { Inject, Service } from 'typedi';
+import { EventSubscriber } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+import SaleInvoicesService from '@/services/Sales/SalesInvoices';
+import { ISaleInvoiceCreatedPayload } from '@/interfaces';
+
+@Service()
+export default class SaleInvoiceAutoIncrementSubscriber extends EventSubscriber {
+  @Inject()
+  saleInvoicesService: SaleInvoicesService;
+
+  /**
+   * Constructor method.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleInvoice.onCreated,
+      this.handleInvoiceNextNumberIncrement
+    );
+  }
+
+  /**
+   * Handles sale invoice next number increment once invoice created.
+   * @param {ISaleInvoiceCreatedPayload} payload -
+   */
+  private handleInvoiceNextNumberIncrement = async ({
+    tenantId,
+  }: ISaleInvoiceCreatedPayload) => {
+    await this.saleInvoicesService.incrementNextInvoiceNumber(tenantId);
+  };
+}
diff --git a/packages/server/src/subscribers/SaleInvoices/ConvertFromEstimate.ts b/packages/server/src/subscribers/SaleInvoices/ConvertFromEstimate.ts
new file mode 100644
index 000000000..913bcf3ab
--- /dev/null
+++ b/packages/server/src/subscribers/SaleInvoices/ConvertFromEstimate.ts
@@ -0,0 +1,41 @@
+import { Inject, Service } from 'typedi';
+import { EventSubscriber } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+import SaleEstimateService from '@/services/Sales/SalesEstimate';
+import { ISaleInvoiceCreatedPayload } from '@/interfaces';
+
+@Service()
+export default class SaleInvoiceConvertFromEstimateSubscriber extends EventSubscriber {
+  @Inject()
+  saleEstimatesService: SaleEstimateService;
+
+  /**
+   * Constructor method.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleInvoice.onCreated,
+      this.handleMarkEstimateConvertOnceInvoiceCreated
+    );
+  }
+
+  /**
+   * Marks the sale estimate as converted from the sale invoice once created.
+   */
+  private handleMarkEstimateConvertOnceInvoiceCreated = async ({
+    tenantId,
+    saleInvoice,
+    saleInvoiceDTO,
+    saleInvoiceId,
+    trx,
+  }: ISaleInvoiceCreatedPayload) => {
+    if (saleInvoiceDTO.fromEstimateId) {
+      await this.saleEstimatesService.convertEstimateToInvoice(
+        tenantId,
+        saleInvoiceDTO.fromEstimateId,
+        saleInvoiceId,
+        trx
+      );
+    }
+  };
+}
diff --git a/packages/server/src/subscribers/SaleInvoices/SendSmsNotificationToCustomer.ts b/packages/server/src/subscribers/SaleInvoices/SendSmsNotificationToCustomer.ts
new file mode 100644
index 000000000..35d4e3e16
--- /dev/null
+++ b/packages/server/src/subscribers/SaleInvoices/SendSmsNotificationToCustomer.ts
@@ -0,0 +1,44 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import SaleInvoiceNotifyBySms from '@/services/Sales/SaleInvoiceNotifyBySms';
+import { ISaleInvoiceCreatedPayload } from '@/interfaces';
+import { runAfterTransaction } from '@/services/UnitOfWork/TransactionsHooks';
+
+@Service()
+export default class SendSmsNotificationToCustomer {
+  @Inject()
+  saleInvoiceNotifyBySms: SaleInvoiceNotifyBySms;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleInvoice.onCreated,
+      this.sendSmsNotificationAfterInvoiceCreation
+    );
+  }
+
+  /**
+   * Hnadle sending SMS notification after invoice transaction creation.
+   */
+  private sendSmsNotificationAfterInvoiceCreation = async ({
+    tenantId,
+    saleInvoiceId,
+    saleInvoice,
+    trx,
+  }: ISaleInvoiceCreatedPayload) => {
+    // Can't continue if the sale invoice is not marked as delivered.
+    if (!saleInvoice.deliveredAt) return;
+
+    // Notify via sms after transactions complete running.
+    runAfterTransaction(trx, async () => {
+      try {
+        await this.saleInvoiceNotifyBySms.notifyDetailsBySmsAfterCreation(
+          tenantId,
+          saleInvoiceId
+        );
+      } catch (error) {}
+    });
+  };
+}
diff --git a/packages/server/src/subscribers/SaleInvoices/WriteInventoryTransactions.ts b/packages/server/src/subscribers/SaleInvoices/WriteInventoryTransactions.ts
new file mode 100644
index 000000000..7d64a146f
--- /dev/null
+++ b/packages/server/src/subscribers/SaleInvoices/WriteInventoryTransactions.ts
@@ -0,0 +1,87 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import SaleInvoicesService from '@/services/Sales/SalesInvoices';
+import {
+  ISaleInvoiceCreatedPayload,
+  ISaleInvoiceDeletedPayload,
+  ISaleInvoiceEditedPayload,
+} from '@/interfaces';
+
+@Service()
+export default class WriteInventoryTransactions {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  saleInvoicesService: SaleInvoicesService;
+
+  /**
+   * Attaches events with handles
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleInvoice.onCreated,
+      this.handleWritingInventoryTransactions
+    );
+    bus.subscribe(
+      events.saleInvoice.onEdited,
+      this.handleRewritingInventoryTransactions
+    );
+    bus.subscribe(
+      events.saleInvoice.onDeleted,
+      this.handleDeletingInventoryTransactions
+    );
+  }
+
+  /**
+   * Handles the writing inventory transactions once the invoice created.
+   * @param {ISaleInvoiceCreatedPayload} payload
+   */
+  private handleWritingInventoryTransactions = async ({
+    tenantId,
+    saleInvoice,
+    trx,
+  }: ISaleInvoiceCreatedPayload) => {
+    await this.saleInvoicesService.recordInventoryTranscactions(
+      tenantId,
+      saleInvoice,
+      false,
+      trx
+    );
+  };
+
+  /**
+   * Rewriting the inventory transactions once the sale invoice be edited.
+   * @param {ISaleInvoiceEditPayload} payload - 
+   */
+  private handleRewritingInventoryTransactions = async ({
+    tenantId,
+    saleInvoice,
+    trx,
+  }: ISaleInvoiceEditedPayload) => {
+    await this.saleInvoicesService.recordInventoryTranscactions(
+      tenantId,
+      saleInvoice,
+      true,
+      trx
+    );
+  };
+
+  /**
+   * Handles deleting the inventory transactions once the invoice deleted.
+   * @param {ISaleInvoiceDeletedPayload} payload - 
+   */
+  private handleDeletingInventoryTransactions = async ({
+    tenantId,
+    saleInvoiceId,
+    oldSaleInvoice,
+    trx,
+  }: ISaleInvoiceDeletedPayload) => {
+    await this.saleInvoicesService.revertInventoryTransactions(
+      tenantId,
+      saleInvoiceId,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/subscribers/SaleInvoices/WriteJournalEntries.ts b/packages/server/src/subscribers/SaleInvoices/WriteJournalEntries.ts
new file mode 100644
index 000000000..fc5d9411b
--- /dev/null
+++ b/packages/server/src/subscribers/SaleInvoices/WriteJournalEntries.ts
@@ -0,0 +1,77 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import {
+  ISaleInvoiceCreatedPayload,
+  ISaleInvoiceDeletePayload,
+  ISaleInvoiceEditedPayload,
+} from '@/interfaces';
+import { SaleInvoiceGLEntries } from '@/services/Sales/Invoices/InvoiceGLEntries';
+
+@Service()
+export default class SaleInvoiceWriteGLEntriesSubscriber {
+  @Inject()
+  private saleInvoiceGLEntries: SaleInvoiceGLEntries;
+
+  /**
+   * Constructor method.
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.saleInvoice.onCreated,
+      this.handleWriteJournalEntriesOnInvoiceCreated
+    );
+    bus.subscribe(
+      events.saleInvoice.onEdited,
+      this.handleRewriteJournalEntriesOnceInvoiceEdit
+    );
+    bus.subscribe(
+      events.saleInvoice.onDeleted,
+      this.handleRevertingInvoiceJournalEntriesOnDelete
+    );
+  }
+
+  /**
+   * Records journal entries of the non-inventory invoice.
+   */
+  private handleWriteJournalEntriesOnInvoiceCreated = async ({
+    tenantId,
+    saleInvoiceId,
+    trx,
+  }: ISaleInvoiceCreatedPayload) => {
+    await this.saleInvoiceGLEntries.writeInvoiceGLEntries(
+      tenantId,
+      saleInvoiceId,
+      trx
+    );
+  };
+
+  /**
+   * Records journal entries of the non-inventory invoice.
+   */
+  private handleRewriteJournalEntriesOnceInvoiceEdit = async ({
+    tenantId,
+    saleInvoice,
+    trx,
+  }: ISaleInvoiceEditedPayload) => {
+    await this.saleInvoiceGLEntries.rewritesInvoiceGLEntries(
+      tenantId,
+      saleInvoice.id,
+      trx
+    );
+  };
+
+  /**
+   * Handle reverting journal entries once sale invoice delete.
+   */
+  private handleRevertingInvoiceJournalEntriesOnDelete = async ({
+    tenantId,
+    saleInvoiceId,
+    trx,
+  }: ISaleInvoiceDeletePayload) => {
+    await this.saleInvoiceGLEntries.revertInvoiceGLEntries(
+      tenantId,
+      saleInvoiceId,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/subscribers/SaleReceipt/AutoIncrementSerial.ts b/packages/server/src/subscribers/SaleReceipt/AutoIncrementSerial.ts
new file mode 100644
index 000000000..d2b712a8a
--- /dev/null
+++ b/packages/server/src/subscribers/SaleReceipt/AutoIncrementSerial.ts
@@ -0,0 +1,31 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import SalesReceiptService from '@/services/Sales/SalesReceipts';
+import { ISaleReceiptCreatedPayload } from '@/interfaces';
+
+@Service()
+export default class SaleReceiptAutoSerialSubscriber {
+  @Inject()
+  saleReceiptsService: SalesReceiptService;
+
+  /**
+   *
+   * @param bus
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleReceipt.onCreated,
+      this.handleReceiptNextNumberIncrement
+    );
+  }
+
+  /**
+   * Handle sale receipt increment next number once be created.
+   */
+  private handleReceiptNextNumberIncrement = async ({
+    tenantId,
+    saleReceiptId,
+  }: ISaleReceiptCreatedPayload) => {
+    await this.saleReceiptsService.incrementNextReceiptNumber(tenantId);
+  };
+}
diff --git a/packages/server/src/subscribers/SaleReceipt/SendSmsNotificationToCustomer.ts b/packages/server/src/subscribers/SaleReceipt/SendSmsNotificationToCustomer.ts
new file mode 100644
index 000000000..536adb6a1
--- /dev/null
+++ b/packages/server/src/subscribers/SaleReceipt/SendSmsNotificationToCustomer.ts
@@ -0,0 +1,45 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import SaleReceiptNotifyBySms from '@/services/Sales/SaleReceiptNotifyBySms';
+import { ISaleReceiptCreatedPayload } from '@/interfaces';
+import { runAfterTransaction } from '@/services/UnitOfWork/TransactionsHooks';
+
+@Service()
+export default class SendSmsNotificationSaleReceipt {
+  @Inject()
+  saleReceiptNotifyBySms: SaleReceiptNotifyBySms;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleReceipt.onCreated,
+      this.handleNotifyViaSmsAfterReceiptCreation
+    );
+  }
+
+  /**
+   * Notify via SMS message after receipt transaction creation.
+   * @param {ISaleReceiptCreatedPayload} payload -
+   */
+  private handleNotifyViaSmsAfterReceiptCreation = ({
+    tenantId,
+    saleReceiptId,
+    saleReceipt,
+    trx,
+  }: ISaleReceiptCreatedPayload) => {
+    // Can't continue if the sale receipt is not closed.
+    if (!saleReceipt.isClosed) return;
+
+    // Notify via sms after transaction complete running.
+    runAfterTransaction(trx, async () => {
+      try {
+        await this.saleReceiptNotifyBySms.notifyViaSmsAfterCreation(
+          tenantId,
+          saleReceiptId
+        );
+      } catch (error) {}
+    });
+  };
+}
diff --git a/packages/server/src/subscribers/SaleReceipt/WriteInventoryTransactions.ts b/packages/server/src/subscribers/SaleReceipt/WriteInventoryTransactions.ts
new file mode 100644
index 000000000..1d224372c
--- /dev/null
+++ b/packages/server/src/subscribers/SaleReceipt/WriteInventoryTransactions.ts
@@ -0,0 +1,87 @@
+import { Inject } from 'typedi';
+import { EventSubscriber } from 'event-dispatch';
+import events from '@/subscribers/events';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import SalesReceiptService from '@/services/Sales/SalesReceipts';
+import {
+  ISaleReceiptCreatedPayload,
+  ISaleReceiptEditedPayload,
+  ISaleReceiptEventDeletedPayload,
+} from '@/interfaces';
+
+@EventSubscriber()
+export default class SaleReceiptInventoryTransactionsSubscriber {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  saleReceiptsService: SalesReceiptService;
+
+  /**
+   * Subscribe events to handles.
+   */
+  attach(bus) {
+    bus.subscribe(
+      events.saleReceipt.onCreated,
+      this.handleWritingInventoryTransactions
+    );
+    bus.subscribe(
+      events.saleReceipt.onEdited,
+      this.handleRewritingInventoryTransactions
+    );
+    bus.subscribe(
+      events.saleReceipt.onDeleted,
+      this.handleDeletingInventoryTransactions
+    );
+  }
+
+  /**
+   * Handles the writing inventory transactions once the receipt created.
+   * @param {ISaleReceiptCreatedPayload} payload -
+   */
+  private handleWritingInventoryTransactions = async ({
+    tenantId,
+    saleReceipt,
+    trx,
+  }: ISaleReceiptCreatedPayload) => {
+    await this.saleReceiptsService.recordInventoryTransactions(
+      tenantId,
+      saleReceipt,
+      false,
+      trx
+    );
+  };
+
+  /**
+   * Rewriting the inventory transactions once the sale invoice be edited.
+   * @param {ISaleReceiptEditedPayload} payload -
+   */
+  private handleRewritingInventoryTransactions = async ({
+    tenantId,
+    saleReceipt,
+    trx,
+  }: ISaleReceiptEditedPayload) => {
+    await this.saleReceiptsService.recordInventoryTransactions(
+      tenantId,
+      saleReceipt,
+      true,
+      trx
+    );
+  };
+
+  /**
+   * Handles deleting the inventory transactions once the receipt deleted.
+   * @param {ISaleReceiptEventDeletedPayload} payload -
+   */
+  private handleDeletingInventoryTransactions = async ({
+    tenantId,
+    saleReceiptId,
+    trx,
+  }: ISaleReceiptEventDeletedPayload) => {
+    await this.saleReceiptsService.revertInventoryTransactions(
+      tenantId,
+      saleReceiptId,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/subscribers/SaleReceipt/WriteJournalEntries.ts b/packages/server/src/subscribers/SaleReceipt/WriteJournalEntries.ts
new file mode 100644
index 000000000..d505a3841
--- /dev/null
+++ b/packages/server/src/subscribers/SaleReceipt/WriteJournalEntries.ts
@@ -0,0 +1,87 @@
+import { Service, Inject } from 'typedi';
+import events from '@/subscribers/events';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import SalesReceiptService from '@/services/Sales/SalesReceipts';
+import {
+  ISaleReceiptCreatedPayload,
+  ISaleReceiptEditedPayload,
+  ISaleReceiptEventDeletedPayload,
+} from '@/interfaces';
+import { SaleReceiptGLEntries } from '@/services/Sales/SaleReceiptGLEntries';
+
+@Service()
+export default class SaleReceiptWriteGLEntriesSubscriber {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject()
+  saleReceiptGLEntries: SaleReceiptGLEntries;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleReceipt.onCreated,
+      this.handleWriteReceiptIncomeJournalEntrieOnCreate
+    );
+    bus.subscribe(
+      events.saleReceipt.onEdited,
+      this.handleWriteReceiptIncomeJournalEntrieOnEdited
+    );
+    bus.subscribe(
+      events.saleReceipt.onDeleted,
+      this.handleRevertReceiptJournalEntriesOnDeleted
+    );
+  }
+
+  /**
+   * Handles writing sale receipt income journal entries once created.
+   * @param {ISaleReceiptCreatedPayload} payload -
+   */
+  public handleWriteReceiptIncomeJournalEntrieOnCreate = async ({
+    tenantId,
+    saleReceiptId,
+    trx,
+  }: ISaleReceiptCreatedPayload) => {
+    // Writes the sale receipt income journal entries.
+    await this.saleReceiptGLEntries.writeIncomeGLEntries(
+      tenantId,
+      saleReceiptId,
+      trx
+    );
+  };
+
+  /**
+   * Handles sale receipt revert jouranl entries once be deleted.
+   * @param {ISaleReceiptEventDeletedPayload} payload -
+   */
+  public handleRevertReceiptJournalEntriesOnDeleted = async ({
+    tenantId,
+    saleReceiptId,
+    trx,
+  }: ISaleReceiptEventDeletedPayload) => {
+    await this.saleReceiptGLEntries.revertReceiptGLEntries(
+      tenantId,
+      saleReceiptId,
+      trx
+    );
+  };
+
+  /**
+   * Handles writing sale receipt income journal entries once be edited.
+   * @param {ISaleReceiptEditedPayload} payload -
+   */
+  private handleWriteReceiptIncomeJournalEntrieOnEdited = async ({
+    tenantId,
+    saleReceiptId,
+    trx,
+  }: ISaleReceiptEditedPayload) => {
+    // Writes the sale receipt income journal entries.
+    await this.saleReceiptGLEntries.rewriteReceiptGLEntries(
+      tenantId,
+      saleReceiptId,
+      trx
+    );
+  };
+}
diff --git a/packages/server/src/subscribers/events.ts b/packages/server/src/subscribers/events.ts
new file mode 100644
index 000000000..a4abf80fb
--- /dev/null
+++ b/packages/server/src/subscribers/events.ts
@@ -0,0 +1,553 @@
+export default {
+  /**
+   * Authentication service.
+   */
+  auth: {
+    login: 'onLogin',
+    register: 'onRegister',
+    sendResetPassword: 'onSendResetPassword',
+    resetPassword: 'onResetPassword',
+  },
+
+  /**
+   * Invite users service.
+   */
+  inviteUser: {
+    acceptInvite: 'onUserAcceptInvite',
+    sendInvite: 'onUserSendInvite',
+    resendInvite: 'onUserInviteResend',
+    checkInvite: 'onUserCheckInvite',
+    sendInviteTenantSynced: 'onUserSendInviteTenantSynced',
+  },
+
+  /**
+   * Organization managment service.
+   */
+  organization: {
+    build: 'onOrganizationBuild',
+    seeded: 'onOrganizationSeeded',
+
+    baseCurrencyUpdated: 'onOrganizationBaseCurrencyUpdated',
+  },
+
+  /**
+   * Tenants managment service.
+   */
+  tenantManager: {
+    databaseCreated: 'onDatabaseCreated',
+    tenantMigrated: 'onTenantMigrated',
+    tenantSeeded: 'onTenantSeeded',
+  },
+
+  /**
+   * Accounts service.
+   */
+  accounts: {
+    onCreating: 'onAccountCreating',
+    onCreated: 'onAccountCreated',
+
+    onEditing: 'onAccountEditing',
+    onEdited: 'onAccountEdited',
+
+    onDelete: 'onAccountDelete',
+    onDeleted: 'onAccountDeleted',
+
+    onBulkDeleted: 'onBulkDeleted',
+    onBulkActivated: 'onAccountBulkActivated',
+
+    onActivated: 'onAccountActivated',
+  },
+
+  /**
+   * Manual journals service.
+   */
+  manualJournals: {
+    onCreating: 'onManualJournalCreating',
+    onCreated: 'onManualJournalCreated',
+
+    onEditing: 'onManualJournalEditing',
+    onEdited: 'onManualJournalEdited',
+
+    onDeleting: 'onManualJournalDeleting',
+    onDeleted: 'onManualJournalDeleted',
+
+    onPublished: 'onManualJournalPublished',
+    onPublishing: 'onManualJournalPublishing',
+  },
+
+  /**
+   * Expenses service.
+   */
+  expenses: {
+    onCreating: 'onExpenseCreating',
+    onCreated: 'onExpenseCreated',
+
+    onEditing: 'onExpenseEditing',
+    onEdited: 'onExpenseEdited',
+
+    onDeleting: 'onExpenseDeleting',
+    onDeleted: 'onExpenseDeleted',
+
+    onPublishing: 'onExpensePublishing',
+    onPublished: 'onExpensePublished',
+  },
+
+  /**
+   * Sales invoices service.
+   */
+  saleInvoice: {
+    onCreate: 'onSaleInvoiceCreate',
+    onCreating: 'onSaleInvoiceCreating',
+    onCreated: 'onSaleInvoiceCreated',
+
+    onEdit: 'onSaleInvoiceEdit',
+    onEditing: 'onSaleInvoiceEditing',
+    onEdited: 'onSaleInvoiceEdited',
+
+    onDelete: 'onSaleInvoiceDelete',
+    onDeleting: 'onSaleInvoiceDeleting',
+    onDeleted: 'onSaleInvoiceDeleted',
+
+    onDelivering: 'onSaleInvoiceDelivering',
+    onDeliver: 'onSaleInvoiceDeliver',
+    onDelivered: 'onSaleInvoiceDelivered',
+
+    onPublish: 'onSaleInvoicePublish',
+    onPublished: 'onSaleInvoicePublished',
+
+    onWriteoff: 'onSaleInvoiceWriteoff',
+    onWrittenoff: 'onSaleInvoiceWrittenoff',
+    onWrittenoffCancel: 'onSaleInvoiceWrittenoffCancel',
+    onWrittenoffCanceled: 'onSaleInvoiceWrittenoffCanceled',
+
+    onNotifySms: 'onSaleInvoiceNotifySms',
+    onNotifiedSms: 'onSaleInvoiceNotifiedSms',
+  },
+
+  /**
+   * Sales estimates service.
+   */
+  saleEstimate: {
+    onCreating: 'onSaleEstimateCreating',
+    onCreated: 'onSaleEstimateCreated',
+
+    onEditing: 'onSaleEstimateEditing',
+    onEdited: 'onSaleEstimateEdited',
+
+    onDeleting: 'onSaleEstimatedDeleting',
+    onDeleted: 'onSaleEstimatedDeleted',
+
+    onPublishing: 'onSaleEstimatedPublishing',
+    onPublished: 'onSaleEstimatedPublished',
+
+    onNotifySms: 'onSaleEstimateNotifySms',
+    onNotifiedSms: 'onSaleEstimateNotifiedSms',
+
+    onDelivering: 'onSaleEstimateDelivering',
+    onDelivered: 'onSaleEstimateDelivered',
+
+    onConvertedToInvoice: 'onSaleEstimateConvertedToInvoice',
+
+    onApproving: 'onSaleEstimateApproving',
+    onApproved: 'onSaleEstimateApproved',
+
+    onRejecting: 'onSaleEstimateRejecting',
+    onRejected: 'onSaleEstimateRejected',
+  },
+
+  /**
+   * Sales receipts service.
+   */
+  saleReceipt: {
+    onCreating: 'onSaleReceiptsCreating',
+    onCreated: 'onSaleReceiptsCreated',
+
+    onEditing: 'onSaleReceiptsEditing',
+    onEdited: 'onSaleReceiptsEdited',
+
+    onDeleting: 'onSaleReceiptsDeleting',
+    onDeleted: 'onSaleReceiptsDeleted',
+
+    onPublishing: 'onSaleReceiptPublishing',
+    onPublished: 'onSaleReceiptPublished',
+
+    onClosed: 'onSaleReceiptClosed',
+    onClosing: 'onSaleReceiptClosing',
+
+    onNotifySms: 'onSaleReceiptNotifySms',
+    onNotifiedSms: 'onSaleReceiptNotifiedSms',
+  },
+
+  /**
+   * Payment receipts service.
+   */
+  paymentReceive: {
+    onCreated: 'onPaymentReceiveCreated',
+    onCreating: 'onPaymentReceiveCreating',
+
+    onEditing: 'onPaymentReceiveEditing',
+    onEdited: 'onPaymentReceiveEdited',
+
+    onDeleting: 'onPaymentReceiveDeleting',
+    onDeleted: 'onPaymentReceiveDeleted',
+
+    onPublishing: 'onPaymentReceivePublishing',
+    onPublished: 'onPaymentReceivePublished',
+
+    onNotifySms: 'onPaymentReceiveNotifySms',
+    onNotifiedSms: 'onPaymentReceiveNotifiedSms',
+  },
+
+  /**
+   * Bills service.
+   */
+  bill: {
+    onCreating: 'onBillCreating',
+    onCreated: 'onBillCreated',
+
+    onEditing: 'onBillEditing',
+    onEdited: 'onBillEdited',
+
+    onDeleting: 'onBillDeleting',
+    onDeleted: 'onBillDeleted',
+
+    onPublishing: 'onBillPublishing',
+    onPublished: 'onBillPublished',
+  },
+
+  /**
+   * Bill payments service.
+   */
+  billPayment: {
+    onCreating: 'onBillPaymentCreating',
+    onCreated: 'onBillPaymentCreated',
+
+    onEditing: 'onBillPaymentEditing',
+    onEdited: 'onBillPaymentEdited',
+
+    onDeleted: 'onBillPaymentDeleted',
+    onDeleting: 'onBillPaymentDeleting',
+
+    onPublishing: 'onBillPaymentPublishing',
+    onPublished: 'onBillPaymentPublished',
+  },
+
+  /**
+   * Customers services.
+   */
+  customers: {
+    onCreating: 'onCustomerCreating',
+    onCreated: 'onCustomerCreated',
+
+    onEdited: 'onCustomerEdited',
+    onEditing: 'onCustomerEditing',
+
+    onDeleted: 'onCustomerDeleted',
+    onDeleting: 'onCustomerDeleting',
+    onBulkDeleted: 'onBulkDeleted',
+
+    onOpeningBalanceChanging: 'onCustomerOpeningBalanceChanging',
+    onOpeningBalanceChanged: 'onCustomerOpeingBalanceChanged',
+
+    onActivating: 'onCustomerActivating',
+    onActivated: 'onCustomerActivated',
+  },
+
+  /**
+   * Vendors services.
+   */
+  vendors: {
+    onCreated: 'onVendorCreated',
+    onCreating: 'onVendorCreating',
+
+    onEdited: 'onVendorEdited',
+    onEditing: 'onVendorEditing',
+
+    onDeleted: 'onVendorDeleted',
+    onDeleting: 'onVendorDeleting',
+
+    onOpeningBalanceChanging: 'onVendorOpeingBalanceChanging',
+    onOpeningBalanceChanged: 'onVendorOpeingBalanceChanged',
+
+    onActivating: 'onVendorActivating',
+    onActivated: 'onVendorActivated',
+  },
+
+  /**
+   * Items service.
+   */
+  item: {
+    onCreated: 'onItemCreated',
+    onCreating: 'onItemCreating',
+
+    onEditing: 'onItemEditing',
+    onEdited: 'onItemEdited',
+
+    onDeleted: 'onItemDeleted',
+    onDeleting: 'onItemDeleting',
+
+    onActivating: 'onItemActivating',
+    onActivated: 'onItemActivated',
+
+    onInactivating: 'onInactivating',
+    onInactivated: 'onItemInactivated',
+  },
+
+  /**
+   * Item category service.
+   */
+  itemCategory: {
+    onCreated: 'onItemCategoryCreated',
+    onEdited: 'onItemCategoryEdited',
+    onDeleted: 'onItemCategoryDeleted',
+    onBulkDeleted: 'onItemCategoryBulkDeleted',
+  },
+
+  /**
+   * Inventory service.
+   */
+  inventory: {
+    onInventoryTransactionsCreated: 'onInventoryTransactionsCreated',
+    onInventoryTransactionsDeleted: 'onInventoryTransactionsDeleted',
+
+    onComputeItemCostJobScheduled: 'onComputeItemCostJobScheduled',
+    onComputeItemCostJobStarted: 'onComputeItemCostJobStarted',
+    onComputeItemCostJobCompleted: 'onComputeItemCostJobCompleted',
+
+    onInventoryCostEntriesWritten: 'onInventoryCostEntriesWritten',
+
+    onCostLotsGLEntriesBeforeWrite: 'onInventoryCostLotsGLEntriesBeforeWrite',
+    onCostLotsGLEntriesWrite: 'onInventoryCostLotsGLEntriesWrite',
+  },
+
+  /**
+   * Inventory adjustment service.
+   */
+  inventoryAdjustment: {
+    onQuickCreating: 'onInventoryAdjustmentCreating',
+    onQuickCreated: 'onInventoryAdjustmentQuickCreated',
+
+    onCreated: 'onInventoryAdjustmentCreated',
+
+    onDeleting: 'onInventoryAdjustmentDeleting',
+    onDeleted: 'onInventoryAdjustmentDeleted',
+
+    onPublishing: 'onInventoryAdjustmentPublishing',
+    onPublished: 'onInventoryAdjustmentPublished',
+  },
+
+  /**
+   * Bill landed cost.
+   */
+  billLandedCost: {
+    onCreate: 'onBillLandedCostCreate',
+    onCreated: 'onBillLandedCostCreated',
+    onDelete: 'onBillLandedCostDelete',
+    onDeleted: 'onBillLandedCostDeleted',
+  },
+
+  cashflow: {
+    onOwnerContributionCreate: 'onCashflowOwnerContributionCreate',
+    onOwnerContributionCreated: 'onCashflowOwnerContributionCreated',
+
+    onOtherIncomeCreate: 'onCashflowOtherIncomeCreate',
+    onOtherIncomeCreated: 'onCashflowOtherIncomeCreated',
+
+    onTransactionCreating: 'onCashflowTransactionCreating',
+    onTransactionCreated: 'onCashflowTransactionCreated',
+
+    onTransactionDeleting: 'onCashflowTransactionDeleting',
+    onTransactionDeleted: 'onCashflowTransactionDeleted',
+  },
+
+  /**
+   * Roles service events.
+   */
+  roles: {
+    onCreate: 'onRoleCreate',
+    onCreated: 'onRoleCreated',
+    onEdit: 'onRoleEdit',
+    onEdited: 'onRoleEdited',
+    onDelete: 'onRoleDelete',
+    onDeleted: 'onRoleDeleted',
+  },
+
+  tenantUser: {
+    onEdited: 'onTenantUserEdited',
+    onDeleted: 'onTenantUserDeleted',
+    onActivated: 'onTenantUserActivated',
+    onInactivated: 'onTenantUserInactivated',
+  },
+
+  /**
+   * Credit note service.
+   */
+  creditNote: {
+    onCreate: 'onCreditNoteCreate',
+    onCreating: 'onCreditNoteCreating',
+    onCreated: 'onCreditNoteCreated',
+
+    onEditing: 'onCreditNoteEditing',
+    onEdit: 'onCreditNoteEdit',
+    onEdited: 'onCreditNoteEdited',
+
+    onDelete: 'onCreditNoteDelete',
+    onDeleting: 'onCreditNoteDeleting',
+    onDeleted: 'onCreditNoteDeleted',
+
+    onOpen: 'onCreditNoteOpen',
+    onOpening: 'onCreditNoteOpening',
+    onOpened: 'onCreditNoteOpened',
+
+    onRefundCreate: 'onCreditNoteRefundCreate',
+    onRefundCreating: 'onCreditNoteRefundCreating',
+    onRefundCreated: 'onCreditNoteRefundCreated',
+
+    onRefundDelete: 'onCreditNoteRefundDelete',
+    onRefundDeleting: 'onCreditNoteRefundDeleting',
+    onRefundDeleted: 'onCreditNoteRefundDeleted',
+
+    onApplyToInvoicesCreated: 'onCreditNoteApplyToInvoiceCreated',
+    onApplyToInvoicesCreate: 'onCreditNoteApplyToInvoiceCreate',
+    onApplyToInvoicesDeleted: 'onCreditNoteApplyToInvoiceDeleted',
+  },
+
+  /**
+   * Vendor credit service.
+   */
+  vendorCredit: {
+    onCreate: 'onVendorCreditCreate',
+    onCreating: 'onVendorCreditCreating',
+    onCreated: 'onVendorCreditCreated',
+
+    onEdit: 'onVendorCreditEdit',
+    onEditing: 'onVendorCreditEditing',
+    onEdited: 'onVendorCreditEdited',
+
+    onDelete: 'onVendorCreditDelete',
+    onDeleting: 'onVendorCreditDeleting',
+    onDeleted: 'onVendorCreditDeleted',
+
+    onOpen: 'onVendorCreditOpen',
+    onOpened: 'onVendorCreditOpened',
+
+    onRefundCreating: 'onVendorCreditRefundCreating',
+    onRefundCreate: 'onVendorCreditRefundCreate',
+    onRefundCreated: 'onVendorCreditRefundCreated',
+
+    onRefundDelete: 'onVendorCreditRefundDelete',
+    onRefundDeleting: 'onVendorCreditRefundDeleting',
+    onRefundDeleted: 'onVendorCreditRefundDeleted',
+
+    onApplyToInvoicesCreated: 'onVendorCreditApplyToInvoiceCreated',
+    onApplyToInvoicesCreate: 'onVendorCreditApplyToInvoiceCreate',
+    onApplyToInvoicesDeleted: 'onVendorCreditApplyToInvoiceDeleted',
+  },
+
+  transactionsLocking: {
+    locked: 'onTransactionLockingLocked',
+    lockCanceled: 'onTransactionLockingLockCanceled',
+    partialUnlocked: 'onTransactionLockingPartialUnlocked',
+    partialUnlockCanceled: 'onTransactionLockingPartialUnlockCanceled',
+  },
+
+  warehouse: {
+    onCreate: 'onWarehouseCreate',
+    onCreated: 'onWarehouseCreated',
+
+    onEdit: 'onWarehouseEdit',
+    onEdited: 'onWarehouseEdited',
+
+    onDelete: 'onWarehouseDelete',
+    onDeleted: 'onWarehouseDeleted',
+
+    onActivate: 'onWarehouseActivate',
+    onActivated: 'onWarehouseActivated',
+
+    onMarkPrimary: 'onWarehouseMarkPrimary',
+    onMarkedPrimary: 'onWarehouseMarkedPrimary',
+  },
+
+  warehouseTransfer: {
+    onCreate: 'onWarehouseTransferCreate',
+    onCreated: 'onWarehouseTransferCreated',
+
+    onEdit: 'onWarehouseTransferEdit',
+    onEdited: 'onWarehouseTransferEdited',
+
+    onDelete: 'onWarehouseTransferDelete',
+    onDeleted: 'onWarehouseTransferDeleted',
+
+    onInitiate: 'onWarehouseTransferInitiate',
+    onInitiated: 'onWarehouseTransferInitated',
+
+    onTransfer: 'onWarehouseTransferInitiate',
+    onTransferred: 'onWarehouseTransferTransferred',
+  },
+
+  /**
+   * Branches.
+   */
+  branch: {
+    onActivate: 'onBranchActivate',
+    onActivated: 'onBranchActivated',
+
+    onMarkPrimary: 'onBranchMarkPrimary',
+    onMarkedPrimary: 'onBranchMarkedPrimary',
+  },
+
+  /**
+   * Projects.
+   */
+  project: {
+    onCreate: 'onProjectCreate',
+    onCreating: 'onProjectCreating',
+    onCreated: 'onProjectCreated',
+
+    onEdit: 'onEditProject',
+    onEditing: 'onEditingProject',
+    onEdited: 'onEditedProject',
+
+    onEditStatus: 'onEditStatusProject',
+    onEditingStatus: 'onEditingStatusProject',
+    onEditedStatus: 'onEditedStatusProject',
+
+    onDelete: 'onDeleteProject',
+    onDeleting: 'onDeletingProject',
+    onDeleted: 'onDeletedProject',
+  },
+
+  /**
+   * Project Tasks.
+   */
+  projectTask: {
+    onCreate: 'onProjectTaskCreate',
+    onCreating: 'onProjectTaskCreating',
+    onCreated: 'onProjectTaskCreated',
+
+    onEdit: 'onProjectTaskEdit',
+    onEditing: 'onProjectTaskEditing',
+    onEdited: 'onProjectTaskEdited',
+
+    onDelete: 'onProjectTaskDelete',
+    onDeleting: 'onProjectTaskDeleting',
+    onDeleted: 'onProjectTaskDeleted',
+  },
+
+  /**
+   * Project Times.
+   */
+  projectTime: {
+    onCreate: 'onProjectTimeCreate',
+    onCreating: 'onProjectTimeCreating',
+    onCreated: 'onProjectTimeCreated',
+
+    onEdit: 'onProjectTimeEdit',
+    onEditing: 'onProjectTimeEditing',
+    onEdited: 'onProjectTimeEdited',
+
+    onDelete: 'onProjectTimeDelete',
+    onDeleting: 'onProjectTimeDeleting',
+    onDeleted: 'onProjectTimeDeleted',
+  },
+};
diff --git a/packages/server/src/system/migrations/20190104195900_create_password_resets_table.js b/packages/server/src/system/migrations/20190104195900_create_password_resets_table.js
new file mode 100644
index 000000000..9337949c7
--- /dev/null
+++ b/packages/server/src/system/migrations/20190104195900_create_password_resets_table.js
@@ -0,0 +1,9 @@
+
+exports.up = (knex) => knex.schema.createTable('password_resets', (table) => {
+  table.increments();
+  table.string('email').index();
+  table.string('token').index();
+  table.timestamp('created_at');
+});
+
+exports.down = (knex) => knex.schema.dropTableIfExists('password_resets');
\ No newline at end of file
diff --git a/packages/server/src/system/migrations/20200420134631_create_tenants_table.js b/packages/server/src/system/migrations/20200420134631_create_tenants_table.js
new file mode 100644
index 000000000..189afa328
--- /dev/null
+++ b/packages/server/src/system/migrations/20200420134631_create_tenants_table.js
@@ -0,0 +1,22 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('tenants', (table) => {
+    table.bigIncrements();
+    table.string('organization_id').index();
+
+    table.dateTime('under_maintenance_since').nullable();
+    table.dateTime('initialized_at').nullable();
+    table.dateTime('seeded_at').nullable();
+    table.dateTime('built_at').nullable();
+    table.string('build_job_id');
+
+    table.integer('database_batch');
+    table.string('upgrade_job_id');
+
+    table.timestamps();
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('tenants');
+};
diff --git a/packages/server/src/system/migrations/20200420134633_create_users_table.js b/packages/server/src/system/migrations/20200420134633_create_users_table.js
new file mode 100644
index 000000000..0366df1b1
--- /dev/null
+++ b/packages/server/src/system/migrations/20200420134633_create_users_table.js
@@ -0,0 +1,26 @@
+exports.up = (knex) => {
+  return knex.schema.createTable('users', (table) => {
+    table.increments();
+    table.string('first_name');
+    table.string('last_name');
+    table.string('email').index();
+    table.string('phone_number').index();
+    table.string('password');
+    table.boolean('active').index();
+    table.string('language');
+    table
+      .bigInteger('tenant_id')
+      .unsigned()
+      .index()
+      .references('id')
+      .inTable('tenants');
+    table.dateTime('invite_accepted_at').index();
+    table.dateTime('last_login_at').index();
+    table.dateTime('deleted_at').index();
+    table.timestamps();
+  });
+};
+
+exports.down = (knex) => {
+  return knex.schema.dropTableIfExists('users');
+};
diff --git a/packages/server/src/system/migrations/20200422225247_create_user_invites_table.js b/packages/server/src/system/migrations/20200422225247_create_user_invites_table.js
new file mode 100644
index 000000000..42028ccc7
--- /dev/null
+++ b/packages/server/src/system/migrations/20200422225247_create_user_invites_table.js
@@ -0,0 +1,15 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('user_invites', (table) => {
+    table.increments();
+    table.string('email').index();
+    table.string('token').unique().index();
+    table.bigInteger('tenant_id').unsigned().index().references('id').inTable('tenants');
+    table.integer('user_id').unsigned().index().references('id').inTable('users');
+    table.datetime('created_at');
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('user_invites');
+};
diff --git a/packages/server/src/system/migrations/20200527091642_create_subscriptions_plans_table.js b/packages/server/src/system/migrations/20200527091642_create_subscriptions_plans_table.js
new file mode 100644
index 000000000..09d890648
--- /dev/null
+++ b/packages/server/src/system/migrations/20200527091642_create_subscriptions_plans_table.js
@@ -0,0 +1,22 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('subscriptions_plans', table => {
+    table.increments();
+
+    table.string('name');
+    table.string('description');
+    table.decimal('price');
+    table.string('currency', 3);
+
+    table.integer('trial_period');
+    table.string('trial_interval');
+    
+    table.integer('invoice_period');
+    table.string('invoice_interval');
+    table.timestamps();
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('subscriptions_plans')
+};
diff --git a/packages/server/src/system/migrations/20200823234134_create_plans_table.js b/packages/server/src/system/migrations/20200823234134_create_plans_table.js
new file mode 100644
index 000000000..2fc61a43a
--- /dev/null
+++ b/packages/server/src/system/migrations/20200823234134_create_plans_table.js
@@ -0,0 +1,30 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('subscription_plans', table => {
+    table.increments();
+    table.string('slug');
+    table.string('name');
+    table.string('desc');
+    table.boolean('active');
+
+    table.decimal('price').unsigned();
+    table.string('currency', 3);
+
+    table.decimal('trial_period').nullable();
+    table.string('trial_interval').nullable();
+
+    table.decimal('invoice_period').nullable();
+    table.string('invoice_interval').nullable();
+
+    table.integer('index').unsigned();
+    table.timestamps();
+  }).then(() => {
+    return knex.seed.run({
+      specific: 'seed_subscriptions_plans.js',
+    });
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('subscription_plans')
+};
diff --git a/packages/server/src/system/migrations/20200823234434_create_subscription_plan_feature.js b/packages/server/src/system/migrations/20200823234434_create_subscription_plan_feature.js
new file mode 100644
index 000000000..43fea2798
--- /dev/null
+++ b/packages/server/src/system/migrations/20200823234434_create_subscription_plan_feature.js
@@ -0,0 +1,15 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('subscription_plan_features', table => {
+    table.increments();
+    table.integer('plan_id').unsigned().index().references('id').inTable('subscription_plans');
+    table.string('slug');
+    table.string('name');
+    table.string('description');
+    table.timestamps();
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('subscription_plan_features');
+};
diff --git a/packages/server/src/system/migrations/20200823234636_create_subscription_plan_subscription.js b/packages/server/src/system/migrations/20200823234636_create_subscription_plan_subscription.js
new file mode 100644
index 000000000..267be4614
--- /dev/null
+++ b/packages/server/src/system/migrations/20200823234636_create_subscription_plan_subscription.js
@@ -0,0 +1,22 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('subscription_plan_subscriptions', table => {
+    table.increments('id');
+    table.string('slug');
+
+    table.integer('plan_id').unsigned().index().references('id').inTable('subscription_plans');
+    table.bigInteger('tenant_id').unsigned().index().references('id').inTable('tenants');
+
+    table.dateTime('starts_at').nullable();
+    table.dateTime('ends_at').nullable();
+
+    table.dateTime('cancels_at').nullable();
+    table.dateTime('canceled_at').nullable();
+
+    table.timestamps();
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('subscription_plan_subscriptions');
+};
diff --git a/packages/server/src/system/migrations/20200823235339_create_subscription_licenses_table.js b/packages/server/src/system/migrations/20200823235339_create_subscription_licenses_table.js
new file mode 100644
index 000000000..6babd6f03
--- /dev/null
+++ b/packages/server/src/system/migrations/20200823235339_create_subscription_licenses_table.js
@@ -0,0 +1,22 @@
+
+exports.up = function(knex) {
+  return knex.schema.createTable('subscription_licenses', (table) => {
+    table.increments();
+
+    table.string('license_code').unique().index();
+    table.integer('plan_id').unsigned().index().references('id').inTable('subscription_plans');
+
+    table.integer('license_period').unsigned();
+    table.string('period_interval');
+
+    table.dateTime('sent_at').index();
+    table.dateTime('disabled_at').index();
+    table.dateTime('used_at').index();
+
+    table.timestamps();
+  })
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('subscription_licenses');
+};
diff --git a/packages/server/src/system/migrations/20200823235340_create_tenants_metadata_table.js b/packages/server/src/system/migrations/20200823235340_create_tenants_metadata_table.js
new file mode 100644
index 000000000..c8f765b6a
--- /dev/null
+++ b/packages/server/src/system/migrations/20200823235340_create_tenants_metadata_table.js
@@ -0,0 +1,22 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('tenants_metadata', (table) => {
+    table.bigIncrements();
+    table.integer('tenant_id').unsigned();
+
+    table.string('name');
+    table.string('industry');
+    table.string('location');
+
+    table.string('base_currency');
+    table.string('language');
+
+    table.string('timezone');
+    table.string('date_format');
+
+    table.string('fiscal_year');
+  });
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTableIfExists('tenants_metadata');
+};
diff --git a/packages/server/src/system/models/Invite.ts b/packages/server/src/system/models/Invite.ts
new file mode 100644
index 000000000..5fa9e0948
--- /dev/null
+++ b/packages/server/src/system/models/Invite.ts
@@ -0,0 +1,30 @@
+import SystemModel from '@/system/models/SystemModel';
+import moment from 'moment';
+
+export default class UserInvite extends SystemModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'user_invites';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt'];
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      notExpired(query) {
+        const comp = moment().subtract(24, 'hours').toMySqlDateTime();
+        query.where('created_at', '>=', comp);
+      }
+    }
+  }
+}
diff --git a/packages/server/src/system/models/PasswordReset.ts b/packages/server/src/system/models/PasswordReset.ts
new file mode 100644
index 000000000..b72b0aeef
--- /dev/null
+++ b/packages/server/src/system/models/PasswordReset.ts
@@ -0,0 +1,17 @@
+import SystemModel from '@/system/models/SystemModel';
+
+export default class PasswordResets extends SystemModel {
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'password_resets';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt'];
+  }
+}
diff --git a/packages/server/src/system/models/Subscriptions/License.ts b/packages/server/src/system/models/Subscriptions/License.ts
new file mode 100644
index 000000000..97bbc87a7
--- /dev/null
+++ b/packages/server/src/system/models/Subscriptions/License.ts
@@ -0,0 +1,129 @@
+import { Model, mixin } from 'objection';
+import moment from 'moment';
+import SystemModel from '@/system/models/SystemModel';
+
+export default class License extends SystemModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'subscription_licenses';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      // Filters active licenses.
+      filterActiveLicense(query) {
+        query.where('disabled_at', null);
+        query.where('used_at', null);
+      },
+
+      // Find license by its code or id.
+      findByCodeOrId(query, id, code) {
+        if (id) {
+          query.where('id', id);
+        }
+        if (code) {
+          query.where('license_code', code);
+        }
+      },
+
+      // Filters licenses list.
+      filter(builder, licensesFilter) {
+        if (licensesFilter.active) {
+          builder.modify('filterActiveLicense');
+        }
+        if (licensesFilter.disabled) {
+          builder.whereNot('disabled_at', null);
+        }
+        if (licensesFilter.used) {
+          builder.whereNot('used_at', null);
+        }
+        if (licensesFilter.sent) {
+          builder.whereNot('sent_at', null);
+        }
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Plan = require('system/models/Subscriptions/Plan');
+
+    return {
+      plan: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Plan.default,
+        join: {
+          from: 'subscription_licenses.planId',
+          to: 'subscriptions_plans.id',
+        },
+      },
+    };
+  }
+
+  /**
+   * Deletes the given license code from the storage.
+   * @param {string} licenseCode
+   * @return {Promise}
+   */
+  static deleteLicense(licenseCode, viaAttribute = 'license_code') {
+    return this.query().where(viaAttribute, licenseCode).delete();
+  }
+
+  /**
+   * Marks the given license code as disabled on the storage.
+   * @param {string} licenseCode
+   * @return {Promise}
+   */
+  static markLicenseAsDisabled(licenseCode, viaAttribute = 'license_code') {
+    return this.query().where(viaAttribute, licenseCode).patch({
+      disabled_at: moment().toMySqlDateTime(),
+    });
+  }
+
+  /**
+   * Marks the given license code as sent on the storage.
+   * @param {string} licenseCode
+   */
+  static markLicenseAsSent(licenseCode, viaAttribute = 'license_code') {
+    return this.query().where(viaAttribute, licenseCode).patch({
+      sent_at: moment().toMySqlDateTime(),
+    });
+  }
+
+  /**
+   * Marks the given license code as used on the storage.
+   * @param {string} licenseCode
+   * @return {Promise}
+   */
+  static markLicenseAsUsed(licenseCode, viaAttribute = 'license_code') {
+    return this.query().where(viaAttribute, licenseCode).patch({
+      used_at: moment().toMySqlDateTime(),
+    });
+  }
+
+  /**
+   *
+   * @param {IIPlan} plan
+   * @return {boolean}
+   */
+  isEqualPlanPeriod(plan) {
+    return (
+      this.invoicePeriod === plan.invoiceInterval &&
+      license.licensePeriod === license.periodInterval
+    );
+  }
+}
diff --git a/packages/server/src/system/models/Subscriptions/Plan.ts b/packages/server/src/system/models/Subscriptions/Plan.ts
new file mode 100644
index 000000000..2b3f6b057
--- /dev/null
+++ b/packages/server/src/system/models/Subscriptions/Plan.ts
@@ -0,0 +1,82 @@
+import { Model, mixin } from 'objection';
+import SystemModel from '@/system/models/SystemModel';
+import { PlanSubscription } from '..';
+
+export default class Plan extends mixin(SystemModel) {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'subscription_plans';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Defined virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['isFree', 'hasTrial'];
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      getFeatureBySlug(builder, featureSlug) {
+        builder.where('slug', featureSlug);
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const PlanSubscription = require('system/models/Subscriptions/PlanSubscription');
+
+    return {
+      /**
+       * The plan may have many subscriptions.
+       */
+      subscriptions: {
+        relation: Model.HasManyRelation,
+        modelClass: PlanSubscription.default,
+        join: {
+          from: 'subscription_plans.id',
+          to: 'subscription_plan_subscriptions.planId',
+        },
+      }
+    };
+  }
+
+  /**
+   * Check if plan is free.
+   * @return {boolean}
+   */
+  isFree() {
+    return this.price <= 0;
+  }
+
+  /**
+   * Check if plan is paid.
+   * @return {boolean}
+   */
+  isPaid() {
+    return !this.isFree();
+  }
+
+  /**
+   * Check if plan has trial.
+   * @return {boolean}
+   */
+  hasTrial() {
+    return this.trialPeriod && this.trialInterval;
+  }
+}
diff --git a/packages/server/src/system/models/Subscriptions/PlanFeature.ts b/packages/server/src/system/models/Subscriptions/PlanFeature.ts
new file mode 100644
index 000000000..178fe818e
--- /dev/null
+++ b/packages/server/src/system/models/Subscriptions/PlanFeature.ts
@@ -0,0 +1,36 @@
+import { Model, mixin } from 'objection';
+import SystemModel from '@/system/models/SystemModel';
+
+export default class PlanFeature extends mixin(SystemModel) {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'subscriptions.plan_features';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  static get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Plan = require('system/models/Subscriptions/Plan');
+
+    return {
+      plan: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Plan.default,
+        join: {
+          from: 'subscriptions.plan_features.planId',
+          to: 'subscriptions.plans.id',
+        },
+      },
+    };
+  }
+}
diff --git a/packages/server/src/system/models/Subscriptions/PlanSubscription.ts b/packages/server/src/system/models/Subscriptions/PlanSubscription.ts
new file mode 100644
index 000000000..d77ee6418
--- /dev/null
+++ b/packages/server/src/system/models/Subscriptions/PlanSubscription.ts
@@ -0,0 +1,164 @@
+import { Model, mixin } from 'objection';
+import SystemModel from '@/system/models/SystemModel';
+import moment from 'moment';
+import SubscriptionPeriod from '@/services/Subscription/SubscriptionPeriod';
+
+export default class PlanSubscription extends mixin(SystemModel) {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'subscription_plan_subscriptions';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Defined virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['active', 'inactive', 'ended', 'onTrial'];
+  }
+
+  /**
+   * Modifiers queries.
+   */
+  static get modifiers() {
+    return {
+      activeSubscriptions(builder) {
+        const dateFormat = 'YYYY-MM-DD HH:mm:ss';
+        const now = moment().format(dateFormat);
+
+        builder.where('ends_at', '>', now);
+        builder.where('trial_ends_at', '>', now);
+      },
+
+      inactiveSubscriptions() {
+        builder.modify('endedTrial');
+        builder.modify('endedPeriod');
+      },
+
+      subscriptionBySlug(builder, subscriptionSlug) {
+        builder.where('slug', subscriptionSlug);
+      },
+
+      endedTrial(builder) {
+        const dateFormat = 'YYYY-MM-DD HH:mm:ss';
+        const endDate = moment().format(dateFormat);
+
+        builder.where('ends_at', '<=', endDate);
+      },
+
+      endedPeriod(builder) {
+        const dateFormat = 'YYYY-MM-DD HH:mm:ss';
+        const endDate = moment().format(dateFormat);
+
+        builder.where('trial_ends_at', '<=', endDate);
+      },
+    };
+  }
+
+  /**
+   * Relations mappings.
+   */
+  static get relationMappings() {
+    const Tenant = require('system/models/Tenant');
+    const Plan = require('system/models/Subscriptions/Plan');
+
+    return {
+      /**
+       * Plan subscription belongs to tenant.
+       */
+      tenant: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Tenant.default,
+        join: {
+          from: 'subscription_plan_subscriptions.tenantId',
+          to: 'tenants.id',
+        },
+      },
+
+      /**
+       * Plan description belongs to plan.
+       */
+      plan: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Plan.default,
+        join: {
+          from: 'subscription_plan_subscriptions.planId',
+          to: 'subscription_plans.id',
+        },
+      },
+    };
+  }
+
+  /**
+   * Check if subscription is active.
+   * @return {Boolean}
+   */
+  active() {
+    return !this.ended() || this.onTrial();
+  }
+
+  /**
+   * Check if subscription is inactive.
+   * @return {Boolean}
+   */
+  inactive() {
+    return !this.active();
+  }
+
+  /**
+   * Check if subscription period has ended.
+   * @return {Boolean}
+   */
+  ended() {
+    return this.endsAt ? moment().isAfter(this.endsAt) : false;
+  }
+
+  /**
+   * Check if subscription is currently on trial.
+   * @return {Boolean}
+   */
+  onTrial() {
+    return this.trailEndsAt ? moment().isAfter(this.trailEndsAt) : false;
+  }
+
+  /**
+   * Set new period from the given details.
+   * @param {string} invoiceInterval
+   * @param {number} invoicePeriod
+   * @param {string} start
+   *
+   * @return {Object}
+   */
+  static setNewPeriod(invoiceInterval, invoicePeriod, start) {
+    const period = new SubscriptionPeriod(
+      invoiceInterval,
+      invoicePeriod,
+      start,
+    );
+
+    const startsAt = period.getStartDate();
+    const endsAt = period.getEndDate();
+
+    return { startsAt, endsAt };
+  }
+
+  /**
+   * Renews subscription period.
+   * @Promise
+   */
+  renew(invoiceInterval, invoicePeriod) {
+    const { startsAt, endsAt } = PlanSubscription.setNewPeriod(
+      invoiceInterval,
+      invoicePeriod,
+    );
+    return this.$query().update({ startsAt, endsAt });
+  }
+}
diff --git a/packages/server/src/system/models/SystemModel.ts b/packages/server/src/system/models/SystemModel.ts
new file mode 100644
index 000000000..cba8eea01
--- /dev/null
+++ b/packages/server/src/system/models/SystemModel.ts
@@ -0,0 +1,19 @@
+import { Container } from 'typedi';
+import BaseModel from 'models/Model';
+
+export default class SystemModel extends BaseModel{
+  /**
+   * Loging all system database queries.
+   * @param  {...any} args 
+   */
+  static query(...args) {
+    const Logger = Container.get('logger');
+    return super.query(...args).onBuildKnex(knexQueryBuilder => {
+      knexQueryBuilder.on('query', queryData => {
+        Logger.info(`[query][system] ${queryData.sql}`, {
+          bindings: queryData.bindings,
+        });
+      });
+    });
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/system/models/SystemUser.ts b/packages/server/src/system/models/SystemUser.ts
new file mode 100644
index 000000000..a341ccedf
--- /dev/null
+++ b/packages/server/src/system/models/SystemUser.ts
@@ -0,0 +1,85 @@
+import { Model } from 'objection';
+import bcrypt from 'bcryptjs';
+import SystemModel from '@/system/models/SystemModel';
+import SoftDeleteQueryBuilder from '@/collection/SoftDeleteQueryBuilder';
+
+export default class SystemUser extends SystemModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'users';
+  }
+
+  /**
+   * Soft delete query builder.
+   */
+  static get QueryBuilder() {
+    return SoftDeleteQueryBuilder;
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['fullName', 'isDeleted', 'isInviteAccepted'];
+  }
+
+  /**
+   * 
+   */
+  get isDeleted() {
+    return !!this.deletedAt;
+  }
+
+  /**
+   * 
+   */
+  get isInviteAccepted() {
+    return !!this.inviteAcceptedAt;
+  }
+
+  /**
+   * Full name attribute.
+   */
+  get fullName() {
+    return (this.firstName + ' ' + this.lastName).trim();
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Tenant = require('system/models/Tenant');
+
+    return {
+      /**
+       * System user may belongs to tenant model.
+       */
+      tenant: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Tenant.default,
+        join: {
+          from: 'users.tenantId',
+          to: 'tenants.id',
+        },
+      },
+    };
+  }
+
+  /**
+   * Verify the password of the user.
+   * @param  {String} password - The given password.
+   * @return {Boolean}
+   */
+  verifyPassword(password) {
+    return bcrypt.compareSync(password, this.password);
+  }
+}
diff --git a/packages/server/src/system/models/Tenant.ts b/packages/server/src/system/models/Tenant.ts
new file mode 100644
index 000000000..82cb0d112
--- /dev/null
+++ b/packages/server/src/system/models/Tenant.ts
@@ -0,0 +1,226 @@
+import moment from 'moment';
+import { Model } from 'objection';
+import uniqid from 'uniqid';
+import SubscriptionPeriod from '@/services/Subscription/SubscriptionPeriod';
+import BaseModel from 'models/Model';
+import TenantMetadata from './TenantMetadata';
+import PlanSubscription from './Subscriptions/PlanSubscription';
+
+export default class Tenant extends BaseModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'tenants';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['isReady', 'isBuildRunning', 'isUpgradeRunning'];
+  }
+
+  /**
+   * Tenant is ready.
+   */
+  get isReady() {
+    return !!(this.initializedAt && this.seededAt);
+  }
+
+  /**
+   * Detarimes the tenant whether is build currently running.
+   */
+  get isBuildRunning() {
+    return !!this.buildJobId;
+  }
+
+  /**
+   * Detarmines the tenant whether is upgrade currently running.
+   */
+  get isUpgradeRunning() {
+    return !!this.upgradeJobId;
+  }
+
+  /**
+   * Query modifiers.
+   */
+  static modifiers() {
+    return {
+      subscriptions(builder) {
+        builder.withGraphFetched('subscriptions');
+      },
+    };
+  }
+
+  /**
+   * Relations mappings.
+   */
+  static get relationMappings() {
+    const PlanSubscription = require('./Subscriptions/PlanSubscription');
+    const TenantMetadata = require('./TenantMetadata');
+
+    return {
+      subscriptions: {
+        relation: Model.HasManyRelation,
+        modelClass: PlanSubscription.default,
+        join: {
+          from: 'tenants.id',
+          to: 'subscription_plan_subscriptions.tenantId',
+        },
+      },
+      metadata: {
+        relation: Model.HasOneRelation,
+        modelClass: TenantMetadata.default,
+        join: {
+          from: 'tenants.id',
+          to: 'tenants_metadata.tenantId',
+        },
+      },
+    };
+  }
+
+  /**
+   * Retrieve the subscribed plans ids.
+   * @return {number[]}
+   */
+  async subscribedPlansIds() {
+    const { subscriptions } = this;
+    return chain(subscriptions).map('planId').unq();
+  }
+
+  /**
+   * 
+   * @param {*} planId 
+   * @param {*} invoiceInterval 
+   * @param {*} invoicePeriod 
+   * @param {*} subscriptionSlug 
+   * @returns 
+   */
+  newSubscription(planId, invoiceInterval, invoicePeriod, subscriptionSlug) {
+    return Tenant.newSubscription(
+      this.id,
+      planId,
+      invoiceInterval,
+      invoicePeriod,
+      subscriptionSlug,
+    );
+  }
+
+  /**
+   * Records a new subscription for the associated tenant.
+   */
+  static newSubscription(
+    tenantId,
+    planId,
+    invoiceInterval,
+    invoicePeriod,
+    subscriptionSlug
+  ) {
+    const period = new SubscriptionPeriod(invoiceInterval, invoicePeriod);
+
+    return PlanSubscription.query().insert({
+      tenantId,
+      slug: subscriptionSlug,
+      planId,
+      startsAt: period.getStartDate(),
+      endsAt: period.getEndDate(),
+    });
+  }
+
+  /**
+   * Creates a new tenant with random organization id.
+   */
+  static createWithUniqueOrgId(uniqId) {
+    const organizationId = uniqid() || uniqId;
+    return this.query().insert({ organizationId });
+  }
+
+  /**
+   * Mark as seeded.
+   * @param {number} tenantId
+   */
+  static markAsSeeded(tenantId) {
+    const seededAt = moment().toMySqlDateTime();
+    return this.query().update({ seededAt }).where({ id: tenantId });
+  }
+
+  /**
+   * Mark the the given organization as initialized.
+   * @param {string} organizationId
+   */
+  static markAsInitialized(tenantId) {
+    const initializedAt = moment().toMySqlDateTime();
+    return this.query().update({ initializedAt }).where({ id: tenantId });
+  }
+
+  /**
+   * Marks the given tenant as built.
+   */
+  static markAsBuilt(tenantId) {
+    const builtAt = moment().toMySqlDateTime();
+    return this.query().update({ builtAt }).where({ id: tenantId });
+  }
+
+  /**
+   * Marks the given tenant as built.
+   */
+  static markAsBuilding(tenantId, buildJobId) {
+    return this.query().update({ buildJobId }).where({ id: tenantId });
+  }
+
+  /**
+   * Marks the given tenant as built.
+   */
+  static markAsBuildCompleted(tenantId) {
+    return this.query().update({ buildJobId: null }).where({ id: tenantId });
+  }
+
+  /**
+   * Marks the given tenant as upgrading.
+   * @param {number} tenantId 
+   * @param {string} upgradeJobId 
+   * @returns 
+   */
+  static markAsUpgrading(tenantId, upgradeJobId) {
+    return this.query().update({ upgradeJobId }).where({ id: tenantId });
+  }
+
+  /**
+   * Markes the given tenant as upgraded.
+   * @param {number} tenantId 
+   * @returns 
+   */
+  static markAsUpgraded(tenantId) {
+    return this.query().update({ upgradeJobId: null }).where({ id: tenantId });
+  }
+
+  /**
+   * Saves the metadata of the given tenant.
+   */
+  static async saveMetadata(tenantId, metadata) {
+    const foundMetadata = await TenantMetadata.query().findOne({ tenantId });
+    const updateOrInsert = foundMetadata ? 'update' : 'insert';
+
+    return TenantMetadata.query()
+      [updateOrInsert]({
+        tenantId,
+        ...metadata,
+      })
+      .where({ tenantId });
+  }
+
+  /**
+   * Saves the metadata of the tenant.
+   */
+  saveMetadata(metadata) {
+    return Tenant.saveMetadata(this.id, metadata);
+  }
+}
diff --git a/packages/server/src/system/models/TenantMetadata.ts b/packages/server/src/system/models/TenantMetadata.ts
new file mode 100644
index 000000000..4664cfd6d
--- /dev/null
+++ b/packages/server/src/system/models/TenantMetadata.ts
@@ -0,0 +1,10 @@
+import BaseModel from 'models/Model';
+
+export default class TenantMetadata extends BaseModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'tenants_metadata';
+  }
+}
diff --git a/packages/server/src/system/models/index.ts b/packages/server/src/system/models/index.ts
new file mode 100644
index 000000000..6e5ee2d80
--- /dev/null
+++ b/packages/server/src/system/models/index.ts
@@ -0,0 +1,22 @@
+
+import Plan from './Subscriptions/Plan';
+import PlanFeature from './Subscriptions/PlanFeature';
+import PlanSubscription from './Subscriptions/PlanSubscription';
+import License from './Subscriptions/License';
+import Tenant from './Tenant';
+import TenantMetadata from './TenantMetadata';
+import SystemUser from './SystemUser';
+import PasswordReset from './PasswordReset';
+import Invite from './Invite';
+
+export {
+  Plan,
+  PlanFeature,
+  PlanSubscription,
+  License,
+  Tenant,
+  TenantMetadata,
+  SystemUser,
+  PasswordReset,
+  Invite,
+}
\ No newline at end of file
diff --git a/packages/server/src/system/repositories/SubscriptionRepository.ts b/packages/server/src/system/repositories/SubscriptionRepository.ts
new file mode 100644
index 000000000..44962b0b8
--- /dev/null
+++ b/packages/server/src/system/repositories/SubscriptionRepository.ts
@@ -0,0 +1,26 @@
+import SystemRepository from '@/system/repositories/SystemRepository';
+import { PlanSubscription } from '@/system/models';
+
+export default class SubscriptionRepository extends SystemRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return PlanSubscription.bindKnex(this.knex);
+  }
+
+  /**
+   * Retrieve subscription from a given slug in specific tenant.
+   * @param {string} slug
+   * @param {number} tenantId
+   */
+  getBySlugInTenant(slug: string, tenantId: number) {
+    const cacheKey = this.getCacheKey('getBySlugInTenant', slug, tenantId);
+
+    return this.cache.get(cacheKey, () => {
+      return PlanSubscription.query()
+        .findOne('slug', slug)
+        .where('tenant_id', tenantId);
+    });
+  }
+}
diff --git a/packages/server/src/system/repositories/SystemRepository.ts b/packages/server/src/system/repositories/SystemRepository.ts
new file mode 100644
index 000000000..e44377130
--- /dev/null
+++ b/packages/server/src/system/repositories/SystemRepository.ts
@@ -0,0 +1,5 @@
+import CachableRepository from "repositories/CachableRepository";
+
+export default class SystemRepository extends CachableRepository {
+
+}
\ No newline at end of file
diff --git a/packages/server/src/system/repositories/SystemUserRepository.ts b/packages/server/src/system/repositories/SystemUserRepository.ts
new file mode 100644
index 000000000..0e4b1ca75
--- /dev/null
+++ b/packages/server/src/system/repositories/SystemUserRepository.ts
@@ -0,0 +1,101 @@
+import moment from 'moment';
+import SystemRepository from '@/system/repositories/SystemRepository';
+import { SystemUser } from '@/system/models';
+import { ISystemUser } from '@/interfaces';
+
+export default class SystemUserRepository extends SystemRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return SystemUser.bindKnex(this.knex);
+  }
+
+  /**
+   * Finds system user by crediential.
+   * @param  {string} crediential - Phone number or email.
+   * @return {ISystemUser}
+   * @return {Promise<ISystemUser>}
+   */
+  findByCrediential(crediential: string): Promise<ISystemUser> {
+    const cacheKey = this.getCacheKey('findByCrediential', crediential);
+
+    return this.cache.get(cacheKey, () => {
+      return this.model.query()
+        .findOne('email', crediential)
+        .orWhere('phone_number', crediential);
+    });
+  }
+
+  /**
+   * Retrieve user by id and tenant id.
+   * @param  {number} userId - User id.
+   * @param  {number} tenantId - Tenant id.
+   * @return {Promise<ISystemUser>}
+   */
+  findOneByIdAndTenant(userId: number, tenantId: number): Promise<ISystemUser> {
+    const cacheKey = this.getCacheKey('findOneByIdAndTenant', userId, tenantId);
+
+    return this.cache.get(cacheKey, () => {
+      return this.model.query()
+        .findOne({ id: userId, tenant_id: tenantId });
+    });
+  }
+
+  /**
+   * Retrieve system user details by the given email.
+   * @param  {string} email - Email
+   * @return {Promise<ISystemUser>}
+   */
+  findOneByEmail(email: string): Promise<ISystemUser> {
+    const cacheKey = this.getCacheKey('findOneByEmail', email);
+
+    return this.cache.get(cacheKey, () => {
+      return this.model.query().findOne('email', email);
+    });
+  }
+
+  /**
+   * Retrieve user by phone number.
+   * @param {string} phoneNumber - Phone number
+   * @return {Promise<ISystemUser>}
+   */
+  findOneByPhoneNumber(phoneNumber: string): Promise<ISystemUser> {
+    const cacheKey = this.getCacheKey('findOneByPhoneNumber', phoneNumber);
+
+    return this.cache.get(cacheKey, () => {
+      return this.model.query()
+        .findOne('phoneNumber', phoneNumber);
+    });
+  }
+
+  /**
+   * Patches the last login date to the given system user.
+   * @param  {number} userId
+   * @return {Promise<void>}
+   */
+  patchLastLoginAt(userId: number): Promise<void> {
+    return super.update(
+      { last_login_at: moment().toMySqlDateTime() },
+      { id: userId }
+    );
+  }
+
+  /**
+   * Activate user by the given id.
+   * @param  {number} userId - User id.
+   * @return {Promise<void>}
+   */
+  activateById(userId: number): Promise<void> {
+    return super.update({ active: 1 }, { id: userId });
+  }
+
+  /**
+   * Inactivate user by the given id.
+   * @param  {number} userId - User id.
+   * @return {Promise<void>}
+   */
+  inactivateById(userId: number): Promise<void> {
+    return super.update({ active: 0 }, { id: userId });
+  }
+}
diff --git a/packages/server/src/system/repositories/TenantRepository.ts b/packages/server/src/system/repositories/TenantRepository.ts
new file mode 100644
index 000000000..b487a62ac
--- /dev/null
+++ b/packages/server/src/system/repositories/TenantRepository.ts
@@ -0,0 +1,43 @@
+import moment from "moment";
+import uniqid from 'uniqid';
+import SystemRepository from "./SystemRepository";
+import { Tenant } from "@/system/models";
+import { ITenant } from '@/interfaces';
+
+export default class TenantRepository extends SystemRepository {
+  /**
+   * Gets the repository's model.
+   */
+  get model() {
+    return Tenant.bindKnex(this.knex);
+  }
+
+  /**
+   * Creates a new tenant with random organization id.
+   * @return {ITenant}
+   */
+  createWithUniqueOrgId(uniqId?: string): Promise<ITenant>{
+    const organizationId = uniqid() || uniqId;
+    return super.create({ organizationId });
+  }
+
+  /**
+   * Mark as seeded.
+   * @param {number} tenantId 
+   */
+  markAsSeeded(tenantId: number) {
+    return super.update({
+      seededAt: moment().toMySqlDateTime(),
+    }, { id: tenantId })
+  }
+
+  /**
+   * Mark the the given organization as initialized.
+   * @param {string} organizationId 
+   */
+  markAsInitialized(tenantId: number) {
+    return super.update({
+      initializedAt: moment().toMySqlDateTime(),
+    }, { id: tenantId });
+  }
+}
\ No newline at end of file
diff --git a/packages/server/src/system/repositories/index.ts b/packages/server/src/system/repositories/index.ts
new file mode 100644
index 000000000..9fb001718
--- /dev/null
+++ b/packages/server/src/system/repositories/index.ts
@@ -0,0 +1,9 @@
+import SystemUserRepository from '@/system/repositories/SystemUserRepository';
+import SubscriptionRepository from '@/system/repositories/SubscriptionRepository';
+import TenantRepository from '@/system/repositories/TenantRepository';
+
+export {
+  SystemUserRepository,
+  SubscriptionRepository,
+  TenantRepository,
+};
\ No newline at end of file
diff --git a/packages/server/src/system/seeds/seed_subscriptions_plans.js b/packages/server/src/system/seeds/seed_subscriptions_plans.js
new file mode 100644
index 000000000..0e69b94db
--- /dev/null
+++ b/packages/server/src/system/seeds/seed_subscriptions_plans.js
@@ -0,0 +1,66 @@
+
+exports.seed = (knex) => {
+  // Deletes ALL existing entries
+  return knex('subscription_plans').del()
+    .then(() => {
+      // Inserts seed entries
+      return knex('subscription_plans').insert([
+        {
+          name: 'Essentials',
+          slug: 'essentials-monthly',
+          price: 100,
+          active: true,
+          currency: 'LYD',
+          trial_period: 7,
+          trial_interval: 'days',
+        },
+        {
+          name: 'Essentials',
+          slug: 'essentials-yearly',
+          price: 1200,
+          active: true,
+          currency: 'LYD',
+          trial_period: 12,
+          trial_interval: 'months',
+        },
+        {
+          name: 'Pro',
+          slug: 'pro-monthly',
+          price: 200,
+          active: true,
+          currency: 'LYD',
+          trial_period: 1,
+          trial_interval: 'months',
+        },
+        {
+          name: 'Pro',
+          slug: 'pro-yearly',
+          price: 500,
+          active: true,
+          currency: 'LYD',
+          invoice_period: 12,
+          invoice_interval: 'month',
+          index: 2,
+        },
+        {
+          name: 'Plus',
+          slug: 'plus-monthly',
+          price: 200,
+          active: true,
+          currency: 'LYD',
+          trial_period: 1,
+          trial_interval: 'months',
+        },
+        {
+          name: 'Plus',
+          slug: 'plus-yearly',
+          price: 500,
+          active: true,
+          currency: 'LYD',
+          invoice_period: 12,
+          invoice_interval: 'month',
+          index: 2,
+        },
+      ]);
+    });
+};
diff --git a/packages/server/src/utils/deepdash.ts b/packages/server/src/utils/deepdash.ts
new file mode 100644
index 000000000..5d4ef60df
--- /dev/null
+++ b/packages/server/src/utils/deepdash.ts
@@ -0,0 +1,106 @@
+import _ from 'lodash';
+import deepdash from 'deepdash';
+
+const {
+  condense,
+  condenseDeep,
+  eachDeep,
+  exists,
+  filterDeep,
+  findDeep,
+  findPathDeep,
+  findValueDeep,
+  forEachDeep,
+  index,
+  keysDeep,
+  mapDeep,
+  mapKeysDeep,
+  mapValuesDeep,
+  omitDeep,
+  pathMatches,
+  pathToString,
+  paths,
+  pickDeep,
+  reduceDeep,
+  someDeep,
+  iteratee,
+} = deepdash(_);
+
+const mapValuesDeepReverse = (nodes, callback, config?) => {
+  const clonedNodes = _.clone(nodes);
+  const nodesPaths = paths(nodes, config);
+  const reversedPaths = _.reverse(nodesPaths);
+
+  reversedPaths.forEach((pathStack: string[], i) => {
+    const node = _.get(clonedNodes, pathStack);
+    const pathString = pathToString(pathStack);
+    const children = _.get(
+      clonedNodes,
+      `${pathString}.${config.childrenPath}`,
+      []
+    );
+    const mappedNode = callback(node, children);
+
+    _.set(clonedNodes, pathString, {
+      ...mappedNode,
+      ...(!_.isEmpty(children) ? { children } : {}),
+    });
+  });
+  return clonedNodes;
+};
+
+const filterNodesDeep = (predicate, nodes) => {
+  return condense(
+    reduceDeep(
+      nodes,
+      (accumulator, value, key, parent, context) => {
+        const newValue = { ...value };
+
+        if (newValue.children) {
+          _.set(newValue, 'children', condense(value.children));
+        }
+        const isTrue = predicate(newValue, key, parent, context);
+
+        if (isTrue === true) {
+          _.set(accumulator, context.path, newValue);
+        } else if (isTrue === false) {
+          _.unset(accumulator, context.path);
+        }
+        return accumulator;
+      },
+      [],
+      {
+        childrenPath: 'children',
+        pathFormat: 'array',
+        callbackAfterIterate: true,
+      }
+    )
+  );
+};
+
+export {
+  iteratee,
+  condense,
+  condenseDeep,
+  eachDeep,
+  exists,
+  filterDeep,
+  findDeep,
+  findPathDeep,
+  findValueDeep,
+  forEachDeep,
+  index,
+  keysDeep,
+  mapDeep,
+  mapKeysDeep,
+  mapValuesDeep,
+  omitDeep,
+  pathMatches,
+  pathToString,
+  paths,
+  pickDeep,
+  reduceDeep,
+  someDeep,
+  mapValuesDeepReverse,
+  filterNodesDeep,
+};
diff --git a/packages/server/src/utils/formatMinutes.ts b/packages/server/src/utils/formatMinutes.ts
new file mode 100644
index 000000000..9fecf3dbe
--- /dev/null
+++ b/packages/server/src/utils/formatMinutes.ts
@@ -0,0 +1,11 @@
+
+export function formatMinutes(totalMinutes: number) {
+  const minutes = totalMinutes % 60;
+  const hours = Math.floor(totalMinutes / 60);
+
+  return `${padTo2Digits(hours)}:${padTo2Digits(minutes)}`;
+}
+
+export function padTo2Digits(num: number) {
+  return num.toString().padStart(2, '0');
+}
diff --git a/packages/server/src/utils/index.ts b/packages/server/src/utils/index.ts
new file mode 100644
index 000000000..9fa8649f8
--- /dev/null
+++ b/packages/server/src/utils/index.ts
@@ -0,0 +1,452 @@
+import bcrypt from 'bcryptjs';
+import moment from 'moment';
+import _ from 'lodash';
+import path from 'path';
+import * as R from 'ramda';
+
+import accounting from 'accounting';
+import pug from 'pug';
+import Currencies from 'js-money/lib/currency';
+import definedOptions from '@/data/options';
+
+export * from './table';
+
+const hashPassword = (password) =>
+  new Promise((resolve) => {
+    bcrypt.genSalt(10, (error, salt) => {
+      bcrypt.hash(password, salt, (err, hash) => {
+        resolve(hash);
+      });
+    });
+  });
+
+const origin = (request) => `${request.protocol}://${request.hostname}`;
+
+const dateRangeCollection = (
+  fromDate,
+  toDate,
+  addType = 'day',
+  increment = 1
+) => {
+  const collection = [];
+  const momentFromDate = moment(fromDate);
+  let dateFormat = '';
+
+  switch (addType) {
+    case 'day':
+    default:
+      dateFormat = 'YYYY-MM-DD';
+      break;
+    case 'month':
+    case 'quarter':
+      dateFormat = 'YYYY-MM';
+      break;
+    case 'year':
+      dateFormat = 'YYYY';
+      break;
+  }
+  for (
+    let i = momentFromDate;
+    i.isBefore(toDate, addType) || i.isSame(toDate, addType);
+    i.add(increment, `${addType}s`)
+  ) {
+    collection.push(i.endOf(addType).format(dateFormat));
+  }
+  return collection;
+};
+
+const dateRangeFromToCollection = (
+  fromDate,
+  toDate,
+  addType = 'day',
+  increment = 1
+) => {
+  const collection = [];
+  const momentFromDate = moment(fromDate);
+  const dateFormat = 'YYYY-MM-DD';
+
+  for (
+    let i = momentFromDate;
+    i.isBefore(toDate, addType) || i.isSame(toDate, addType);
+    i.add(increment, `${addType}s`)
+  ) {
+    collection.push({
+      fromDate: i.startOf(addType).format(dateFormat),
+      toDate: i.endOf(addType).format(dateFormat),
+    });
+  }
+  return collection;
+};
+
+const dateRangeFormat = (rangeType) => {
+  switch (rangeType) {
+    case 'year':
+      return 'YYYY';
+    case 'month':
+    case 'quarter':
+    default:
+      return 'YYYY-MM';
+  }
+};
+
+function mapKeysDeep(obj, cb, isRecursive) {
+  if (!obj && !isRecursive) {
+    return {};
+  }
+  if (!isRecursive) {
+    if (
+      typeof obj === 'string' ||
+      typeof obj === 'number' ||
+      typeof obj === 'boolean'
+    ) {
+      return {};
+    }
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => mapKeysDeep(item, cb, true));
+  }
+  if (!_.isPlainObject(obj)) {
+    return obj;
+  }
+  const result = _.mapKeys(obj, cb);
+  return _.mapValues(result, (value) => mapKeysDeep(value, cb, true));
+}
+
+const mapValuesDeep = (v, callback) =>
+  _.isObject(v)
+    ? _.mapValues(v, (v) => mapValuesDeep(v, callback))
+    : callback(v);
+
+const promiseSerial = (funcs) => {
+  return funcs.reduce(
+    (promise, func) =>
+      promise.then((result) =>
+        func().then(Array.prototype.concat.bind(result))
+      ),
+    Promise.resolve([])
+  );
+};
+
+const flatToNestedArray = (
+  data,
+  config = { id: 'id', parentId: 'parent_id' }
+) => {
+  const map = {};
+  const nestedArray = [];
+
+  data.forEach((item) => {
+    map[item[config.id]] = item;
+    map[item[config.id]].children = [];
+  });
+
+  data.forEach((item) => {
+    const parentItemId = item[config.parentId];
+
+    if (!item[config.parentId]) {
+      nestedArray.push(item);
+    }
+    if (parentItemId) {
+      map[parentItemId].children.push(item);
+    }
+  });
+  return nestedArray;
+};
+
+const itemsStartWith = (items, char) => {
+  return items.filter((item) => item.indexOf(char) === 0);
+};
+
+const getTotalDeep = (items, deepProp, totalProp) =>
+  items.reduce((acc, item) => {
+    const total = Array.isArray(item[deepProp])
+      ? getTotalDeep(item[deepProp], deepProp, totalProp)
+      : 0;
+    return _.sumBy(item, totalProp) + total + acc;
+  }, 0);
+
+function applyMixins(derivedCtor, baseCtors) {
+  baseCtors.forEach((baseCtor) => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+      Object.defineProperty(
+        derivedCtor.prototype,
+        name,
+        Object.getOwnPropertyDescriptor(baseCtor.prototype, name)
+      );
+    });
+  });
+}
+
+const formatDateFields = (inputDTO, fields, format = 'YYYY-MM-DD') => {
+  const _inputDTO = { ...inputDTO };
+
+  fields.forEach((field) => {
+    if (_inputDTO[field]) {
+      _inputDTO[field] = moment(_inputDTO[field]).format(format);
+    }
+  });
+  return _inputDTO;
+};
+
+const getDefinedOptions = () => {
+  const options = [];
+
+  Object.keys(definedOptions).forEach((groupKey) => {
+    const groupOptions = definedOptions[groupKey];
+    groupOptions.forEach((option) => {
+      options.push({ ...option, group: groupKey });
+    });
+  });
+  return options;
+};
+
+const getDefinedOption = (key, group) => {
+  return definedOptions?.[group]?.find((option) => option.key == key);
+};
+
+const isDefinedOptionConfigurable = (key, group) => {
+  const definedOption = getDefinedOption(key, group);
+  return definedOption?.config || false;
+};
+
+const entriesAmountDiff = (
+  newEntries,
+  oldEntries,
+  amountAttribute,
+  idAttribute
+) => {
+  const oldEntriesTable = _.chain(oldEntries)
+    .groupBy(idAttribute)
+    .mapValues((group) => _.sumBy(group, amountAttribute) || 0)
+    .value();
+
+  const newEntriesTable = _.chain(newEntries)
+    .groupBy(idAttribute)
+    .mapValues((group) => _.sumBy(group, amountAttribute) || 0)
+    .mergeWith(oldEntriesTable, (objValue, srcValue) => {
+      return _.isNumber(objValue) ? objValue - srcValue : srcValue * -1;
+    })
+    .value();
+
+  return _.chain(newEntriesTable)
+    .mapValues((value, key) => ({
+      [idAttribute]: key,
+      [amountAttribute]: value,
+    }))
+    .filter((entry) => entry[amountAttribute] != 0)
+    .values()
+    .value();
+};
+
+const convertEmptyStringToNull = (value) => {
+  return typeof value === 'string'
+    ? value.trim() === ''
+      ? null
+      : value
+    : value;
+};
+
+const getNegativeFormat = (formatName) => {
+  switch (formatName) {
+    case 'parentheses':
+      return '(%s%v)';
+    case 'mines':
+      return '-%s%v';
+  }
+};
+
+const getCurrencySign = (currencyCode) => {
+  return _.get(Currencies, `${currencyCode}.symbol`);
+};
+
+const formatNumber = (
+  balance,
+  {
+    precision = 2,
+    divideOn1000 = false,
+    excerptZero = false,
+    negativeFormat = 'mines',
+    thousand = ',',
+    decimal = '.',
+    zeroSign = '',
+    money = true,
+    currencyCode,
+    symbol = '',
+  }
+) => {
+  const formattedSymbol = getCurrencySign(currencyCode);
+  const negForamt = getNegativeFormat(negativeFormat);
+  const format = '%s%v';
+
+  let formattedBalance = parseFloat(balance);
+
+  if (divideOn1000) {
+    formattedBalance /= 1000;
+  }
+  return accounting.formatMoney(
+    formattedBalance,
+    money ? formattedSymbol : symbol ? symbol : '',
+    precision,
+    thousand,
+    decimal,
+    {
+      pos: format,
+      neg: negForamt,
+      zero: excerptZero ? zeroSign : format,
+    }
+  );
+};
+
+const isBlank = (value) => {
+  return (_.isEmpty(value) && !_.isNumber(value)) || _.isNaN(value);
+};
+
+function defaultToTransform(value, defaultOrTransformedValue, defaultValue) {
+  const _defaultValue =
+    typeof defaultValue === 'undefined'
+      ? defaultOrTransformedValue
+      : defaultValue;
+
+  const _transfromedValue =
+    typeof defaultValue === 'undefined' ? value : defaultOrTransformedValue;
+
+  return value == null || value !== value || value === ''
+    ? _defaultValue
+    : _transfromedValue;
+}
+
+const transformToMap = (objects, key) => {
+  const map = new Map();
+
+  objects.forEach((object) => {
+    map.set(object[key], object);
+  });
+  return map;
+};
+
+const transactionIncrement = (s) => s.replace(/([0-8]|\d?9+)?$/, (e) => ++e);
+
+const booleanValuesRepresentingTrue: string[] = ['true', '1'];
+const booleanValuesRepresentingFalse: string[] = ['false', '0'];
+
+const normalizeValue = (value: any): string =>
+  value.toString().trim().toLowerCase();
+
+const booleanValues: string[] = [
+  ...booleanValuesRepresentingTrue,
+  ...booleanValuesRepresentingFalse,
+].map((value) => normalizeValue(value));
+
+export const parseBoolean = <T>(value: any, defaultValue: T): T | boolean => {
+  const normalizedValue = normalizeValue(value);
+  if (booleanValues.indexOf(normalizedValue) === -1) {
+    return defaultValue;
+  }
+  return booleanValuesRepresentingTrue.indexOf(normalizedValue) !== -1;
+};
+
+var increment = (n) => {
+  return () => {
+    n += 1;
+    return n;
+  };
+};
+
+const transformToMapBy = (collection, key) => {
+  return new Map(Object.entries(_.groupBy(collection, key)));
+};
+
+const transformToMapKeyValue = (collection, key) => {
+  return new Map(collection.map((item) => [item[key], item]));
+};
+
+const accumSum = (data, callback) => {
+  return data.reduce((acc, _data) => {
+    const amount = callback(_data);
+    return acc + amount;
+  }, 0);
+};
+
+const mergeObjectsBykey = (object1, object2, key) => {
+  var merged = _.merge(_.keyBy(object1, key), _.keyBy(object2, key));
+  return _.values(merged);
+};
+
+function templateRender(filePath, options) {
+  const basePath = path.join(__dirname, '../../resources/views');
+  return pug.renderFile(`${basePath}/${filePath}.pug`, options);
+}
+
+/**
+ * All passed conditions should pass.
+ * @param condsPairFilters
+ * @returns
+ */
+export const allPassedConditionsPass = (condsPairFilters): Function => {
+  const filterCallbacks = condsPairFilters
+    .filter((cond) => cond[0])
+    .map((cond) => cond[1]);
+
+  return R.allPass(filterCallbacks);
+};
+
+export const runningAmount = (amount: number) => {
+  let runningBalance = amount;
+
+  return {
+    decrement: (decrement: number) => {
+      runningBalance -= decrement;
+    },
+    increment: (increment: number) => {
+      runningBalance += increment;
+    },
+    amount: () => runningBalance,
+  };
+};
+
+export const formatSmsMessage = (message, args) => {
+  let formattedMessage = message;
+
+  Object.keys(args).forEach((key) => {
+    const variable = `{${key}}`;
+    const value = _.defaultTo(args[key], '');
+
+    formattedMessage = formattedMessage.replace(variable, value);
+  });
+  return formattedMessage;
+};
+
+export const parseDate = (date: string) => {
+  return date ? moment(date).utcOffset(0).format('YYYY-MM-DD') : '';
+};
+
+export {
+  templateRender,
+  accumSum,
+  increment,
+  hashPassword,
+  origin,
+  dateRangeCollection,
+  dateRangeFormat,
+  mapValuesDeep,
+  mapKeysDeep,
+  promiseSerial,
+  flatToNestedArray,
+  itemsStartWith,
+  getTotalDeep,
+  applyMixins,
+  formatDateFields,
+  isDefinedOptionConfigurable,
+  getDefinedOption,
+  getDefinedOptions,
+  entriesAmountDiff,
+  convertEmptyStringToNull,
+  formatNumber,
+  isBlank,
+  defaultToTransform,
+  transformToMap,
+  transactionIncrement,
+  transformToMapBy,
+  dateRangeFromToCollection,
+  transformToMapKeyValue,
+  mergeObjectsBykey,
+};
diff --git a/packages/server/src/utils/table.ts b/packages/server/src/utils/table.ts
new file mode 100644
index 000000000..a6d39be94
--- /dev/null
+++ b/packages/server/src/utils/table.ts
@@ -0,0 +1,32 @@
+import { get } from 'lodash';
+import { IColumnMapperMeta, ITableRow } from '@/interfaces';
+
+export function tableMapper(
+  data: Object[],
+  columns: IColumnMapperMeta[],
+  rowsMeta
+): ITableRow[] {
+  return data.map((object) => tableRowMapper(object, columns, rowsMeta));
+}
+
+function getAccessor(object, accessor) {
+  return typeof accessor === 'function'
+    ? accessor(object)
+    : get(object, accessor);
+}
+
+export function tableRowMapper(
+  object: Object,
+  columns: IColumnMapperMeta[],
+  rowMeta
+): ITableRow {
+  const cells = columns.map((column) => ({
+    key: column.key,
+    value: column.value ? column.value : getAccessor(object, column.accessor),
+  }));
+
+  return {
+    cells,
+    ...rowMeta,
+  };
+}
diff --git a/packages/server/tests/collection/NestedSet.test.js b/packages/server/tests/collection/NestedSet.test.js
new file mode 100644
index 000000000..7246259f8
--- /dev/null
+++ b/packages/server/tests/collection/NestedSet.test.js
@@ -0,0 +1,130 @@
+import { expect } from '~/testInit';
+import NestedSet from '@/collection/NestedSet';
+
+describe('NestedSet', () => {
+  describe('linkChildren()', () => {  
+    it('Should link parent and children nodes.', () => {
+      const flattenArray = [
+        { id: 10 },
+        { id: 1 },
+        {
+          id: 3,
+          parent_id: 1,
+        },
+        {
+          id: 2,
+          parent_id: 1,
+        },
+        {
+          id: 4,
+          parent_id: 3,
+        },
+      ];
+      const nestSet = new NestedSet(flattenArray);
+      const treeGroups = nestSet.linkChildren();
+
+      expect(treeGroups['1']).deep.equals({
+        id: 1,
+        children: {
+          '2': { id: 2, parent_id: 1, children: {} },
+          '3': {
+            id: 3, parent_id: 1, children: {
+              '4': { id: 4, parent_id: 3, children: {} }
+            }
+          }
+        }
+      });
+      expect(treeGroups['2']).deep.equals({
+        id: 2, parent_id: 1, children: {},
+      });
+      expect(treeGroups['3']).deep.equals({      
+        id: 3,
+        parent_id: 1,
+        children: { '4': { id: 4, parent_id: 3, children: {} } }
+      });
+      expect(treeGroups['4']).deep.equals({
+        id: 4, parent_id: 3, children: {},
+      });
+    });
+  });
+
+  describe('toArray()', () => {
+    it('Should retrieve nested sets as array.', () => {
+      const flattenArray = [
+        { id: 10 },
+        { id: 1 },
+        {
+          id: 3,
+          parent_id: 1,
+        },
+        {
+          id: 2,
+          parent_id: 1,
+        },
+        {
+          id: 4,
+          parent_id: 3,
+        },
+      ];
+      const nestSet = new NestedSet(flattenArray);
+      const treeArray = nestSet.toArray();
+
+      expect(treeArray[0]).deep.equals({
+        id: 10, children: [],
+      });
+      expect(treeArray[1]).deep.equals({
+        id: 1,
+        children: [
+          { id: 2, parent_id: 1, children: [] },
+          { id: 3, parent_id: 1, children: [{
+            id: 4, parent_id: 3, children: []
+          }] }
+        ]
+      });
+    });
+  });
+
+  describe('getParents(id)', () => {
+    it('Should retrieve parent nodes of the given node id.', () => {
+      const flattenArray = [
+        { id: 10 },
+        { id: 1 },
+        {
+          id: 3,
+          parent_id: 1,
+        },
+        {
+          id: 2,
+          parent_id: 1,
+        },
+        {
+          id: 4,
+          parent_id: 3,
+        },
+      ];
+      const nestSet = new NestedSet(flattenArray);
+      const parentNodes = nestSet.getParents(4);
+    
+      expect(parentNodes).deep.equals([
+        { id: 4, parent_id: 3, children: {} },
+        {      
+          id: 3,
+          parent_id: 1,
+          children: { '4': { id: 4, parent_id: 3, children: {} } } 
+        },
+        {
+          id: 1,
+          children: {
+            '2': { id: 2, parent_id: 1, children: {} },
+            '3': {
+              id: 3, parent_id: 1, children: {
+                '4': { id: 4, parent_id: 3, children: {} }
+              }
+            }
+          }
+        }
+      ]);
+    });
+  })
+
+});
diff --git a/packages/server/tests/dbInit.js b/packages/server/tests/dbInit.js
new file mode 100644
index 000000000..8da9bb9c9
--- /dev/null
+++ b/packages/server/tests/dbInit.js
@@ -0,0 +1,40 @@
+import { 
+  request,
+  expect,
+  createTenantFactory,
+  createTenant,
+  bindTenantModel,
+  login,
+  systemFactory,
+  dropTenant,
+} from '~/testInit';
+import CacheService from '@/services/Cache';
+
+let tenantWebsite;
+let tenantFactory;
+let loginRes;
+
+beforeEach(async () => {
+  tenantWebsite = await createTenant();
+  tenantFactory = createTenantFactory(tenantWebsite.tenantDb);
+
+  bindTenantModel(tenantWebsite.tenantDb);
+  loginRes = await login(tenantWebsite);
+
+  CacheService.flush();
+});
+
+afterEach(async () => {
+  await dropTenant(tenantWebsite);
+
+  loginRes = null;
+  tenantFactory = null;
+  tenantWebsite = null;
+});
+
+export {
+  tenantWebsite,
+  tenantFactory,
+  systemFactory,
+  loginRes,
+};
\ No newline at end of file
diff --git a/packages/server/tests/docker-compose.yml b/packages/server/tests/docker-compose.yml
new file mode 100644
index 000000000..52c7a1c24
--- /dev/null
+++ b/packages/server/tests/docker-compose.yml
@@ -0,0 +1,14 @@
+
+services:  
+    mysql:
+        image: mysql/mysql-server:5.7
+        ports:
+            - "3306:3306"
+        environment:
+            - MYSQL_ROOT_PASSWORD=root
+            - MYSQL_DATABASE=moosher_test
+            - MYSQL_USER=moosher
+            - MYSQL_PASSWORD=moosher
+        tmpfs:
+            - /var/lib/mysql/:rw,noexec,nosuid,size=600m
+            - /tmp/:rw,noexec,nosuid,size=50m
diff --git a/packages/server/tests/lib/CachableModel.test.js b/packages/server/tests/lib/CachableModel.test.js
new file mode 100644
index 000000000..d81541cf1
--- /dev/null
+++ b/packages/server/tests/lib/CachableModel.test.js
@@ -0,0 +1,32 @@
+import {
+  request,
+  expect,
+} from '~/testInit';
+import Account from 'models/Account';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+import { times } from 'lodash';
+
+describe('CachableModel', () => {
+  describe('remember()', () => {
+    it('Should retrieve the data from the storage.', async () => {
+      
+      for (let i = 0; i < 1; i++) {
+        const account = await Account.tenant().query()
+          .remember()
+          .where('id', 1);
+
+        const account2 = await Account.tenant().query()
+          .remember()
+          .withGraphFetched('balance');
+        
+        console.log(account2);
+        // \\\
+      }
+      // Account.flushCache();
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/server/tests/lib/MetableStore.test.ts b/packages/server/tests/lib/MetableStore.test.ts
new file mode 100644
index 000000000..a2be0bdca
--- /dev/null
+++ b/packages/server/tests/lib/MetableStore.test.ts
@@ -0,0 +1,39 @@
+import { expect } from '~/testInit';
+import MetableStore from '@/lib/MetableStore';
+
+describe('MetableStore()', () => { 
+
+  describe('find', () => {
+    it('Find metadata by the given key.', () => {
+      const store = new MetableStore();
+      store.metadata = [{ key: 'first-key', value: 'first-value' }];
+
+      const meta = store.find('first-key');
+
+      expect(meta.value).equals('first-value');
+      expect(meta.key).equals('first-key');
+    });
+
+    it('Find metadata by the key as payload.', () => {
+      
+    });
+
+    it('Find metadata by the given key and extra columns.', () => {
+
+    });
+  });
+
+  describe('all()', () => {
+    it('Should retrieve all metadata in the store.', () => {
+
+    });
+  });
+
+  describe('get()', () => {
+    it('Should retrieve data of the given metadata query.', () => {
+
+    });
+  });
+
+  describe('removeMeta')
+});
\ No newline at end of file
diff --git a/packages/server/tests/models/Account.test.js b/packages/server/tests/models/Account.test.js
new file mode 100644
index 000000000..c933ffcf3
--- /dev/null
+++ b/packages/server/tests/models/Account.test.js
@@ -0,0 +1,50 @@
+import { 
+  expect,
+} from '~/testInit';
+import Account from 'models/Account';
+import AccountType from 'models/AccountType';
+import {
+  tenantFactory,
+  tenantWebsite
+} from '~/dbInit';
+import DependencyGraph from '@/lib/DependencyGraph';
+
+describe('Model: Account', () => {
+  it('Should account model belongs to the associated account type model.', async () => {
+    const accountType = await tenantFactory.create('account_type');
+    const account = await tenantFactory.create('account', { account_type_id: accountType.id });
+
+    const accountModel = await Account.tenant().query()
+      .where('id', account.id)
+      .withGraphFetched('type')
+      .first();
+
+    expect(accountModel.type.id).equals(accountType.id);
+  });
+
+  it('Should account model has one balance model that associated to the account model.', async () => {
+    const accountBalance = await tenantFactory.create('account_balance');
+
+    const accountModel = await Account.tenant().query()
+      .where('id', accountBalance.accountId)
+      .withGraphFetched('balance')
+      .first();
+
+    expect(accountModel.balance.amount).equals(accountBalance.amount);
+  });
+
+  it('Should account model has many transactions models that associated to the account model.', async () => {
+    const account = await tenantFactory.create('account');
+    const accountTransaction = await tenantFactory.create('account_transaction', { account_id: account.id });
+
+    const accountModel = await Account.tenant().query().where('id', account.id).first();
+    const transactionsModels = await accountModel.$relatedQuery('transactions');
+
+    expect(transactionsModels.length).equals(1);
+  });
+
+  it('Should retrieve dependency graph.', async () => {
+    const accountsDepGraph = await Account.tenant().depGraph().query();
+    expect(accountsDepGraph).to.be.an.instanceOf(DependencyGraph);
+  });
+});
diff --git a/packages/server/tests/models/AccountType.test.js b/packages/server/tests/models/AccountType.test.js
new file mode 100644
index 000000000..51bd5f5d7
--- /dev/null
+++ b/packages/server/tests/models/AccountType.test.js
@@ -0,0 +1,22 @@
+import { create, expect } from '~/testInit';
+import 'models/Account';
+import AccountType from 'models/AccountType';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+
+describe('Model: AccountType', () => {
+  it('Shoud account type model has many associated accounts.', async () => {
+    const accountType = await tenantFactory.create('account_type');
+    await tenantFactory.create('account', { account_type_id: accountType.id });
+    await tenantFactory.create('account', { account_type_id: accountType.id });
+
+    const accountTypeModel = await AccountType.tenant().query().where('id', accountType.id).first();
+    const typeAccounts = await accountTypeModel.$relatedQuery('accounts');
+
+    expect(typeAccounts.length).equals(2);
+  });
+});
diff --git a/packages/server/tests/models/Expense.test.js b/packages/server/tests/models/Expense.test.js
new file mode 100644
index 000000000..ed5348a46
--- /dev/null
+++ b/packages/server/tests/models/Expense.test.js
@@ -0,0 +1,39 @@
+import { create, expect } from '~/testInit';
+import Expense from 'models/Expense';
+import ExpenseCategory from 'models/ExpenseCategory';
+import {
+  tenantFactory,
+  tenantWebsite
+} from '~/dbInit';
+ 
+describe('Model: Expense', () => {
+  describe('relations', () => {
+    it('Expense model may belongs to associated payment account.', async () => {
+      const expense = await tenantFactory.create('expense');
+      
+      const expenseModel = await Expense.tenant().query().findById(expense.id);
+      const paymentAccountModel = await expenseModel.$relatedQuery('paymentAccount');
+      
+      expect(paymentAccountModel.id).equals(expense.paymentAccountId);
+    });
+
+    it('Expense model may has many associated expense categories.', async () => {
+      const expenseCategory = await tenantFactory.create('expense_category');
+
+      const expenseModel = await Expense.tenant().query().findById(expenseCategory.expenseId);
+      const expenseCategories = await expenseModel.$relatedQuery('categories');
+
+      expect(expenseCategories.length).equals(1);
+      expect(expenseCategories[0].expenseId).equals(expenseModel.id);
+    });
+
+    it('Expense model may belongs to associated user model.', async () => {
+      const expense = await tenantFactory.create('expense');
+      
+      const expenseModel = await Expense.tenant().query().findById(expense.id);
+      const expenseUserModel = await expenseModel.$relatedQuery('user');
+      
+      expect(expenseUserModel.id).equals(expense.userId);
+    });
+  });
+});
diff --git a/packages/server/tests/models/ExpenseCategory.test.js b/packages/server/tests/models/ExpenseCategory.test.js
new file mode 100644
index 000000000..1eca93c07
--- /dev/null
+++ b/packages/server/tests/models/ExpenseCategory.test.js
@@ -0,0 +1,5 @@
+
+
+describe('ExpenseCategory', () => {
+
+});
\ No newline at end of file
diff --git a/packages/server/tests/models/Item.test.js b/packages/server/tests/models/Item.test.js
new file mode 100644
index 000000000..8ce26771c
--- /dev/null
+++ b/packages/server/tests/models/Item.test.js
@@ -0,0 +1,22 @@
+import { create, expect } from '~/testInit';
+import Item from 'models/Item';
+// eslint-disable-next-line no-unused-vars
+import itemCategory from 'models/ItemCategory';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+
+describe('Model: Item', () => {
+  it('Should item model belongs to the associated category model.', async () => {
+    const category = await tenantFactory.create('item_category');
+    const item = await tenantFactory.create('item', { category_id: category.id });
+
+    const itemModel = await Item.tenant().query().where('id', item.id).first();
+    const itemCategoryModel = await itemModel.$relatedQuery('category');
+
+    expect(itemCategoryModel.id).equals(category.id);
+  });
+});
diff --git a/packages/server/tests/models/ItemCategories.test.js b/packages/server/tests/models/ItemCategories.test.js
new file mode 100644
index 000000000..cd339d70c
--- /dev/null
+++ b/packages/server/tests/models/ItemCategories.test.js
@@ -0,0 +1,24 @@
+import { create, expect } from '~/testInit';
+import 'models/Item';
+import ItemCategory from 'models/ItemCategory';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+
+describe('Model: ItemCategories', () => {
+  it('Shoud item category model has many associated items.', async () => {
+    const category = await tenantFactory.create('item_category');
+    await tenantFactory.create('item', { category_id: category.id });
+    await tenantFactory.create('item', { category_id: category.id });
+
+    const categoryModel = await ItemCategory.tenant().query()
+      .where('id', category.id).first();
+
+    const categoryItems = await categoryModel.$relatedQuery('items');
+
+    expect(categoryItems.length).equals(2);
+  });
+});
diff --git a/packages/server/tests/models/Resource.test.js b/packages/server/tests/models/Resource.test.js
new file mode 100644
index 000000000..8a2a1eb11
--- /dev/null
+++ b/packages/server/tests/models/Resource.test.js
@@ -0,0 +1,31 @@
+import { create, expect } from '~/testInit';
+import Resource from 'models/Resource';
+import 'models/View';
+import 'models/ResourceField';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+
+describe('Model: Resource', () => {
+  it('Resource model may has many associated views.', async () => {
+    const view = await tenantFactory.create('view');
+    await tenantFactory.create('view', { resource_id: view.resourceId });
+
+    const resourceModel = await Resource.tenant().query().findById(view.resourceId);
+    const resourceViews = await resourceModel.$relatedQuery('views');
+
+    expect(resourceViews).to.have.lengthOf(2);
+  });
+
+  it('Resource model may has many fields.', async () => {
+    const resourceField = await tenantFactory.create('resource_field');
+
+    const resourceModel = await Resource.tenant().query().findById(resourceField.resourceId);
+    const resourceFields = await resourceModel.$relatedQuery('fields');
+
+    expect(resourceFields).to.have.lengthOf(1);
+  });
+});
diff --git a/packages/server/tests/models/User.test.js b/packages/server/tests/models/User.test.js
new file mode 100644
index 000000000..b29332288
--- /dev/null
+++ b/packages/server/tests/models/User.test.js
@@ -0,0 +1,23 @@
+import { create, expect } from '~/testInit';
+import User from 'models/TenantUser';
+import 'models/Role';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+
+describe('Model: User', () => {
+  describe('relations', () => {
+    it('User model may has many associated roles.', async () => {
+      const userHasRole = await tenantFactory.create('user_has_role');
+      await tenantFactory.create('user_has_role', { user_id: userHasRole.user_id });
+
+      const userModel = await User.tenant().query().where('id', userHasRole.userId).first();
+      const userRoles = await userModel.$relatedQuery('roles');
+
+      expect(userRoles).to.have.lengthOf(1);
+    });
+  });
+});
diff --git a/packages/server/tests/models/View.test.js b/packages/server/tests/models/View.test.js
new file mode 100644
index 000000000..208302afa
--- /dev/null
+++ b/packages/server/tests/models/View.test.js
@@ -0,0 +1,47 @@
+import { create, expect } from '~/testInit';
+import View from 'models/View';
+import Resource from 'models/Resource';
+import ResourceField from 'models/ResourceField';
+import ViewRole from 'models/ViewRole';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+
+describe('Model: View', () => {
+  it('View model may has many associated resource.', async () => {
+    const view = await tenantFactory.create('view');
+
+    const viewModel = await View.tenant().query().findById(view.id);
+    const viewResource = await viewModel.$relatedQuery('resource');
+
+    const foundResource = await Resource.tenant().query().findById(view.resourceId);
+
+    expect(viewResource.id).equals(foundResource.id);
+    expect(viewResource.name).equals(foundResource.name);
+  });
+
+  it('View model may has many associated view roles.', async () => {
+    const view = await tenantFactory.create('view');
+    await tenantFactory.create('view_role', { view_id: view.id });
+    await tenantFactory.create('view_role', { view_id: view.id });
+
+    const viewModel = await View.tenant().query().findById(view.id);
+    const viewRoles = await viewModel.$relatedQuery('roles');
+
+    expect(viewRoles).to.have.lengthOf(2);
+  });
+
+  it('View model may has many associated view columns', async () => {
+    const view = await tenantFactory.create('view');
+    await tenantFactory.create('view_column', { view_id: view.id });
+    await tenantFactory.create('view_column', { view_id: view.id });
+
+    const viewModel = await View.tenant().query().findById(view.id);
+    const viewColumns = await viewModel.$relatedQuery('columns');
+
+    expect(viewColumns).to.have.lengthOf(2);
+  });
+});
diff --git a/packages/server/tests/mysql-tmpfs.sh b/packages/server/tests/mysql-tmpfs.sh
new file mode 100644
index 000000000..7ee993230
--- /dev/null
+++ b/packages/server/tests/mysql-tmpfs.sh
@@ -0,0 +1,31 @@
+MYSQL_USER="database_test"
+MYSQL_DATABASE="database_test"
+MYSQL_CONTAINER_NAME="database_test"
+
+MYSQL_ROOT_PASSWORD="root"
+MYSQL_PASSWORD="root"
+
+echo "Start the testing MySql database..."
+
+docker \
+  run \
+    --detach \
+    --env MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD} \
+    --env MYSQL_USER=${MYSQL_USER} \
+    --env MYSQL_PASSWORD=${MYSQL_PASSWORD} \
+    --env MYSQL_DATABASE=${MYSQL_DATABASE} \
+    --name ${MYSQL_CONTAINER_NAME} \
+    --publish 3306:3306 \
+    --tmpfs /var/lib/mysql:rw,noexec,nosuid,size=600m \
+  mysql:5.7;
+
+echo "Sleeping for 10 seconds to allow time for the DB to be provisioned:"
+for i in `seq 1 10`;
+do
+  echo "."
+  sleep 1
+done
+
+echo "Database '${MYSQL_DATABASE}' running."
+echo "  Username: ${MYSQL_USER}"
+echo "  Password: ${MYSQL_PASSWORD}"
diff --git a/packages/server/tests/routes/accounting.test.js b/packages/server/tests/routes/accounting.test.js
new file mode 100644
index 000000000..1b2d1b2c5
--- /dev/null
+++ b/packages/server/tests/routes/accounting.test.js
@@ -0,0 +1,887 @@
+import {
+  request,
+  expect,
+} from '~/testInit';
+import moment from 'moment';
+import ManualJournal from 'models/ManualJournal';
+import AccountTransaction from 'models/AccountTransaction';
+import AccountBalance from 'models/AccountBalance';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+
+describe('routes: `/accounting`', () => {
+  describe('route: `/accounting/make-journal-entries`', async () => {
+    it('Should sumation of credit or debit does not equal zero.', async () => {
+      const account = await tenantFactory.create('account');
+      const res = await request()
+        .post('/api/accounting/make-journal-entries')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: new Date().toISOString(),
+          journal_number: '123',
+          reference: 'ASC',
+          entries: [
+            {
+              index: 1,
+              credit: 0,
+              debit: 0,
+              account_id: account.id,
+            },
+            {
+              index: 2,
+              credit: 0,
+              debit: 0,
+              account_id: account.id,
+            },
+          ],
+        });
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equal({
+        type: 'CREDIT.DEBIT.SUMATION.SHOULD.NOT.EQUAL.ZERO',
+        code: 400,
+      });
+    });
+
+    it('Should all credit entries equal debit.', async () => {
+      const account = await tenantFactory.create('account');
+      const res = await request()
+        .post('/api/accounting/make-journal-entries')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: new Date().toISOString(),
+          journal_number: '123',
+          entries: [
+            {
+              index: 1,
+              credit: 1000,
+              debit: 0,
+              account_id: account.id,
+            },
+            {
+              index: 2,
+              credit: 0,
+              debit: 500,
+              account_id: account.id,
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equal({
+        type: 'CREDIT.DEBIT.NOT.EQUALS',
+        code: 100,
+      });
+    });
+
+    it('Should journal reference be not exists.', async () => {
+      const manualJournal = await tenantFactory.create('manual_journal');
+      const account = await tenantFactory.create('account');
+
+      const res = await request()
+        .post('/api/accounting/make-journal-entries')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: new Date().toISOString(),
+          journal_number: manualJournal.journalNumber,
+          entries: [
+            {
+              index: 1,
+              credit: 1000,
+              debit: 0,
+              account_id: account.id,
+            },
+            {
+              index: 2,
+              credit: 0,
+              debit: 1000,
+              account_id: account.id,
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equal({
+        type: 'JOURNAL.NUMBER.ALREADY.EXISTS',
+        code: 300,
+      });
+    });
+
+    it('Should response error in case account id not exists in one of the given entries.', async () => {
+      const res = await request()
+        .post('/api/accounting/make-journal-entries')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: new Date().toISOString(),
+          journal_number: '123',
+          entries: [
+            {
+              index: 1,
+              credit: 1000,
+              debit: 0,
+              account_id: 12,
+            },
+            {
+              index: 2,
+              credit: 0,
+              debit: 1000,
+              account_id: 12,
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equal({
+        type: 'ACCOUNTS.IDS.NOT.FOUND',
+        code: 200,
+      });
+    });
+
+    it('Should discard journal entries that has null credit and debit amount.', async () => {
+      const account1 = await tenantFactory.create('account');
+      const account2 = await tenantFactory.create('account');
+
+      const res = await request()
+        .post('/api/accounting/make-journal-entries')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: new Date().toISOString(),
+          journal_number: '1000',
+          entries: [
+            {
+              index: 1,
+              credit: null,
+              debit: 0,
+              account_id: account1.id,
+            },
+            {
+              index: 2,
+              credit: null,
+              debit: 0,
+              account_id: account2.id,
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equal({
+        type: 'CREDIT.DEBIT.SUMATION.SHOULD.NOT.EQUAL.ZERO',
+
+        code: 400,
+      });
+    });
+
+    it('Should validate the customers and vendors contact if were not found on the storage.', async () => {
+      const account1 = await tenantFactory.create('account');
+      const account2 = await tenantFactory.create('account');
+
+      const res = await request()
+        .post('/api/accounting/make-journal-entries')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: new Date().toISOString(),
+          journal_number: '1000',
+          entries: [
+            {
+              index: 1,
+              credit: null,
+              debit: 1000,
+              account_id: account1.id,
+              contact_type: 'customer',
+              contact_id: 100,
+            },
+            {
+              index: 2,
+              credit: 1000,
+              debit: 0,
+              account_id: account1.id,
+              contact_type: 'vendor',
+              contact_id: 300,
+            },
+          ],
+        });
+
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'CUSTOMERS.CONTACTS.NOT.FOUND', code: 500, ids: [100],
+      });
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'VENDORS.CONTACTS.NOT.FOUND', code: 600, ids: [300],
+      })
+    });
+
+    it('Should customer contact_type with receivable accounts type.', async () => {
+      const account1 = await tenantFactory.create('account');
+      const account2 = await tenantFactory.create('account');
+      const customer = await tenantFactory.create('customer');
+
+      const res = await request()
+        .post('/api/accounting/make-journal-entries')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: new Date().toISOString(),
+          journal_number: '1000',
+          entries: [
+            {
+              index: 1,
+              credit: null,
+              debit: 1000,
+              account_id: account1.id,
+              contact_type: 'customer',
+              contact_id: 100,
+            },
+            {
+              index: 2,
+              credit: 1000,
+              debit: 0,
+              account_id: account1.id,
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'CUSTOMERS.NOT.WITH.RECEIVABLE.ACCOUNT',
+        code: 700,
+        indexes: [1]
+      });
+    });
+
+    it('Should account receivable entries has contact_id and contact_type customer.', async () => {
+      const res = await request()
+        .post('/api/accounting/make-journal-entries')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: new Date().toISOString(),
+          journal_number: '1000',
+          entries: [
+            {
+              index: 1,
+              credit: null,
+              debit: 1000,
+              account_id: 10,
+            },
+            {
+              index: 2,
+              credit: 1000,
+              debit: 0,
+              account_id: 1,
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'RECEIVABLE.ENTRIES.HAS.NO.CUSTOMERS', code: 900, indexes: [1],
+      });
+    });
+
+    it('Should account payable entries has contact_id and contact_type vendor.', async () => {
+      const res = await request()
+        .post('/api/accounting/make-journal-entries')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: new Date().toISOString(),
+          journal_number: '1000',
+          entries: [
+            {
+              index: 1,
+              credit: null,
+              debit: 1000,
+              account_id: 10,
+            },
+            {
+              index: 2,
+              credit: 1000,
+              debit: 0,
+              account_id: 11,
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'PAYABLE.ENTRIES.HAS.NO.VENDORS', code: 1000, indexes: [2]
+      });
+    });
+
+    it('Should retrieve account_id is not receivable in case contact_type equals customer.', async () => {
+      const customer = await tenantFactory.create('customer');
+
+      const res = await request()
+        .post('/api/accounting/make-journal-entries')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: new Date().toISOString(),
+          journal_number: '1000',
+          entries: [
+            {
+              index: 1,
+              credit: null,
+              debit: 1000,
+              account_id: 2,
+              contact_id: customer.id,
+              contact_type: 'customer',
+            },
+            {
+              index: 2,
+              credit: 1000,
+              debit: 0,
+              account_id: 11,
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'CUSTOMERS.NOT.WITH.RECEIVABLE.ACCOUNT', code: 700, indexes: [1],
+      });
+    });
+
+    it('Should store manual journal transaction to the storage.', async () => {
+      const account1 = await tenantFactory.create('account');
+      const account2 = await tenantFactory.create('account');
+
+      const res = await request()
+        .post('/api/accounting/make-journal-entries')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: new Date('2020-2-2').toISOString(),
+          journal_number: '1000',
+          reference: '2000',
+          description: 'Description here.',
+          entries: [
+            {
+              index: 1,
+              credit: 1000,
+              account_id: account1.id,
+            },
+            {
+              index: 2,
+              debit: 1000,
+              account_id: account2.id,
+            },
+          ],
+        });
+
+      const foundManualJournal = await ManualJournal.tenant().query();
+      expect(foundManualJournal.length).equals(1);
+      
+      expect(foundManualJournal[0].reference).equals('2000');
+      expect(foundManualJournal[0].journalNumber).equals('1000');
+      expect(foundManualJournal[0].transactionType).equals('Journal');
+      expect(foundManualJournal[0].amount).equals(1000);
+      expect(moment(foundManualJournal[0].date).format('YYYY-MM-DD')).equals('2020-02-02');
+      expect(foundManualJournal[0].description).equals('Description here.');
+      expect(foundManualJournal[0].userId).to.be.a('number');
+    });
+
+    it('Should store journal transactions to the storage.', async () => {
+      const account1 = await tenantFactory.create('account');
+      const account2 = await tenantFactory.create('account');
+
+      const res = await request()
+        .post('/api/accounting/make-journal-entries')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          journal_number: '1',
+          date: new Date('2020-1-1').toISOString(),
+          reference: '1000',
+          memo: 'Description here.',
+          entries: [
+            {
+              index: 1,
+              credit: 1000,
+              account_id: account1.id,
+              note: 'First note',
+            },
+            {
+              index: 2,
+              debit: 1000,
+              account_id: account2.id,
+              note: 'Second note',
+            },
+          ],
+        });
+
+      const foundAccountsTransactions = await AccountTransaction.tenant().query();
+
+      expect(foundAccountsTransactions.length).equals(2);
+
+      expect(foundAccountsTransactions[0].credit).equals(1000);
+      expect(foundAccountsTransactions[0].debit).equals(null);
+      expect(foundAccountsTransactions[0].accountId).equals(account1.id);
+      expect(foundAccountsTransactions[0].note).equals('First note');
+      expect(foundAccountsTransactions[0].referenceType).equals('Journal');
+      expect(foundAccountsTransactions[0].userId).equals(1);
+
+      expect(foundAccountsTransactions[1].credit).equals(null);
+      expect(foundAccountsTransactions[1].debit).equals(1000);
+      expect(foundAccountsTransactions[1].accountId).equals(account2.id);
+      expect(foundAccountsTransactions[1].note).equals('Second note');
+      expect(foundAccountsTransactions[1].referenceType).equals('Journal');
+      expect(foundAccountsTransactions[1].userId).equals(1);
+    });
+  });
+
+  describe('route: POST: `/accounting/manual-journal/:id`', () => {
+    it('Should response not found in case manual journal transaction was not exists.', async () => {
+      const res = await request()
+        .post('/api/manual-journal/1000')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+    });
+
+    it('Should sumation of credit or debit be equal zero.', async () => {
+      const manualJournal = await tenantFactory.create('manual_journal');
+
+      const res = await request()
+        .post(`/api/accounting/manual-journals/${manualJournal.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: new Date().toISOString(),
+          journal_number: '123',
+          reference: 'ASC',
+          entries: [
+            {
+              credit: 0,
+              debit: 0,
+              account_id: 2000,
+            },
+            {
+              credit: 0,
+              debit: 0,
+              account_id: 2000,
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equal({
+        type: 'CREDIT.DEBIT.SUMATION.SHOULD.NOT.EQUAL.ZERO',
+        code: 400,
+      });
+    });
+
+    it('Should all credit and debit sumation be equal.', async () => {
+      const manualJournal = await tenantFactory.create('manual_journal');
+
+      const res = await request()
+        .post(`/api/accounting/manual-journals/${manualJournal.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: new Date().toISOString(),
+          journal_number: '123',
+          reference: 'ASC',
+          entries: [
+            {
+              credit: 0,
+              debit: 2000,
+              account_id: 2000,
+            },
+            {
+              credit: 1000,
+              debit: 0,
+              account_id: 2000,
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equal({
+        type: 'CREDIT.DEBIT.NOT.EQUALS', code: 100,
+      });
+    });
+
+    it('Should response journal number already exists in case another one on the storage.', async () => {
+      const manualJournal = await tenantFactory.create('manual_journal');
+      const manualJournal2 = await tenantFactory.create('manual_journal');
+
+      const jsonBody = {
+        date: new Date().toISOString(),
+        reference: 'ASC',
+        entries: [
+          {
+            credit: 0,
+            debit: 2000,
+            account_id: 2000,
+          },
+          {
+            credit: 1000,
+            debit: 0,
+            account_id: 2000,
+          },
+        ],
+      };
+
+      const res = await request()
+        .post(`/api/accounting/manual-journals/${manualJournal.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          ...jsonBody,
+          journal_number: manualJournal2.journalNumber,
+        });
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equal({
+        type: 'JOURNAL.NUMBER.ALREADY.EXISTS', code: 300,
+      });
+    });
+
+    it('Should not response journal number exists in case was unique number.', async () => {
+      const manualJournal = await tenantFactory.create('manual_journal');
+      const manualJournal2 = await tenantFactory.create('manual_journal');
+
+      const jsonBody = {
+        date: new Date().toISOString(),
+        reference: 'ASC',
+        entries: [
+          {
+            credit: 0,
+            debit: 2000,
+            account_id: 2000,
+          },
+          {
+            credit: 1000,
+            debit: 0,
+            account_id: 2000,
+          },
+        ],
+      };
+      const res = await request()
+        .post(`/api/accounting/manual-journals/${manualJournal.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          ...jsonBody,
+          journal_number: manualJournal.journalNumber,
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).not.include.something.that.deep.equal({
+        type: 'JOURNAL.NUMBER.ALREADY.EXISTS', code: 300,
+      });
+    })
+
+    it('Should response error in case account id not exists in one of the given entries.', async () => {
+      const manualJournal = await tenantFactory.create('manual_journal');
+      const manualJournal2 = await tenantFactory.create('manual_journal');
+
+      const jsonBody = {
+        date: new Date().toISOString(),
+        reference: 'ASC',
+        entries: [
+          {
+            credit: 0,
+            debit: 1000,
+            account_id: 2000,
+          },
+          {
+            credit: 1000,
+            debit: 0,
+            account_id: 2000,
+          },
+        ],
+      };
+      const res = await request()
+        .post(`/api/accounting/manual-journals/${manualJournal.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          ...jsonBody,
+          journal_number: manualJournal.journalNumber,
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equal({
+        type: 'ACCOUNTS.IDS.NOT.FOUND', code: 200,
+      }); 
+    });
+
+    it('Should update the given manual journal transaction in the storage.', async () => {
+      const manualJournal = await tenantFactory.create('manual_journal');
+      const account1 = await tenantFactory.create('account');
+      const account2 = await tenantFactory.create('account');
+
+      const res = await request()
+        .post(`/api/accounting/manual-journals/${manualJournal.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          journal_number: '123',
+          date: new Date().toISOString(),
+          reference: 'ABC',
+          description: 'hello world',
+          entries: [
+            {
+              credit: 0,
+              debit: 1000,
+              account_id: account1.id,
+            },
+            {
+              credit: 1000,
+              debit: 0,
+              account_id: account2.id,
+            },
+          ],
+        });
+      
+      const foundManualJournal = await ManualJournal.tenant().query()
+        .where('id', manualJournal.id);
+
+      expect(foundManualJournal.length).equals(1);
+      expect(foundManualJournal[0].journalNumber).equals('123');
+      expect(foundManualJournal[0].reference).equals('ABC');
+      expect(foundManualJournal[0].description).equals('hello world');
+    });
+
+    it('Should update account transactions that associated to the manual journal transaction.', async () => {
+      const manualJournal = await tenantFactory.create('manual_journal');
+      const account1 = await tenantFactory.create('account');
+      const account2 = await tenantFactory.create('account');
+      const transaction = await tenantFactory.create('account_transaction', {
+        reference_type: 'Journal',
+        reference_id: manualJournal.id,
+      });
+      const transaction2 = await tenantFactory.create('account_transaction', {
+        reference_type: 'Journal',
+        reference_id: manualJournal.id,
+      });
+
+      const res = await request()
+        .post(`/api/accounting/manual-journals/${manualJournal.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          journal_number: '123',
+          date: new Date().toISOString(),
+          reference: 'ABC',
+          description: 'hello world',
+          entries: [
+            {
+              credit: 0,
+              debit: 1000,
+              account_id: account1.id,
+              note: 'hello 1',
+            },
+            {
+              credit: 1000,
+              debit: 0,
+              account_id: account2.id,
+              note: 'hello 2',
+            },
+          ],
+        });
+
+      const foundTransactions = await AccountTransaction.tenant().query();
+    
+      expect(foundTransactions.length).equals(2);
+      expect(foundTransactions[0].credit).equals(0);
+      expect(foundTransactions[0].debit).equals(1000);
+      expect(foundTransactions[0].accountId).equals(account1.id);
+      expect(foundTransactions[0].note).equals('hello 1');
+
+      expect(foundTransactions[1].credit).equals(1000);
+      expect(foundTransactions[1].debit).equals(0);
+      expect(foundTransactions[1].accountId).equals(account2.id);
+      expect(foundTransactions[1].note).equals('hello 2');
+    });
+  });
+
+  describe('route: DELETE `accounting/manual-journals/:id`', () => {
+    it('Should response not found in case the manual journal transaction was not found.', async() => {
+      const res = await request()
+        .delete('/api/accounting/manual-journals/1000')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.that.deep.equal({
+        type: 'MANUAL.JOURNAL.NOT.FOUND', code: 100,
+      });
+    });
+
+    it('Should delete manual journal transactions from storage.', async () => {
+      const manualJournal = await tenantFactory.create('manual_journal');
+
+      const res = await request()
+        .delete(`/api/accounting/manual-journals/${manualJournal.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      const foundManualTransaction = await ManualJournal.tenant().query()
+        .where('id', manualJournal.id).first();
+
+      expect(foundManualTransaction).equals(undefined);
+    });
+
+    it('Should delete associated transactions of journal transaction.', async () => {
+      const manualJournal = await tenantFactory.create('manual_journal');
+      const transaction1 = await tenantFactory.create('account_transaction', {
+        reference_type: 'Journal', reference_id: manualJournal.id,
+      });
+      const transaction2 = await tenantFactory.create('account_transaction', {
+        reference_type: 'Journal', reference_id: manualJournal.id,
+      });
+
+      const res = await request()
+        .delete(`/api/accounting/manual-journals/${manualJournal.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      const foundTransactions = await AccountTransaction.tenant().query();
+      expect(foundTransactions.length).equals(0);
+    });
+
+    it('Should revert accounts balance after delete account transactions.', () => {
+
+    });
+  });
+
+  describe('route: GET `accounting/manual-journals/:id`', () => {
+    it('Should response not found in case manual transaction id was not exists.', async () => {
+      const res = await request()
+        .delete('/api/accounting/manual-journals/100')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'MANUAL.JOURNAL.NOT.FOUND', code: 100,
+      });
+    });
+
+    it('Should response manual transaction and transactions metadata.', async () => {
+
+    });
+
+  });
+
+  describe('route: `accounting/manual-journals`', async () => {
+
+    it('Should retrieve all manual journals with pagination meta.', async () => {
+      const manualJournal1 = await tenantFactory.create('manual_journal');
+      const manualJournal2 = await tenantFactory.create('manual_journal');
+
+      const res = await request()
+        .get('/api/accounting/manual-journals')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(200);
+      expect(res.body.manualJournals.results).to.be.a('array');
+      expect(res.body.manualJournals.results.length).equals(2);
+    });
+  });
+
+  describe('route: POST `accounting/manual-journals/:id/publish`', () => {
+
+    it('Should response not found in case the manual journal id was not exists.', async () => {
+      const manualJournal = await tenantFactory.create('manual_journal');
+
+      const res = await request()
+        .post('/api/accounting/manual-journals/123/publish')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'MANUAL.JOURNAL.NOT.FOUND', code: 100,
+      });
+    });
+
+    it('Should response published ready.', async () => {
+      const manualJournal = await tenantFactory.create('manual_journal', { status: 1 });
+      
+      const res = await request()
+        .post(`/api/accounting/manual-journals/${manualJournal.id}/publish`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'MANUAL.JOURNAL.PUBLISHED.ALREADY', code: 200,
+      });
+    });
+
+    it('Should update all accounts transactions to not draft.', async () => {
+      const manualJournal = await tenantFactory.create('manual_journal', { status: 0 });
+      const transaction = await tenantFactory.create('account_transaction', {
+        reference_type: 'Journal',
+        reference_id: manualJournal.id,
+        draft: 1,
+      });
+      const transaction2 = await tenantFactory.create('account_transaction', {
+        reference_type: 'Journal',
+        reference_id: manualJournal.id,
+        draft: 1,
+      });
+      const res = await request()
+        .post(`/api/accounting/manual-journals/${manualJournal.id}/publish`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      const foundTransactions = await AccountTransaction.tenant().query()
+        .whereIn('id', [transaction.id, transaction2.id]);
+
+      expect(foundTransactions[0].draft).equals(0);
+      expect(foundTransactions[1].draft).equals(0);
+    });
+
+    it('Should increment/decrement accounts balance.', () => {
+
+    });
+  });
+
+  describe('route: `/accounting/quick-journal-entries`', async () => {
+    it('Shoud `credit_account_id` be required', () => {
+
+    });
+    it('Should `debit_account_id` be required.', () => {
+
+    });
+
+    it('Should `amount` be required.', () => {
+
+    });
+
+    it('Should credit account id be exists.', () => {
+
+    });
+
+    it('Should debit account id be exists.', () => {
+
+    });
+
+    it('Should store the quick journal entry to the storage.', () => {
+
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/server/tests/routes/accounts.test.js b/packages/server/tests/routes/accounts.test.js
new file mode 100644
index 000000000..1a6fb1d31
--- /dev/null
+++ b/packages/server/tests/routes/accounts.test.js
@@ -0,0 +1,758 @@
+import {
+  request,
+  expect,
+} from '~/testInit';
+import Account from 'models/Account';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+
+describe('routes: /accounts/', () => {
+  describe('POST `/accounts`', () => {
+    it('Should `name` be required.', async () => {
+      const res = await request()
+        .post('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+    });
+
+    it('Should `account_type_id` be required.', async () => {
+      const res = await request()
+        .post('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+    });
+
+    it('Should max length of `code` be limited.', async () => {
+      const res = await request()
+        .post('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+    });
+
+    it('Should response type not found in case `account_type_id` was not exist.', async () => {
+      const account = await tenantFactory.create('account');
+      const res = await request()
+        .post('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Account Name',
+          description: account.description,
+          account_type_id: 22, // not found.
+          code: 123,
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'NOT_EXIST_ACCOUNT_TYPE', code: 200,
+      });
+    });
+
+    it('Should account code be unique in the storage.', async () => {
+      const account = await tenantFactory.create('account');
+      const res = await request()
+        .post('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: account.name,
+          description: account.description,
+          account_type_id: account.accountTypeId,
+          code: account.code,
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'NOT_UNIQUE_CODE', code: 100,
+      });
+    });
+
+    it('Should response success with correct data form.', async () => {
+      const account = await tenantFactory.create('account');
+      const res = await request()
+        .post('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Name',
+          description: 'description here',
+          code: 100,
+          account_type_id: account.accountTypeId,
+          parent_account_id: account.id,
+        });
+
+      expect(res.status).equals(200);
+    });
+
+    it('Should store account data in the storage.', async () => {
+      const account = await tenantFactory.create('account');
+
+      const res = await request().post('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Account Name',
+          description: 'desc here',
+          account_type_id: account.accountTypeId,
+          parent_account_id: account.id,
+        });
+
+      const accountModel = await Account.tenant().query()
+        .where('name', 'Account Name')
+        .first();
+
+      expect(accountModel).a.an('object');
+      expect(accountModel.description).equals('desc here');
+      expect(accountModel.accountTypeId).equals(account.accountTypeId);
+      expect(accountModel.parentAccountId).equals(account.id);
+    });
+  });
+
+  describe('POST `/accounts/:id`', () => {
+    it('Should `name` be required.', async () => {
+      const account = await tenantFactory.create('account');
+      const res = await request()
+        .post(`/api/accounts/${account.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+    });
+
+    it('Should `account_type_id` be required.', async () => {
+      const account = await tenantFactory.create('account');
+      const res = await request()
+        .post(`/api/accounts/${account.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+    });
+
+    it('Should max length of `code` be limited.', async () => {
+      const account = await tenantFactory.create('account');
+      const res = await request()
+        .post(`/api/accounts/${account.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+    });
+
+    it('Should response type not found in case `account_type_id` was not exist.', async () => {
+      const res = await request()
+        .post('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+    });
+
+    it('Should account code be unique in the storage.', async () => {
+      await tenantFactory.create('account', { code: 'ABCD' });
+      const account = await tenantFactory.create('account');
+      const res = await request()
+        .post(`/api/accounts/${account.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'name',
+          code: 'ABCD',
+          account_type_id: account.accountTypeId,
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'NOT_UNIQUE_CODE', code: 100,
+      });
+    });
+
+    it('Should response success with correct data form.', async () => {
+      const account = await tenantFactory.create('account');
+      const res = await request()
+        .post('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Name',
+          description: 'description here',
+          account_type_id: account.accountTypeId,
+          parent_account_id: account.id,
+          code: '123',
+        });
+
+      expect(res.status).equals(200);
+    });
+  });
+
+  describe('GET: `/accounts`', () => {
+    it('Should retrieve chart of accounts', async () => {
+      await tenantFactory.create('resource', { name: 'accounts' });
+      const account = await tenantFactory.create('account');
+      await tenantFactory.create('account', { parent_account_id: account.id });
+
+      const res = await request()
+        .get('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(200);
+      expect(res.body.accounts.length).above(0);
+    });
+
+    it('Should retrieve accounts based on view roles conditionals of the custom view.', async () => {
+      const resource = await tenantFactory.create('resource', { name: 'accounts' });
+      
+      const accountTypeField = await tenantFactory.create('resource_field', {
+        label_name: 'Account type',
+        key: 'type',
+        resource_id: resource.id,
+        active: true,
+        predefined: true,
+      });
+
+      const accountNameField = await tenantFactory.create('resource_field', {
+        label_name: 'Account Name',
+        key: 'name',
+        resource_id: resource.id,
+        active: true,
+        predefined: true,
+      });
+      const accountsView = await tenantFactory.create('view', {
+        name: 'Accounts View',
+        resource_id: resource.id,
+        roles_logic_expression: '1 AND 2',
+      });
+      const accountType = await tenantFactory.create('account_type');
+
+      await tenantFactory.create('view_role', {
+        view_id: accountsView.id,
+        index: 1,
+        field_id: accountTypeField.id,
+        value: accountType.name,
+        comparator: 'equals',
+      });
+      await tenantFactory.create('view_role', {
+        view_id: accountsView.id,
+        index: 2,
+        field_id: accountNameField.id,
+        value: 'account',
+        comparator: 'contains',
+      });
+
+      await tenantFactory.create('account', { name: 'account-1', account_type_id: accountType.id });
+      await tenantFactory.create('account', { name: 'account-2', account_type_id: accountType.id });
+      await tenantFactory.create('account', { name: 'account-3' });
+
+      const res = await request()
+        .get('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          custom_view_id: accountsView.id
+        })
+        .send();
+
+      expect(res.body.accounts.length).equals(2);
+      expect(res.body.accounts[0].name).equals('account-1');
+      expect(res.body.accounts[1].name).equals('account-2');
+      expect(res.body.accounts[0].account_type_id).equals(accountType.id);
+      expect(res.body.accounts[1].account_type_id).equals(accountType.id); 
+    });
+
+    it('Should retrieve accounts based on view roles conditionals with relation join column.', async () => {
+      const resource = await tenantFactory.create('resource', { name: 'accounts' });
+      
+      const accountTypeField = await tenantFactory.create('resource_field', {
+        label_name: 'Account type',
+        key: 'type',
+        resource_id: resource.id,
+        active: true,
+        predefined: true,
+      });
+      const accountsView = await tenantFactory.create('view', {
+        name: 'Accounts View',
+        resource_id: resource.id,
+        roles_logic_expression: '1',
+      });
+
+      const accountType = await tenantFactory.create('account_type');
+      const accountsViewRole = await tenantFactory.create('view_role', {
+        view_id: accountsView.id,
+        index: 1,
+        field_id: accountTypeField.id,
+        value: accountType.name,
+        comparator: 'equals',
+      });
+
+      await tenantFactory.create('account', { account_type_id: accountType.id });
+      await tenantFactory.create('account');
+      await tenantFactory.create('account');
+
+      const res = await request()
+        .get('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          custom_view_id: accountsView.id
+        })
+        .send();
+
+      expect(res.body.accounts.length).equals(1);
+      expect(res.body.accounts[0].account_type_id).equals(accountType.id);
+    });
+
+    it('Should retrieve accounts and child accounts in nested set graph.', async () => {
+      const resource = await tenantFactory.create('resource', { name: 'accounts' });
+
+      const account1 = await tenantFactory.create('account');
+      const account2 = await tenantFactory.create('account', { parent_account_id: account1.id });
+      const account3 = await tenantFactory.create('account', { parent_account_id: account2.id });
+
+      const res = await request()
+        .get('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(200);
+
+      const foundAccount = res.body.accounts.find(a => a.id === account1.id);
+
+      expect(foundAccount.id).equals(account1.id);
+      expect(foundAccount.children[0].id).equals(account2.id);
+      expect(foundAccount.children[0].children[0].id).equals(account3.id);
+    });
+
+    it('Should retrieve bad request when `filter_roles.*.comparator` not associated to `field_key`.', () => {
+
+    });
+
+    it('Should retrieve bad request when `filter_roles.*.field_key` not found in accounts resource.', async () => {
+      const resource = await tenantFactory.create('resource', { name: 'accounts' });
+
+      const account1 = await tenantFactory.create('account', { name: 'ahmed' });
+      const account2 = await tenantFactory.create('account');
+      const account3 = await tenantFactory.create('account');
+
+      const res = await request()
+        .get('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          stringified_filter_roles: JSON.stringify([{
+            condition: 'AND',
+            field_key: 'not_found',
+            comparator: 'equals',
+            value: 'ahmed',
+          }, { 
+            condition: 'AND',
+            field_key: 'mybe_found',
+            comparator: 'equals',
+            value: 'ahmed',
+          }]),
+        });
+
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'ACCOUNTS.RESOURCE.HAS.NO.GIVEN.FIELDS', code: 500,
+      });
+    });
+
+    it('Should retrieve bad request when `filter_roles.*.condition` is invalid.', async () => {
+
+    });
+
+    it('Should retrieve filtered accounts according to the given account type filter condition.', async () => {
+      const resource = await tenantFactory.create('resource', { name: 'accounts' });
+      const keyField = await tenantFactory.create('resource_field', {
+        key: 'type',
+        resource_id: resource.id,
+      });
+      const nameFiled = await tenantFactory.create('resource_field', {
+        key: 'name',
+        resource_id: resource.id,
+      });
+      const accountType = await tenantFactory.create('account_type');
+
+      const account1 = await tenantFactory.create('account', {
+        name: 'ahmed',
+        account_type_id: accountType.id
+      });
+      const account2 = await tenantFactory.create('account');
+      const account3 = await tenantFactory.create('account');
+
+      const res = await request()
+        .get('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          stringified_filter_roles: JSON.stringify([{
+            condition: '&&',
+            field_key: 'type',
+            comparator: 'equals',
+            value: accountType.name,
+          }, {
+            condition: '&&',
+            field_key: 'name',
+            comparator: 'equals',
+            value: 'ahmed', 
+          }]),
+        });
+
+      expect(res.body.accounts.length).equals(1);
+    });
+
+    it('Shoud retrieve filtered accounts according to the given account description filter condition.', async () => {
+      const resource = await tenantFactory.create('resource', { name: 'accounts' });
+      const resourceField = await tenantFactory.create('resource_field', {
+        key: 'description',
+        resource_id: resource.id,
+      });
+
+      const account1 = await tenantFactory.create('account', { name: 'ahmed', description: 'here' });
+      const account2 = await tenantFactory.create('account');
+      const account3 = await tenantFactory.create('account');
+
+      const res = await request()
+        .get('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          stringified_filter_roles: JSON.stringify([{
+            condition: 'AND',
+            field_key: resourceField.key,
+            comparator: 'contain',
+            value: 'here',
+          }]),
+        });
+
+      expect(res.body.accounts.length).equals(1);
+      expect(res.body.accounts[0].description).equals('here');
+    });
+
+    it('Should retrieve filtered accounts based on given filter roles between OR conditions.', async () => {
+      const resource = await tenantFactory.create('resource', { name: 'accounts' });
+      const resourceField = await tenantFactory.create('resource_field', {
+        key: 'description',
+        resource_id: resource.id,
+      });
+
+      const resourceCodeField = await tenantFactory.create('resource_field', {
+        key: 'code',
+        resource_id: resource.id,
+      });
+
+      const account1 = await tenantFactory.create('account', { name: 'ahmed', description: 'target' });
+      const account2 = await tenantFactory.create('account', { description: 'target' });
+      const account3 = await tenantFactory.create('account');
+
+      const res = await request()
+        .get('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          stringified_filter_roles: JSON.stringify([{
+            condition: '&&',
+            field_key: resourceField.key,
+            comparator: 'contain',
+            value: 'target',
+          }, {
+            condition: '||',
+            field_key: resourceCodeField.key,
+            comparator: 'equals',
+            value: 'ahmed',
+          }]),
+        });
+
+      expect(res.body.accounts.length).equals(2);
+      expect(res.body.accounts[0].description).equals('target');
+      expect(res.body.accounts[1].description).equals('target');
+      expect(res.body.accounts[0].name).equals('ahmed');
+    });
+
+    it('Should retrieve filtered accounts from custom view and filter roles.', async () => {
+      const resource = await tenantFactory.create('resource', { name: 'accounts' });
+      const accountTypeField = await tenantFactory.create('resource_field', {
+        key: 'type', resource_id: resource.id,
+      });
+      const accountDescriptionField = await tenantFactory.create('resource_field', {
+        key: 'description', resource_id: resource.id,
+      });
+
+      const accountType = await tenantFactory.create('account_type', { name: 'type-name' });
+
+      const account1 = await tenantFactory.create('account', { name: 'ahmed-1' });
+      const account2 = await tenantFactory.create('account', { name: 'ahmed-2', account_type_id: accountType.id, description: 'target' });
+      const account3 = await tenantFactory.create('account', { name: 'ahmed-3' });
+
+      const accountsView = await tenantFactory.create('view', {
+        name: 'Accounts View',
+        resource_id: resource.id,
+        roles_logic_expression: '1',
+      });
+      const accountsViewRole = await tenantFactory.create('view_role', {
+        view_id: accountsView.id,
+        field_id: accountTypeField.id,
+        index: 1,
+        value: 'type-name',
+        comparator: 'equals',
+      });
+
+      const res = await request()
+        .get('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          custom_view_id: accountsView.id,
+          stringified_filter_roles: JSON.stringify([{
+            condition: 'AND',
+            field_key: 'description',
+            comparator: 'contain',
+            value: 'target',
+          }]),
+        });
+
+      expect(res.body.accounts.length).equals(1);
+      expect(res.body.accounts[0].name).equals('ahmed-2');
+      expect(res.body.accounts[0].description).equals('target');
+    });
+
+    it('Should validate the given `column_sort_order` column on the accounts resource.', async () => {
+      const resource = await tenantFactory.create('resource', { name: 'accounts' });
+      const res = await request()
+        .get('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({ 
+          column_sort_by: 'not_found',
+          sort_order: 'desc',
+        });
+      
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'COLUMN.SORT.ORDER.NOT.FOUND', code: 300,
+      });
+    });
+
+    it('Should sorting the given `column_sort_order` column on asc direction,', async () => {
+      const resource = await tenantFactory.create('resource', { name: 'accounts' });
+      const resourceField = await tenantFactory.create('resource_field', {
+        key: 'name', resource_id: resource.id,
+      });
+      const accounts1 = await tenantFactory.create('account', { name: 'A' });
+      const accounts2 = await tenantFactory.create('account', { name: 'B' });
+
+      const res = await request()
+        .get('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          column_sort_by: 'name',
+          sort_order: 'asc',
+        });
+
+      const AAccountIndex = res.body.accounts.findIndex(a => a.name === 'B');
+      const BAccountIndex = res.body.accounts.findIndex(a => a.name === 'A');
+      
+      expect(AAccountIndex).above(BAccountIndex);
+    });
+
+    it('Should sorting the given `column_sort_order` columnw with relation on another table on asc direction.', async () => {
+      const resource = await tenantFactory.create('resource', { name: 'accounts' });
+      const resourceField = await tenantFactory.create('resource_field', {
+        key: 'type', resource_id: resource.id,
+      });
+      const accounts1 = await tenantFactory.create('account', { name: 'A' });
+      const accounts2 = await tenantFactory.create('account', { name: 'B' });
+
+      const res = await request()
+        .get('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          column_sort_by: 'name',
+          sort_order: 'asc',
+        });
+
+      expect(res.body.accounts[0].name).equals('A');
+      expect(res.body.accounts[1].name).equals('B');
+    });
+  });
+
+  describe('DELETE: `/accounts`', () => {
+    it('Should response not found in case account was not exist.', async () => {
+      const res = await request()
+        .delete('/api/accounts/10')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+    });
+
+    it('Should delete the give account from the storage.', async () => {
+      const account = await tenantFactory.create('account');
+      await request()
+        .delete(`/api/accounts/${account.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      const foundAccounts = await Account.tenant().query().where('id', account.id);
+      expect(foundAccounts).to.have.lengthOf(0);
+    });
+
+    it('Should not delete the given account in case account has associated transactions.', async () => {
+      const accountTransaction = await tenantFactory.create('account_transaction');
+
+      const res = await request()
+        .delete(`/api/accounts/${accountTransaction.accountId}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'ACCOUNT.HAS.ASSOCIATED.TRANSACTIONS', code: 100,
+      });
+    });
+  });
+
+  describe('DELETE: `/accounts?ids=`', () => {
+    it('Should response in case on of accounts ids was not exists.', async () => {
+      const res = await request()
+        .delete('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [100, 200],
+        })
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'ACCOUNTS.IDS.NOT.FOUND', code: 200, ids: [100, 200],
+      });
+    });
+
+    it('Should response bad request in case one of accounts has transactions.', async () => {
+      const accountTransaction = await tenantFactory.create('account_transaction');
+      const accountTransaction2 = await tenantFactory.create('account_transaction');
+
+      const res = await request()
+        .delete('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [accountTransaction.accountId, accountTransaction2.accountId],
+        })
+        .send();
+
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'ACCOUNT.HAS.ASSOCIATED.TRANSACTIONS',
+        code: 300,
+        ids: [accountTransaction.accountId, accountTransaction2.accountId],
+      });
+    });
+
+    it('Should delete the given accounts from the storage.', async () => {
+      const account1 = await tenantFactory.create('account');
+      const account2 = await tenantFactory.create('account');
+
+      const res = await request()
+        .delete('/api/accounts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [account1.id, account2.id],
+        })
+        .send();
+
+      expect(res.status).equals(200);
+
+      const foundAccounts = await Account.tenant().query()
+        .whereIn('id', [account1.id, account2.id]);
+
+      expect(foundAccounts.length).equals(0);
+    });
+  });
+
+  describe('POST: `/api/accounts/bulk/activate|inactivate', () => {
+    it('Should response if there one of accounts ids were not found.', async () => {
+      const res = await request()
+        .post('/api/accounts/bulk/activate')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [123123, 321321],
+        })
+        .send();
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'ACCOUNTS.NOT.FOUND', code: 200,
+      });
+    });
+
+    it('Should activate all the given accounts.', async () => {
+      const accountA = await tenantFactory.create('account', { active: 1 });
+      const accountB = await tenantFactory.create('account', { active: 1 });
+      
+      const res = await request()
+        .post('/api/accounts/bulk/inactivate')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [accountA.id, accountB.id],
+        })
+        .send();
+
+      const updatedAccounts = await Account.tenant().query().whereIn('id', [accountA.id, accountB.id]);
+
+      expect(updatedAccounts[0].active).equals(0);
+      expect(updatedAccounts[1].active).equals(0);
+    });
+
+    it('Should inactivate all the given accounts.', async () => {
+      const accountA = await tenantFactory.create('account', { active: 0 });
+      const accountB = await tenantFactory.create('account', { active: 0 });
+      
+      const res = await request()
+        .post('/api/accounts/bulk/activate')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [accountA.id, accountB.id],
+        })
+        .send();
+
+      const updatedAccounts = await Account.tenant().query().whereIn('id', [accountA.id, accountB.id]);
+
+      expect(updatedAccounts[0].active).equals(1);
+      expect(updatedAccounts[1].active).equals(1);
+    });
+  });
+});
diff --git a/packages/server/tests/routes/auth.test.js b/packages/server/tests/routes/auth.test.js
new file mode 100644
index 000000000..69226bad8
--- /dev/null
+++ b/packages/server/tests/routes/auth.test.js
@@ -0,0 +1,288 @@
+import { request, expect, createUser } from '~/testInit';
+import { hashPassword } from 'utils';
+import knex from '@/database/knex';
+import {
+  tenantWebsite,
+  tenantFactory,
+  systemFactory,
+  loginRes
+} from '~/dbInit';
+import TenantUser from 'models/TenantUser';
+import PasswordReset from '@/system/models/PasswordReset';
+import SystemUser from '@/system/models/SystemUser';
+
+
+describe('routes: /auth/', () => {
+  describe('POST `/api/auth/login`', () => {
+    it('Should `crediential` be required.', async () => {
+      const res = await request().post('/api/auth/login').send({});
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+
+      const paramsErrors = res.body.errors.map((error) => error.param);
+      expect(paramsErrors).to.include('crediential');
+    });
+
+    it('Should `password` be required.', async () => {
+      const res = await request().post('/api/auth/login').send();
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+
+      const paramsErrors = res.body.errors.map((error) => error.param);
+      expect(paramsErrors).to.include('password');
+    });
+
+    it('Should the min length of the `password` be 5 ch.', async () => {
+      const res = await request().post('/api/auth/login').send({
+        crediential: 'admin@admin.com',
+        password: 'test',
+      });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+
+      const paramsErrors = res.body.errors.map((error) => error.param);
+      expect(paramsErrors).to.include('password');
+    });
+
+    it('Should be a valid email format in crediential attribute.', async () => {
+      const res = await request().post('/api/auth/login').send({
+        crediential: 'admin',
+        password: 'test',
+      });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+
+      const paramsErrors = res.body.errors.map((error) => error.param);
+      expect(paramsErrors).to.include('password');
+    });
+
+    it('Should not authenticate with wrong user email and password.', async () => {
+      const res = await request().post('/api/auth/login').send({
+        crediential: 'admin@admin.com',
+        password: 'admin',
+      });
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'INVALID_DETAILS', code: 100,
+      });
+    });
+
+    it('Should not authenticate in case user was not active.', async () => {
+      const user = await createUser(tenantWebsite, {
+        active: false,
+        email: 'admin@admin.com',
+      });
+
+      const res = await request().post('/api/auth/login').send({
+        crediential: 'admin@admin.com',
+        password: 'admin',
+      });
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'USER_INACTIVE', code: 110,
+      });
+    });
+
+    it('Should authenticate with correct email and password and active user.', async () => {
+      const user = await createUser(tenantWebsite, {
+        email: 'admin@admin.com',
+      });
+      const res = await request().post('/api/auth/login').send({
+        crediential: user.email,
+        password: 'admin',
+      });
+      expect(res.status).equals(200);
+    });
+
+    it('Should autheticate success with correct phone number and password.', async () => {
+      const password = await hashPassword('admin');
+      const user = await createUser(tenantWebsite, {
+        phone_number: '0920000000',
+        password,
+      });
+      const res = await request().post('/api/auth/login').send({
+        crediential: user.email,
+        password: 'admin',
+      });
+
+      expect(res.status).equals(200);
+    });
+
+    it('Should last login date be saved after success login.', async () => {
+      const user = await createUser(tenantWebsite, {
+        email: 'admin@admin.com',
+      });
+      const res = await request().post('/api/auth/login').send({
+        crediential: user.email,
+        password: 'admin',
+      });
+      const foundUserAfterUpdate = await TenantUser.tenant().query()
+        .where('email', user.email)
+        .where('first_name', user.first_name)
+        .first();
+ 
+      expect(res.status).equals(200);
+      expect(foundUserAfterUpdate.lastLoginAt).to.not.be.null;
+    });
+  });
+
+  describe('POST: `/auth/send_reset_password`', () => {
+    it('Should `email` be required.', async () => {
+      const res = await request().post('/api/auth/send_reset_password').send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+    });
+
+    it('Should response unproccessable if the email address was invalid.', async () => {
+      const res = await request().post('/api/auth/send_reset_password').send({
+        email: 'invalid_email',
+      });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+    });
+
+    it('Should response unproccessable if the email address was not exist.', async () => {
+      const res = await request().post('/api/auth/send_reset_password').send({
+        email: 'admin@admin.com',
+      });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'EMAIL.NOT.REGISTERED', code: 200,
+      });
+    });
+
+    it('Should delete all already tokens that associate to the given email.', async () => {
+      const user = await createUser(tenantWebsite);
+      const token = '123123';
+
+      await knex('password_resets').insert({ email: user.email, token });
+
+      await request().post('/api/auth/send_reset_password').send({
+        email: user.email,
+      });
+
+      const oldPasswordToken = await knex('password_resets').where('token', token);
+
+      expect(oldPasswordToken).to.have.lengthOf(0);
+    });
+
+    it('Should store new token associate with the given email.', async () => {
+      const user = await createUser(tenantWebsite);
+      await request().post('/api/auth/send_reset_password').send({
+        email: user.email,
+      });
+
+      const token = await knex('password_resets').where('email', user.email);
+
+      expect(token).to.have.lengthOf(1);
+    });
+
+    it('Should response success if the email was exist.', async () => {
+      const user = await createUser(tenantWebsite);
+      const res = await request().post('/api/auth/send_reset_password').send({
+        email: user.email,
+      });
+
+      expect(res.status).equals(200);
+    });
+  });
+
+  describe('POST: `/auth/reset/:token`', () => {
+    // it('Should response forbidden if the token was invalid.', () => {
+
+    // });
+
+    it('Should response forbidden if the token was expired.', () => {
+
+    });
+
+    it('Should `password` be required.', async () => {
+      const user = await createUser(tenantWebsite);
+      const passwordReset = await systemFactory.create('password_reset', {
+        email: user.email,
+      });
+
+      const res = await request()
+        .post(`/api/auth/reset/${passwordReset.token}`)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+
+      const paramsErrors = res.body.errors.map((error) => error.param);
+      expect(paramsErrors).to.include('password');
+    });
+
+    it('Should password and confirm_password be equal.', async () => {
+      const user = await createUser(tenantWebsite);
+      const passwordReset = await systemFactory.create('password_reset', {
+        email: user.email,
+      });
+
+      const res = await request()
+        .post(`/api/auth/reset/${passwordReset.token}`)
+        .send({
+          password: '123123',
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+
+      const paramsErrors = res.body.errors.map((error) => error.param);
+      expect(paramsErrors).to.include('password');
+    });
+
+    it('Should response success with correct data form.', async () => {
+      const user = await createUser(tenantWebsite);
+      const passwordReset = await systemFactory.create('password_reset', {
+        email: user.email,
+      });
+
+      const res = await request()
+        .post(`/api/auth/reset/${passwordReset.token}`)
+        .send({
+          password: '123123',
+          confirm_password: '123123',
+        });
+      expect(res.status).equals(200);
+    });
+
+    it('Should token be deleted after success response.', async () => {
+      const user = await createUser(tenantWebsite);
+      const passwordReset = await systemFactory.create('password_reset', {
+        email: user.email,
+      });
+      await request()
+        .post(`/api/auth/reset/${passwordReset.token}`)
+        .send({
+          password: '123123',
+          confirm_password: '123123',
+        });
+
+      const foundTokens = await PasswordReset.query().where('email', passwordReset.email);
+
+      expect(foundTokens).to.have.lengthOf(0);
+    });
+
+    it('Should password be updated after success response.', async () => {
+      const user = await createUser(tenantWebsite);
+      const passwordReset = await systemFactory.create('password_reset', {
+        email: user.email,
+      });
+
+      const res = await request().post(`/api/auth/reset/${passwordReset.token}`).send({
+        password: '123123',
+        confirm_password: '123123',
+      });
+      const systemUserPasswordUpdated = await SystemUser.query()
+        .where('id', user.id).first();
+
+      expect(systemUserPasswordUpdated.id).equals(user.id);
+      expect(systemUserPasswordUpdated.password).not.equals(user.password);
+    });
+  });
+});
diff --git a/packages/server/tests/routes/balance_sheet.test.js b/packages/server/tests/routes/balance_sheet.test.js
new file mode 100644
index 000000000..d3260e09d
--- /dev/null
+++ b/packages/server/tests/routes/balance_sheet.test.js
@@ -0,0 +1,541 @@
+import moment from 'moment';
+import {
+  request,
+  expect,
+} from '~/testInit';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+import { iteratee } from 'lodash';
+
+let creditAccount;
+let debitAccount;
+let incomeAccount;
+let incomeType;
+
+describe('routes: `/financial_statements`', () => {
+  beforeEach(async () => {
+    const accountTransactionMixied = { date: '2020-1-10' };
+
+    // Expense --
+    // 1000 Credit  - Cash account 
+    //    1000 Debit - Bank account.
+    await tenantFactory.create('account_transaction', {
+      credit: 1000, debit: 0, account_id: 2, referenceType: 'Expense',
+      referenceId: 1, ...accountTransactionMixied,
+    });
+    await tenantFactory.create('account_transaction', {
+      credit: 0, debit: 1000, account_id: 7, referenceType: 'Expense',
+      referenceId: 1, ...accountTransactionMixied,
+    });
+
+    // Jounral
+    // 4000 Credit - Opening balance account.
+    //     2000 Debit - Bank account
+    //     2000 Debit - Bank account
+    await tenantFactory.create('account_transaction', {
+      credit: 4000, debit: 0, account_id: 5, ...accountTransactionMixied,
+    });
+    await tenantFactory.create('account_transaction', {
+      debit: 2000, credit: 0, account_id: 2, ...accountTransactionMixied,
+    });
+    await tenantFactory.create('account_transaction', {
+      debit: 2000, credit: 0, account_id: 2, ...accountTransactionMixied,
+    });
+
+    // Income Journal.
+    // 2000 Credit - Income account.
+    //    2000 Debit - Bank account.
+    await tenantFactory.create('account_transaction', {
+      credit: 2000, account_id: 4, ...accountTransactionMixied
+    });
+    await tenantFactory.create('account_transaction', {
+      debit: 2000, credit: 0, account_id: 2, ...accountTransactionMixied,
+    });
+
+    // -----------------------------------------
+    // Bank account balance  = 5000  |  Opening balance account balance = 4000
+    // Expense account balance = 1000  |  Income account balance   = 2000
+  });
+ 
+  describe('routes: `financial_statements/balance_sheet`', () => {
+    it('Should response unauthorzied in case the user was not authorized.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .send();
+
+      expect(res.status).equals(401);
+    });
+
+    it('Should retrieve query of the balance sheet with default values.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          display_columns_by: 'year',
+          from_date: '2020-01-01',
+          to_date: '2020-02-01',
+        })
+        .send();
+
+      expect(res.body.query.display_columns_by).equals('year');
+      expect(res.body.query.from_date).equals('2020-01-01');
+      expect(res.body.query.to_date).equals('2020-02-01');
+
+      expect(res.body.query.number_format.no_cents).equals(false);
+      expect(res.body.query.number_format.divide_1000).equals(false);
+
+      expect(res.body.query.none_zero).equals(false);
+    });
+
+    it('Should retrieve assets and liabilities/equity section.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          display_columns_by: 'year',
+        })
+        .send();
+
+      expect(res.body.balance_sheet[0].name).equals('Assets');
+      expect(res.body.balance_sheet[1].name).equals('Liabilities and Equity');
+
+      expect(res.body.balance_sheet[0].section_type).equals('assets');
+      expect(res.body.balance_sheet[1].section_type).equals('liabilities_equity');
+
+      expect(res.body.balance_sheet[0].type).equals('section');
+      expect(res.body.balance_sheet[1].type).equals('section');
+    });
+
+    it('Should retrieve assets and liabilities/equity total of each section.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          to_date: '2020-12-10',
+        })
+        .send();
+
+      expect(res.body.balance_sheet[0].total.amount).equals(5000);
+      expect(res.body.balance_sheet[1].total.amount).equals(4000);
+    });
+
+    it('Should retrieve the asset and liabilities/equity accounts.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          display_columns_type: 'total',
+          from_date: '2012-01-01',
+          to_date: '2032-02-02',
+        })
+        .send();
+
+      expect(res.body.balance_sheet[0].children).to.be.a('array');
+      expect(res.body.balance_sheet[0].children).to.be.a('array');
+
+      expect(res.body.balance_sheet[0].children.length).is.not.equals(0);
+      expect(res.body.balance_sheet[1].children.length).is.not.equals(0);
+
+      expect(res.body.balance_sheet[1].children[0].children.length).is.not.equals(0);
+      expect(res.body.balance_sheet[1].children[1].children.length).is.not.equals(0);
+    });
+
+    it('Should retrieve assets/liabilities total balance between the given date range.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          display_columns_type: 'total',
+          from_date: '2012-01-01',
+          to_date: '2032-02-02',
+        })
+        .send();
+
+      expect(res.body.accounts[0].children).include.something.deep.equals({
+        id: 1001,
+        index: null,
+        name: debitAccount.name,
+        code: debitAccount.code,
+        parentAccountId: null,
+        children: [],
+        total: { formatted_amount: 5000, amount: 5000, date: '2032-02-02' }
+      });
+
+      expect(res.body.accounts[1].children).include.something.deep.equals({        
+        id: 1000,
+        index: null,
+        name: creditAccount.name,
+        code: creditAccount.code,
+        parentAccountId: null,
+        children: [],
+        total: { formatted_amount: 4000, amount: 4000, date: '2032-02-02' }
+      });
+    });
+
+    it('Should retrieve asset/liabilities balance sheet with display columns by `year`.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          display_columns_by: 'year',
+          display_columns_type: 'date_periods',
+          from_date: '2012-01-01',
+          to_date: '2018-02-02',
+        })
+        .send();
+
+      expect(res.body.accounts[0].children[0].total_periods.length).equals(7);
+      expect(res.body.accounts[1].children[0].total_periods.length).equals(7);
+
+      expect(res.body.accounts[0].children[0].total_periods).deep.equals([
+        {
+          amount: 0,
+          formatted_amount: 0,
+          date: '2012',
+        },
+        {
+          amount: 0,
+          formatted_amount: 0,
+          date: '2013',
+        },
+        {
+          amount: 0,
+          formatted_amount: 0,
+          date: '2014',
+        },
+        {
+          amount: 0,
+          formatted_amount: 0,
+          date: '2015',
+        },
+        {
+          amount: 0,
+          formatted_amount: 0,
+          date: '2016',
+        },
+        {
+          amount: 0,
+          formatted_amount: 0,
+          date: '2017',
+        },
+        {
+          amount: 0,
+          formatted_amount: 0,
+          date: '2018',
+        },
+      ]);
+    });
+
+    it('Should retrieve balance sheet with display columns by `day`.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          display_columns_by: 'day',
+          display_columns_type: 'date_periods',
+          from_date: '2020-01-08',
+          to_date: '2020-01-12',
+        })
+        .send();
+
+      expect(res.body.accounts[0].children).include.something.deep.equals({
+        id: debitAccount.id,
+        index: debitAccount.index,
+        name: debitAccount.name,
+        code: debitAccount.code,
+        parentAccountId: null,
+        children: [],
+        total_periods: [
+          { date: '2020-01-08', formatted_amount: 0, amount: 0 },
+          { date: '2020-01-09', formatted_amount: 0, amount: 0 },
+          { date: '2020-01-10', formatted_amount: 5000, amount: 5000 },
+          { date: '2020-01-11', formatted_amount: 5000, amount: 5000 },
+          { date: '2020-01-12', formatted_amount: 5000, amount: 5000 },
+        ],
+        total: { formatted_amount: 5000, amount: 5000, date: '2020-01-12' }
+      });
+      expect(res.body.accounts[1].children).include.something.deep.equals({
+        id: creditAccount.id,
+        index: creditAccount.index,
+        name: creditAccount.name,
+        code: creditAccount.code,
+        parentAccountId: null,
+        children: [],
+        total_periods: [
+          { date: '2020-01-08', formatted_amount: 0, amount: 0 },
+          { date: '2020-01-09', formatted_amount: 0, amount: 0 },
+          { date: '2020-01-10', formatted_amount: 4000, amount: 4000 },
+          { date: '2020-01-11', formatted_amount: 4000, amount: 4000 },
+          { date: '2020-01-12', formatted_amount: 4000, amount: 4000 }
+        ],
+        total: { formatted_amount: 4000, amount: 4000, date: '2020-01-12' }
+      });
+    });
+
+    it('Should retrieve the balance sheet with display columns by `month`.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          display_columns_by: 'month',
+          display_columns_type: 'date_periods',
+          from_date: '2019-07-01',
+          to_date: '2020-06-30',
+        })
+        .send();
+
+      expect(res.body.accounts[0].children).include.something.deep.equals({
+        id: debitAccount.id,
+        index: debitAccount.index,
+        name: debitAccount.name,
+        code: debitAccount.code,
+        parentAccountId: null,
+        children: [],
+        total_periods: [
+          { date: '2019-07', formatted_amount: 0, amount: 0 },
+          { date: '2019-08', formatted_amount: 0, amount: 0 },
+          { date: '2019-09', formatted_amount: 0, amount: 0 },
+          { date: '2019-10', formatted_amount: 0, amount: 0 },
+          { date: '2019-11', formatted_amount: 0, amount: 0 },
+          { date: '2019-12', formatted_amount: 0, amount: 0 },
+          { date: '2020-01', formatted_amount: 5000, amount: 5000 },
+          { date: '2020-02', formatted_amount: 5000, amount: 5000 },
+          { date: '2020-03', formatted_amount: 5000, amount: 5000 },
+          { date: '2020-04', formatted_amount: 5000, amount: 5000 },
+          { date: '2020-05', formatted_amount: 5000, amount: 5000 },
+          { date: '2020-06', formatted_amount: 5000, amount: 5000 },
+        ],
+        total: { formatted_amount: 5000, amount: 5000, date: '2020-06-30' } 
+      });
+    });
+
+    it('Should retrieve the balance sheet with display columns `quarter`.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          display_columns_by: 'quarter',
+          display_columns_type: 'date_periods',
+          from_date: '2020-01-01',
+          to_date: '2020-12-31',
+        })
+        .send();
+
+      expect(res.body.accounts[0].children).include.something.deep.equals({
+        id: debitAccount.id,
+        index: debitAccount.index,
+        name: debitAccount.name,
+        code: debitAccount.code,
+        parentAccountId: null,
+        children: [],
+        total_periods: [
+          { date: '2020-03', formatted_amount: 5000, amount: 5000 },
+          { date: '2020-06', formatted_amount: 5000, amount: 5000 },
+          { date: '2020-09', formatted_amount: 5000, amount: 5000 },
+          { date: '2020-12', formatted_amount: 5000, amount: 5000 },
+        ],
+        total: { formatted_amount: 5000, amount: 5000, date: '2020-12-31' },
+      });
+    });
+
+    it('Should retrieve the balance sheet amounts without cents.', async () => {
+      await tenantFactory.create('account_transaction', {
+        debit: 0.25, credit: 0, account_id: debitAccount.id, date: '2020-1-10',
+      });
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          display_columns_by: 'quarter',
+          display_columns_type: 'date_periods',
+          from_date: '2020-01-01',
+          to_date: '2020-12-31',
+          number_format: {
+            no_cents: true,
+          },
+        })
+        .send();
+
+      expect(res.body.accounts[0].children).include.something.deep.equals({
+        id: debitAccount.id,
+        index: debitAccount.index,
+        name: debitAccount.name,
+        code: debitAccount.code,
+        parentAccountId: null,
+        children: [],
+        total_periods: [
+          { date: '2020-03', formatted_amount: 5000, amount: 5000.25 },
+          { date: '2020-06', formatted_amount: 5000, amount: 5000.25 },
+          { date: '2020-09', formatted_amount: 5000, amount: 5000.25 },
+          { date: '2020-12', formatted_amount: 5000, amount: 5000.25 },  
+        ],
+        total: { formatted_amount: 5000, amount: 5000.25, date: '2020-12-31' },
+      });
+    });
+
+    it('Should retrieve the balance sheet amounts divided on 1000.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          display_columns_by: 'quarter',
+          display_columns_type: 'date_periods',
+          from_date: '2020',
+          to_date: '2021',
+          number_format: {
+            divide_1000: true,
+          },
+        })
+        .send();
+      
+      expect(res.body.accounts[0].children).include.something.deep.equals({
+        id: debitAccount.id,
+        index: debitAccount.index,
+        name: debitAccount.name,
+        code: debitAccount.code,
+        parentAccountId: null,
+        children: [],
+        total_periods: [
+          { date: '2020-03', formatted_amount: 5, amount: 5000 },
+          { date: '2020-06', formatted_amount: 5, amount: 5000 },
+          { date: '2020-09', formatted_amount: 5, amount: 5000 },
+          { date: '2020-12', formatted_amount: 5, amount: 5000 },
+          { date: '2021-03', formatted_amount: 5, amount: 5000 },
+        ],
+        total: { formatted_amount: 5, amount: 5000, date: '2021' },
+      });
+    });
+
+    it('Should not retrieve accounts has no transactions between the given date range in case query none_zero is true.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          display_columns_by: 'quarter',
+          from_date: '2002',
+          to_date: '2003',
+          number_format: {
+            divide_1000: true,
+          },
+          none_zero: true,
+        })
+        .send();
+
+      expect(res.body.accounts[0].children.length).equals(0);
+      expect(res.body.accounts[1].children.length).equals(0);
+    });
+
+    it('Should retrieve accounts in nested structure parent and children accounts.', async () => {
+      const childAccount = await tenantFactory.create('account', {
+        parent_account_id: debitAccount.id,
+        account_type_id: 1
+      });
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          none_zero: false,
+          account_ids: [childAccount.id, debitAccount.id]
+        })
+        .send();
+
+      expect(res.body.accounts[0].children).include.something.deep.equals({
+        id: debitAccount.id,
+        index: null,
+        name: debitAccount.name,
+        code: debitAccount.code,
+        parentAccountId: null,
+        total: { formatted_amount: 5000, amount: 5000, date: '2020-12-31' },
+        children: [
+          {
+            id: childAccount.id,
+            index: null,
+            name: childAccount.name,
+            code: childAccount.code,
+            parentAccountId: debitAccount.id,
+            total: { formatted_amount: 0, amount: 0, date: '2020-12-31' },
+            children: [],
+          }
+        ]
+      });
+    });
+    
+    it('Should parent account balance sumation of total balane all children accounts.', async () => {
+      const childAccount = await tenantFactory.create('account', {
+        parent_account_id: debitAccount.id,
+        account_type_id: 1
+      });
+      await tenantFactory.create('account_transaction', {
+        credit: 0, debit: 1000, account_id: childAccount.id, date: '2020-1-10'
+      });
+
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          none_zero: false,
+          account_ids: [childAccount.id, debitAccount.id]
+        })
+        .send();
+
+      expect(res.body.accounts[0].children[0].total.amount).equals(6000);
+      expect(res.body.accounts[0].children[0].total.formatted_amount).equals(6000);
+    });
+
+    it('Should parent account balance sumation of total periods amounts all children accounts.', async () => {
+      const childAccount = await tenantFactory.create('account', {
+        parent_account_id: debitAccount.id,
+        account_type_id: 1
+      });
+      await tenantFactory.create('account_transaction', {
+        credit: 0, debit: 1000, account_id: childAccount.id, date: '2020-2-10'
+      });
+
+      const res = await request()
+        .get('/api/financial_statements/balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          none_zero: false,
+          account_ids: [childAccount.id, debitAccount.id],
+          display_columns_type: 'date_periods',
+          display_columns_by: 'month',
+          from_date: '2020-01-01',
+          to_date: '2020-12-12',
+        })
+        .send();
+
+      expect(res.body.accounts[0].children[0].total_periods).deep.equals([
+        { amount: 5000, formatted_amount: 5000, date: '2020-01' },
+        { amount: 6000, formatted_amount: 6000, date: '2020-02' },
+        { amount: 6000, formatted_amount: 6000, date: '2020-03' },
+        { amount: 6000, formatted_amount: 6000, date: '2020-04' },
+        { amount: 6000, formatted_amount: 6000, date: '2020-05' },
+        { amount: 6000, formatted_amount: 6000, date: '2020-06' },
+        { amount: 6000, formatted_amount: 6000, date: '2020-07' },
+        { amount: 6000, formatted_amount: 6000, date: '2020-08' },
+        { amount: 6000, formatted_amount: 6000, date: '2020-09' },
+        { amount: 6000, formatted_amount: 6000, date: '2020-10' },
+        { amount: 6000, formatted_amount: 6000, date: '2020-11' },
+        { amount: 6000, formatted_amount: 6000, date: '2020-12' }
+      ])
+    });
+  });
+});
diff --git a/packages/server/tests/routes/bill_payments.test.js b/packages/server/tests/routes/bill_payments.test.js
new file mode 100644
index 000000000..5c7440125
--- /dev/null
+++ b/packages/server/tests/routes/bill_payments.test.js
@@ -0,0 +1,113 @@
+import {
+  request,
+  expect,
+} from '~/testInit';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+describe('route: `/api/purchases/bill_payments`', () => {
+  describe('POST: `/api/purchases/bill_payments`', () => {
+    it('Should `payment_date` be required.', async () => {
+      const res = await request()
+        .post('/api/purchases/bills')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'payment_date',
+        location: 'body',
+      });
+    });
+
+    it('Should `payment_account_id` be required.', async () => {
+      const res = await request()
+        .post('/api/purchases/bills')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'payment_account_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `payment_number` be required.', async () => {
+      const res = await request()
+        .post('/api/purchases/bills')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'payment_number',
+        location: 'body',
+      });
+    });
+
+    it('Should `entries.*.item_id` be required.', async () => {
+      const res = await request()
+        .post('/api/purchases/bills')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          entries: [{}],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'entries[0].item_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `payment_number` be unique on the storage.', () => {
+
+    });
+
+    it('Should `payment_account_id` be exists on the storage.', () => {
+
+    });
+
+    it('Should `entries.*.item_id` be exists on the storage.', () => {
+
+    });
+
+    it('Should store the given bill payment to the storage.', () => {
+
+    });
+  });
+
+  describe('POST: `/api/purchases/bill_payments/:id`', () => {
+    it('Should bill payment be exists on the storage.', () => {
+
+    });
+  });
+
+  describe('DELETE: `/api/purchases/bill_payments/:id`', () => {
+    it('Should bill payment be exists on the storage.', () => {
+
+    });
+
+    it('Should delete the given bill payment from the storage.', () => {
+
+    });    
+  });
+
+  describe('GET: `/api/purchases/bill_payments/:id`', () => {
+    it('Should bill payment be exists on the storage.', () => {
+
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/server/tests/routes/bills.test.js b/packages/server/tests/routes/bills.test.js
new file mode 100644
index 000000000..5ace5cec2
--- /dev/null
+++ b/packages/server/tests/routes/bills.test.js
@@ -0,0 +1,217 @@
+import {
+  request,
+  expect,
+} from '~/testInit';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+describe('route: `/api/purchases/bills`', () => {
+  describe('POST: `/api/purchases/bills`', () => {
+    it('Should `bill_number` be required.', async () => {
+      const res = await request()
+        .post('/api/purchases/bills')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'bill_number',
+        location: 'body',
+      });
+    });
+
+    it('Should `vendor_id` be required.', async () => {
+      const res = await request()
+        .post('/api/purchases/bills')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'vendor_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `bill_date` be required.', async () => {
+      const res = await request()
+        .post('/api/purchases/bills')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'bill_date',
+        location: 'body',
+      });
+    });
+
+    it('Should `entries` be minimum one', async () => {
+      const res = await request()
+        .post('/api/purchases/bills')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'entries',
+        location: 'body',
+      });
+    });
+
+    it('Should `entries.*.item_id be required.', async () => {
+      const res = await request()
+        .post('/api/purchases/bills')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          entries: [{
+
+          }]
+        });
+      expect(res.status).equals(422);
+      expecvt(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'entries[0].item_id',
+        location: 'body'
+      });
+    });
+
+    it('Should `entries.*.rate` be required.', async () => {
+      const res = await request()
+        .post('/api/purchases/bills')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          entries: [{
+
+          }]
+        });
+      expect(res.status).equals(422);
+      expecvt(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'entries[0].rate',
+        location: 'body'
+      });
+    });
+
+    it('Should `entries.*.discount` be required.', () => {
+
+    });
+
+    it('Should entries.*.quantity be required.', () => {
+
+    });
+
+
+    it('Should vendor_id be exists on the storage.', async () => {
+      const vendor = await tenantFactory.create('vendor');
+      const res = await request()
+        .post('/api/purchases/bills')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          vendor_id: vendor.id,
+          bill_number: '123',
+          bill_date: '2020-02-02',
+          entries: [{
+            item_id: 1,
+            rate: 1,
+            quantity: 1,
+          }]
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'VENDOR.ID.NOT.FOUND', code: 300,
+      })
+    });
+
+    it('Should entries.*.item_id be exists on the storage.', async () => {
+      const item = await tenantFactory.create('item');
+      const vendor = await tenantFactory.create('vendor');
+      const res = await request()
+        .post('/api/purchases/bills')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          vendor_id: vendor.id,
+          bill_number: '123',
+          bill_date: '2020-02-02',
+          entries: [{
+            item_id: 123123,
+            rate: 1,
+            quantity: 1,
+          }]
+        });
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'ITEMS.IDS.NOT.FOUND', code: 400,
+      });
+    });
+
+    it('Should validate the bill number is not exists on the storage.', async () => {
+      const item = await tenantFactory.create('item');
+      const vendor = await tenantFactory.create('vendor');
+      const bill = await tenantFactory.create('bill', { bill_number: '123' });
+
+      const res = await request()
+        .post('/api/purchases/bills')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          vendor_id: vendor.id,
+          bill_number: '123',
+          bill_date: '2020-02-02',
+          entries: [{
+            item_id: item.id,
+            rate: 1,
+            quantity: 1,
+          }]
+        }); 
+      
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'BILL.NUMBER.EXISTS', code: 500,
+      })
+    })
+
+    it('Should store the given bill details with associated entries to the storage.', async () => {
+      const item = await tenantFactory.create('item');
+      const vendor = await tenantFactory.create('vendor');
+      const res = await request()
+        .post('/api/purchases/bills')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          vendor_id: vendor.id,
+          bill_number: '123',
+          bill_date: '2020-02-02',
+          entries: [{
+            item_id: item.id,
+            rate: 1,
+            quantity: 1,
+          }]
+        });
+
+      expect(res.status).equals(200);
+    });
+
+    
+  });
+
+  describe('DELETE: `/api/purchases/bills/:id`', () => {
+
+  });
+});
\ No newline at end of file
diff --git a/packages/server/tests/routes/currencies.test.js b/packages/server/tests/routes/currencies.test.js
new file mode 100644
index 000000000..a6583c0cd
--- /dev/null
+++ b/packages/server/tests/routes/currencies.test.js
@@ -0,0 +1,191 @@
+import {
+  request,
+  expect,
+} from '~/testInit';
+import Currency from 'models/Currency';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+
+describe('route: /currencies/', () => {
+  describe('POST: `/api/currencies`', () => {
+    it('Should response unauthorized in case user was not logged in.', async () => {
+      const res = await request()
+        .post('/api/currencies')
+        .send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should `currency_name` be required.', async () => {
+      const res = await request()
+        .post('/api/currencies')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'currency_name', location: 'body',
+      });
+    });
+
+    it('Should `currency_code` be required.', async () => {
+      const res = await request()
+        .post('/api/currencies')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'currency_code', location: 'body',
+      });
+    });
+
+    it('Should response currency code is duplicated.', async () => {
+      tenantFactory.create('currency', { currency_code: 'USD' });
+
+      const res = await request()
+        .post('/api/currencies')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          currency_code: 'USD',
+          currency_name: 'Dollar',
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'CURRENCY.CODE.ALREADY.EXISTS', code: 100,
+      });
+    });
+
+    it('Should insert currency details to the storage.', async () => {
+      const res = await request()
+        .post('/api/currencies')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          currency_code: 'USD',
+          currency_name: 'Dollar',
+        });
+
+      const foundCurrency = await Currency.tenant().query().where('currency_code', 'USD');
+
+      expect(foundCurrency.length).equals(1);
+      expect(foundCurrency[0].currencyCode).equals('USD');
+      expect(foundCurrency[0].currencyName).equals('Dollar');
+    });
+
+    it('Should response success with correct data.', async () => {
+      const res = await request()
+        .post('/api/currencies')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          currency_code: 'USD',
+          currency_name: 'Dollar',
+        });
+
+      expect(res.status).equals(200);
+    });
+  });
+
+  describe('DELETE: `/api/currencies/:currency_code`', () => {
+    it('Should delete the given currency code from the storage.', async () => {
+      const currency = await tenantFactory.create('currency');
+      const res = await request()
+        .delete(`/api/currencies/${currency.currencyCode}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(200);
+
+      const foundCurrency = await Currency.tenant().query().where('currency_code', 'USD');
+      expect(foundCurrency.length).equals(0);
+    });
+  });
+
+  describe('POST: `/api/currencies/:id`', () => {
+    it('Should `currency_name` be required.', async () => {
+      const currency = await tenantFactory.create('currency');
+      const res = await request()
+        .post(`/api/currencies/${currency.code}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'currency_name', location: 'body',
+      });
+    });
+
+    it('Should `currency_code` be required.', async () => {
+      const currency = await tenantFactory.create('currency');
+      const res = await request()
+        .post(`/api/currencies/${currency.code}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'currency_code', location: 'body',
+      });
+    });
+
+    it('Should response currency code is duplicated.', async () => {
+      const currency1 = await tenantFactory.create('currency');
+      const currency2 = await tenantFactory.create('currency');
+
+      const res = await request()
+        .post(`/api/currencies/${currency2.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          currency_code: currency1.currencyCode,
+          currency_name: 'Dollar',
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'CURRENCY.CODE.ALREADY.EXISTS', code: 100,
+      });
+    });
+
+    it('Should update currency details of the given currency on the storage.', async () => {
+      const currency1 = await tenantFactory.create('currency');
+      const currency2 = await tenantFactory.create('currency');
+
+      const res = await request()
+        .post(`/api/currencies/${currency2.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          currency_code: 'ABC',
+          currency_name: 'Name',
+        });
+
+      const foundCurrency = await Currency.tenant().query().where('currency_code', 'ABC');
+
+      expect(foundCurrency.length).equals(1);
+      expect(foundCurrency[0].currencyCode).equals('ABC');
+      expect(foundCurrency[0].currencyName).equals('Name');
+    });
+
+    it('Should response success with correct data.', () => {
+
+    });
+  })
+});
diff --git a/packages/server/tests/routes/customers.test.js b/packages/server/tests/routes/customers.test.js
new file mode 100644
index 000000000..2a3eb327d
--- /dev/null
+++ b/packages/server/tests/routes/customers.test.js
@@ -0,0 +1,250 @@
+import {
+  request,
+  expect,
+} from '~/testInit';
+import Currency from 'models/Currency';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+import Customer from '../../src/models/Customer';
+
+describe('route: `/customers`', () => {
+  describe('POST: `/customers`', () => {
+    it('Should response unauthorized in case the user was not logged in.', async () => {
+      const res = await request()
+        .post('/api/customers')
+        .send({});
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should `display_name` be required field.', async () => {
+      const res = await request()
+        .post('/api/customers')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'display_name', location: 'body',
+      })
+    });
+
+    it('Should `customer_type` be required field', async () => {
+      const res = await request()
+        .post('/api/customers')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'customer_type', location: 'body',
+      });
+    });
+
+    it('Should store the customer data to the storage.', async () => {
+      const res = await request()
+        .post('/api/customers')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_type: 'business',
+
+          first_name: 'Ahmed',
+          last_name: 'Bouhuolia',
+
+          company_name: 'Bigcapital',
+
+          display_name: 'Ahmed Bouhuolia, Bigcapital',
+
+          email: 'a.bouhuolia@live.com',
+          work_phone: '0927918381',
+          personal_phone: '0925173379',
+
+          billing_address_city: 'Tripoli',
+          billing_address_country: 'Libya',
+          billing_address_email: 'a.bouhuolia@live.com',
+          billing_address_state: 'State Tripoli',
+          billing_address_zipcode: '21892',
+
+          shipping_address_city: 'Tripoli',
+          shipping_address_country: 'Libya',
+          shipping_address_email: 'a.bouhuolia@live.com',
+          shipping_address_state: 'State Tripoli',
+          shipping_address_zipcode: '21892',
+          
+          note: '__desc__',
+
+          active: true,
+        });
+
+      expect(res.status).equals(200);
+
+      const foundCustomer = await Customer.tenant().query().where('id', res.body.id);
+
+      expect(foundCustomer[0].customerType).equals('business');
+      expect(foundCustomer[0].firstName).equals('Ahmed');
+      expect(foundCustomer[0].lastName).equals('Bouhuolia');
+      expect(foundCustomer[0].companyName).equals('Bigcapital');
+      expect(foundCustomer[0].displayName).equals('Ahmed Bouhuolia, Bigcapital');
+
+      expect(foundCustomer[0].email).equals('a.bouhuolia@live.com');
+      
+      expect(foundCustomer[0].workPhone).equals('0927918381');
+      expect(foundCustomer[0].personalPhone).equals('0925173379');
+
+      expect(foundCustomer[0].billingAddressCity).equals('Tripoli');
+      expect(foundCustomer[0].billingAddressCountry).equals('Libya');
+      expect(foundCustomer[0].billingAddressEmail).equals('a.bouhuolia@live.com');
+      expect(foundCustomer[0].billingAddressState).equals('State Tripoli');
+      expect(foundCustomer[0].billingAddressZipcode).equals('21892');
+      
+      expect(foundCustomer[0].shippingAddressCity).equals('Tripoli');
+      expect(foundCustomer[0].shippingAddressCountry).equals('Libya');
+      expect(foundCustomer[0].shippingAddressEmail).equals('a.bouhuolia@live.com');
+      expect(foundCustomer[0].shippingAddressState).equals('State Tripoli');
+      expect(foundCustomer[0].shippingAddressZipcode).equals('21892');
+    });
+  });
+
+  describe('GET: `/customers/:id`', () => {
+    it('Should response not found in case the given customer id was not exists on the storage.', async () => {
+      const res = await request()
+        .get('/api/customers/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'CUSTOMER.NOT.FOUND', code: 200,
+      });
+    });
+  });
+
+  describe('GET: `customers`', () => {
+    it('Should response customers items', async () => {
+      await tenantFactory.create('customer');
+      await tenantFactory.create('customer');
+
+      const res = await request()
+        .get('/api/customers')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.body.customers.results.length).equals(2);
+    });
+  });
+
+  describe('DELETE: `/customers/:id`', () => {
+    it('Should response not found in case the given customer id was not exists on the storage.', async () => {
+      const res = await request()
+        .delete('/api/customers/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'CUSTOMER.NOT.FOUND', code: 200,
+      });
+    });
+
+    it('Should delete the given customer from the storage.', async () => {
+      const customer = await tenantFactory.create('customer');
+      const res = await request()
+        .delete(`/api/customers/${customer.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(200);
+
+      const foundCustomer = await Customer.tenant().query().where('id', customer.id);
+      expect(foundCustomer.length).equals(0);
+    })
+  });
+
+  describe('POST: `/customers/:id`', () => {
+    it('Should response customer not found', async () => {
+      const res = await request()
+        .post('/api/customers/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_type: 'business',
+          display_name: 'Ahmed Bouhuolia, Bigcapital',
+        });
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'CUSTOMER.NOT.FOUND', code: 200,
+      });
+    });
+
+    it('Should update details of the given customer.', async () => {
+      const customer = await tenantFactory.create('customer');
+      const res = await request()
+        .post(`/api/customers/${customer.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_type: 'business',
+          display_name: 'Ahmed Bouhuolia, Bigcapital',
+        });
+
+      expect(res.status).equals(200);
+      const foundCustomer = await Customer.tenant().query().where('id', res.body.id);
+
+      expect(foundCustomer.length).equals(1);
+      expect(foundCustomer[0].customerType).equals('business');
+      expect(foundCustomer[0].displayName).equals('Ahmed Bouhuolia, Bigcapital');
+    })
+  });
+
+  describe('DELETE: `customers`', () => {
+    it('Should response customers ids not found.', async () => {
+      const res = await request()
+        .delete('/api/customers')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [100, 200],
+        })
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'CUSTOMERS.NOT.FOUND', code: 200,        
+      });
+    });
+
+    it('Should delete the given customers.', async () => {
+      const customer1 = await tenantFactory.create('customer');
+      const customer2 = await tenantFactory.create('customer');
+
+      const res = await request()
+        .delete('/api/customers')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [customer1.id, customer2.id],
+        })
+        .send();
+
+      const foundCustomers = await Customer.tenant().query()
+        .whereIn('id', [customer1.id, customer2.id]);
+
+      expect(res.status).equals(200);
+      expect(foundCustomers.length).equals(0);
+    });
+  })
+});
diff --git a/packages/server/tests/routes/exchange_rates.test.js b/packages/server/tests/routes/exchange_rates.test.js
new file mode 100644
index 000000000..c655ab316
--- /dev/null
+++ b/packages/server/tests/routes/exchange_rates.test.js
@@ -0,0 +1,230 @@
+import moment from 'moment';
+import {
+  request,
+  expect,
+} from '~/testInit';
+import ExchangeRate from '../../src/models/ExchangeRate';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+
+describe('route: /exchange_rates/', () => {
+  describe('POST: `/api/exchange_rates`', () => {
+    it('Should response unauthorized in case the user was not logged in.', async () => {
+      const res = await request()
+        .post('/api/exchange_rates')
+        .send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should `currency_code` be required.', async () => {
+      const res = await request()
+        .post('/api/exchange_rates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'currency_code', location: 'body',
+      });
+    });
+
+    it('Should `exchange_rate` be required.', async () => {
+      const res = await request()
+        .post('/api/exchange_rates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'exchange_rate', location: 'body',
+      });
+    });
+
+    it('Should date be required', async () => {
+      const res = await request()
+        .post('/api/exchange_rates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'date', location: 'body',
+      });
+    });
+
+    it('Should response date and currency code is already exists.', async () => {
+      await tenantFactory.create('exchange_rate', {
+        date: '2020-02-02',
+        currency_code: 'USD',
+        exchange_rate: 4.4,
+      });
+      const res = await request()
+        .post('/api/exchange_rates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: '2020-02-02',
+          currency_code: 'USD',
+          exchange_rate: 4.4,
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'EXCHANGE.RATE.DATE.PERIOD.DEFINED', code: 200,
+      });
+    });
+
+    it('Should save the given exchange rate to the storage.', async () => {
+      const res = await request()
+        .post('/api/exchange_rates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: '2020-02-02',
+          currency_code: 'USD',
+          exchange_rate: 4.4,
+        });
+      expect(res.status).equals(200);
+
+      const foundExchangeRate = await ExchangeRate.tenant().query()
+        .where('currency_code', 'USD');
+
+      expect(foundExchangeRate.length).equals(1);
+      expect(
+        moment(foundExchangeRate[0].date).format('YYYY-MM-DD'),
+      ).equals('2020-02-02');
+      expect(foundExchangeRate[0].currencyCode).equals('USD');
+      expect(foundExchangeRate[0].exchangeRate).equals(4.4);
+    });
+  });
+
+  describe('GET: `/api/exchange_rates', () => {
+    it('Should retrieve all exchange rates with pagination meta.', async () => {
+      await tenantFactory.create('exchange_rate');
+      await tenantFactory.create('exchange_rate');
+      await tenantFactory.create('exchange_rate');
+
+      const res = await request()
+        .get('/api/exchange_rates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(200);
+      expect(res.body.exchange_rates.results.length).equals(3);
+    });
+  });
+
+  describe('POST: `/api/exchange_rates/:id`', () => {
+    it('Should response the given exchange rate not found.', async () => {
+      const res = await request()
+        .post('/api/exchange_rates/100')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          date: '2020-02-02', 
+          currency_code: 'USD',
+          exchange_rate: 4.4,
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'EXCHANGE.RATE.NOT.FOUND', code: 200,
+      });
+    });
+
+    it('Should update exchange rate of the given id on the storage.', async () => {
+      const exRate = await tenantFactory.create('exchange_rate');
+      const res = await request()
+        .post(`/api/exchange_rates/${exRate.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          exchange_rate: 4.4,
+        });
+      expect(res.status).equals(200);
+
+      const foundExchangeRate = await ExchangeRate.tenant().query()
+        .where('id', exRate.id);
+
+      expect(foundExchangeRate.length).equals(1);
+      expect(foundExchangeRate[0].exchangeRate).equals(4.4);
+    });
+  });
+
+  describe('DELETE: `/api/exchange_rates/:id`', () => {
+    it('Should response the given exchange rate id not found.', async () => {
+      const res = await request()
+        .delete('/api/exchange_rates/100')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'EXCHANGE.RATE.NOT.FOUND', code: 200,
+      });
+    });
+
+    it('Should delete the given exchange rate id from the storage.', async () => {
+      const exRate = await tenantFactory.create('exchange_rate');
+      const res = await request()
+        .delete(`/api/exchange_rates/${exRate.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      const foundRates = await ExchangeRate.tenant().query();
+      expect(foundRates.length).equals(0);
+    });
+  });
+
+  describe('DELETE: `/api/exchange_rates/bulk`', () => {
+    it('Should response the given exchange rates ids where not found.', async () => {
+      const res = await request()
+        .delete('/api/exchange_rates/bulk')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [12332, 32432],
+        })
+        .send();
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'EXCHANGE.RATES.IS.NOT.FOUND', code: 200, ids: [12332, 32432],
+      })
+    });
+
+    it('Should delete the given excahnge rates ids.', async () => {
+      const exRate = await tenantFactory.create('exchange_rate');
+      const exRate2 = await tenantFactory.create('exchange_rate');
+
+      const res = await request()
+        .delete('/api/exchange_rates/bulk')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [exRate.id, exRate2.id],
+        })
+        .send();
+
+      const foundExchangeRate = await ExchangeRate.tenant().query()
+        .whereIn('id', [exRate.id, exRate2.id]);
+
+      expect(foundExchangeRate.length).equals(0);
+    })
+  });
+});
diff --git a/packages/server/tests/routes/expenses.test.js b/packages/server/tests/routes/expenses.test.js
new file mode 100644
index 000000000..17a4c4ac9
--- /dev/null
+++ b/packages/server/tests/routes/expenses.test.js
@@ -0,0 +1,739 @@
+import moment from 'moment';
+import { pick } from 'lodash';
+import {
+  request,
+  expect,
+} from '~/testInit';
+import Expense from 'models/Expense';
+import ExpenseCategory from 'models/ExpenseCategory';
+import AccountTransaction from 'models/AccountTransaction';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes,
+} from '~/dbInit';
+
+describe('routes: /expenses/', () => {
+  describe('POST `/expenses`', () => {
+    it('Should retrieve unauthorized access if the user was not authorized.', async () => {
+      const res = await request()
+        .post('/api/expenses')
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should categories total not be equals zero.', async () => {
+      const res = await request()
+        .post('/api/expenses')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          payment_date: moment().format('YYYY-MM-DD'),
+          reference_no: '',
+          payment_account_id: 0,
+          description: '',
+          publish: 1,
+          categories: [
+            {
+              index: 1,
+              expense_account_id: 33,
+              amount: 1000,
+              description: '',
+            }
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'EXPENSE.ACCOUNTS.IDS.NOT.STORED', code: 400, ids: [33]
+      });
+    });
+
+    it('Should expense accounts ids be stored in the storage.', async () => {
+      const res = await request() 
+        .post('/api/expenses')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          payment_date: moment().format('YYYY-MM-DD'),
+          reference_no: '',
+          payment_account_id: 0,
+          description: '',
+          publish: 1,
+          categories: [
+            {
+              index: 1,
+              expense_account_id: 22,
+              amount: 1000,
+              description: '',
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'EXPENSE.ACCOUNTS.IDS.NOT.STORED', code: 400, ids: [22],
+      });
+    });
+
+    it('Should `payment_account_id` be in the storage.', async () => {
+      const res = await request() 
+        .post('/api/expenses')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          payment_date: moment().format('YYYY-MM-DD'),
+          reference_no: '',
+          payment_account_id: 22,
+          description: '',
+          publish: 1,
+          categories: [
+            {
+              index: 1,
+              expense_account_id: 22,
+              amount: 1000,
+              description: '',
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'PAYMENT.ACCOUNT.NOT.FOUND', code: 500,
+      });
+    });
+
+    it('Should payment_account be required.', async () => {
+      const res = await request() 
+        .post('/api/expenses')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+    });
+
+    it('Should `categories.*.expense_account_id` be required.', async () => {
+      const res = await request()
+        .post('/api/expenses')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+
+        });
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'payment_account_id', location: 'body'
+      });
+    });
+
+    it('Should expense transactions be stored on the storage.', async () => { 
+      const paymentAccount = await tenantFactory.create('account');
+      const expenseAccount = await tenantFactory.create('account');
+
+      const res = await request()
+        .post('/api/expenses')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          payment_date: moment().format('YYYY-MM-DD'),
+          reference_no: 'ABC',
+          payment_account_id: paymentAccount.id,
+          description: 'desc',
+          publish: 1,
+          categories: [
+            {
+              index: 1,
+              expense_account_id: expenseAccount.id,
+              amount: 1000,
+              description: '',
+            },
+          ],          
+        });      
+
+      const foundExpense = await Expense.tenant().query().where('id', res.body.id);
+    
+      expect(foundExpense.length).equals(1);
+      expect(foundExpense[0].referenceNo).equals('ABC');
+      expect(foundExpense[0].paymentAccountId).equals(paymentAccount.id);
+      expect(foundExpense[0].description).equals('desc');
+      expect(foundExpense[0].totalAmount).equals(1000);
+    });
+
+    it('Should expense categories transactions be stored on the storage.', async () => {
+      const paymentAccount = await tenantFactory.create('account');
+      const expenseAccount = await tenantFactory.create('account');
+
+      const res = await request()
+        .post('/api/expenses')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          payment_date: moment().format('YYYY-MM-DD'),
+          reference_no: 'ABC',
+          payment_account_id: paymentAccount.id,
+          description: 'desc',
+          publish: 1,
+          categories: [
+            {
+              index: 1,
+              expense_account_id: expenseAccount.id,
+              amount: 1000,
+              description: 'category desc',
+            },
+          ],          
+        });
+
+      const foundCategories = await ExpenseCategory.tenant().query().where('id', res.body.id);
+
+      expect(foundCategories.length).equals(1);
+      expect(foundCategories[0].index).equals(1);
+      expect(foundCategories[0].expenseAccountId).equals(expenseAccount.id);
+      expect(foundCategories[0].amount).equals(1000);
+      expect(foundCategories[0].description).equals('category desc');
+    });
+
+    it('Should save journal entries that associate to the expense transaction.', async () => {
+      const paymentAccount = await tenantFactory.create('account');
+      const expenseAccount = await tenantFactory.create('account');
+
+      const res = await request()
+        .post('/api/expenses')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          payment_date: moment().format('YYYY-MM-DD'),
+          reference_no: 'ABC',
+          payment_account_id: paymentAccount.id,
+          description: 'desc',
+          publish: 1,
+          categories: [
+            {
+              index: 1,
+              expense_account_id: expenseAccount.id,
+              amount: 1000,
+              description: 'category desc',
+            },
+          ],          
+        });
+
+      const transactions = await AccountTransaction.tenant().query()
+        .where('reference_id', res.body.id)
+        .where('reference_type', 'Expense');
+
+      const mappedTransactions = transactions.map(tr => ({
+        ...pick(tr, ['credit', 'debit', 'referenceId', 'referenceType']),
+      }));
+
+      expect(mappedTransactions[0]).deep.equals({
+        credit: 1000,
+        debit: 0,
+        referenceType: 'Expense',
+        referenceId: res.body.id,
+      });
+      expect(mappedTransactions[1]).deep.equals({
+        credit: 0,
+        debit: 1000,
+        referenceType: 'Expense',
+        referenceId: res.body.id,
+      });
+      expect(transactions.length).equals(2);
+    })
+  });
+
+  describe('GET: `/expenses`', () => {
+    it('Should response unauthorized if the user was not logged in.', async () => {
+      const res = await request()
+        .post('/api/expenses')
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should retrieve expenses with pagination meta.', async () => {
+      await tenantFactory.create('expense');
+      await tenantFactory.create('expense');
+
+      const res = await request()
+        .get('/api/expenses')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+      
+      expect(res.body.expenses).that.is.an('object');
+      expect(res.body.expenses.results).that.is.an('array');
+    });
+
+    it('Should retrieve expenses based on view roles conditions of the custom view.', () => {
+
+    });
+
+    it('Should sort expenses based on the given `column_sort_order` column on ASC direction.', () => {
+
+    });
+  });
+
+  describe('DELETE: `/expenses/:id`', () => {
+    it('Should response unauthorized if the user was not logged in.', async () => {
+      const res = await request()
+        .delete('/api/expenses')
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should response not found in case expense id was not exists on the storage.', async () => {
+      const res = await request()
+        .delete('/api/expenses/123321')
+        .set('organization-id', tenantWebsite.organizationId)
+        .set('x-access-token', loginRes.body.token)
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'EXPENSE.NOT.FOUND', code: 200,
+      });
+    });
+
+    it('Should delete the given expense transactions with associated categories.', async () => {
+      const expense = await tenantFactory.create('expense');
+
+      const res = await request()
+        .delete(`/api/expenses/${expense.id}`)
+        .set('organization-id', tenantWebsite.organizationId)
+        .set('x-access-token', loginRes.body.token)
+        .send();
+
+      expect(res.status).equals(200);
+
+      const storedExpense = await Expense.tenant().query().where('id', expense.id);
+      const storedExpenseCategories = await ExpenseCategory.tenant().query().where('expense_id', expense.id);
+
+      expect(storedExpense.length).equals(0);
+      expect(storedExpenseCategories.length).equals(0);
+    });
+
+    it('Should delete all journal entries that associated to the given expense.', async () => {
+      const expense = await tenantFactory.create('expense');
+
+      const trans = { reference_id: expense.id, reference_type: 'Expense' };
+      await tenantFactory.create('account_transaction', trans);
+      await tenantFactory.create('account_transaction', trans);
+
+      const res = await request()
+        .delete(`/api/expenses/${expense.id}`)
+        .set('organization-id', tenantWebsite.organizationId)
+        .set('x-access-token', loginRes.body.token)
+        .send();
+
+      const foundTransactions = await AccountTransaction.tenant().query()
+        .where('reference_type', 'Expense')
+        .where('reference_id', expense.id);
+
+      expect(foundTransactions.length).equals(0);
+    });
+  });
+
+  describe('GET: `/expenses/:id`', () => {
+    it('Should response unauthorized if the user was not logged in.', async () => {
+      const res = await request()
+        .get('/api/expenses/123')
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should response not found in case the given expense id was not exists in the storage.', async () => {
+      const res = await request()
+        .get(`/api/expenses/321`)
+        .set('organization-id', tenantWebsite.organizationId)
+        .set('x-access-token', loginRes.body.token)
+        .send();
+
+      expect(res.status).equals(404);
+    });
+
+    it('Should retrieve expense metadata and associated expense categories.', async () => {
+      const expense = await tenantFactory.create('expense');
+      const expenseCategory = await tenantFactory.create('expense_category', {
+        expense_id: expense.id,
+      })
+      const res = await request()
+        .get(`/api/expenses/${expense.id}`)
+        .set('organization-id', tenantWebsite.organizationId)
+        .set('x-access-token', loginRes.body.token)
+        .send();
+
+      expect(res.status).equals(200);
+    
+      expect(res.body.expense.id).is.a('number');
+      expect(res.body.expense.paymentAccountId).is.a('number');
+      expect(res.body.expense.totalAmount).is.a('number');
+      expect(res.body.expense.userId).is.a('number');
+      expect(res.body.expense.referenceNo).is.a('string');
+      expect(res.body.expense.description).is.a('string');
+      expect(res.body.expense.categories).is.a('array');
+
+      expect(res.body.expense.categories[0].id).is.a('number');
+      expect(res.body.expense.categories[0].description).is.a('string');
+      expect(res.body.expense.categories[0].expenseAccountId).is.a('number');
+    });
+
+    it('Should retrieve journal entries with expense metadata.', async () => {
+      const expense = await tenantFactory.create('expense');
+      const expenseCategory = await tenantFactory.create('expense_category', {
+        expense_id: expense.id,
+      });
+      const trans = { reference_id: expense.id, reference_type: 'Expense' };
+      await tenantFactory.create('account_transaction', trans);
+      await tenantFactory.create('account_transaction', trans);
+
+      const res = await request()
+        .get(`/api/expenses/${expense.id}`)
+        .set('organization-id', tenantWebsite.organizationId)
+        .set('x-access-token', loginRes.body.token)
+        .send();
+
+      expect(res.body.expense.journalEntries).is.an('array');
+      expect(res.body.expense.journalEntries.length).equals(2);
+    });
+  });
+
+  describe('POST: `expenses/:id`', () => {
+    it('Should response unauthorized in case the user was not logged in.', async () => {
+      const expense = await tenantFactory.create('expense');
+      const res = await request()
+        .post(`/api/expenses/${expense.id}`)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should response the given expense id not exists on the storage.', async () => {
+      const expenseAccount = await tenantFactory.create('account');
+
+      const res = await request()
+        .post('/api/expenses/1233')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          reference_no: '123',
+          payment_date: moment().format('YYYY-MM-DD'),
+          payment_account_id: 321,
+          publish: true,
+          categories: [
+            {
+              expense_account_id: expenseAccount.id,
+              index: 1,
+              amount: 1000,
+              description: '',
+            },
+          ],
+        });
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'EXPENSE.NOT.FOUND', code: 200,
+      });
+    });
+
+    it('Should response the given `payment_account_id` not exists.', async () => {
+      const expense = await tenantFactory.create('expense');
+      const expenseAccount = await tenantFactory.create('account');
+
+      const res = await request()
+      .post(`/api/expenses/${expense.id}`)
+      .set('x-access-token', loginRes.body.token)
+      .set('organization-id', tenantWebsite.organizationId)
+      .send({
+        reference_no: '123',
+        payment_date: moment().format('YYYY-MM-DD'),
+        payment_account_id: 321,
+        publish: true,
+        categories: [
+          {
+            expense_account_id: expenseAccount.id,
+            index: 1,
+            amount: 1000,
+            description: '',
+          },
+        ],
+      });
+      
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'PAYMENT.ACCOUNT.NOT.FOUND', code: 400,
+      });
+    });
+    
+    it('Should response the given `categories.*.expense_account_id` not exists.', async () => {
+      const paymentAccount = await tenantFactory.create('account');
+      const expense = await tenantFactory.create('expense');
+
+      const res = await request()
+        .post(`/api/expenses/${expense.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          reference_no: '123',
+          payment_date: moment().format('YYYY-MM-DD'),
+          payment_account_id: paymentAccount.id,
+          publish: true,
+          categories: [
+            {
+              index: 1,
+              expense_account_id: 100,
+              amount: 1000,
+              description: '',
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'EXPENSE.ACCOUNTS.IDS.NOT.FOUND', code: 600, ids: [100],
+      });
+    });
+
+    it('Should response the total amount equals zero.', async () => {
+      const expense = await tenantFactory.create('expense');
+      const expenseAccount = await tenantFactory.create('account');
+      const paymentAccount = await tenantFactory.create('account');
+
+      const res = await request()
+        .post(`/api/expenses/${expense.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          reference_no: '123',
+          payment_date: moment().format('YYYY-MM-DD'),
+          payment_account_id: paymentAccount.id,
+          publish: true,
+          categories: [
+            {
+              index: 1,
+              expense_account_id: expenseAccount.id,
+              amount: 0,
+              description: '',
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'TOTAL.AMOUNT.EQUALS.ZERO', code: 500,
+      });
+    });
+
+    it('Should update the expense transaction.', async () => {
+      const expense = await tenantFactory.create('expense');
+      const paymentAccount = await tenantFactory.create('account');
+      const expenseAccount = await tenantFactory.create('account');
+
+      const res = await request()
+        .post(`/api/expenses/${expense.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          reference_no: '123',
+          payment_date: moment('2009-01-02').format('YYYY-MM-DD'),
+          payment_account_id: paymentAccount.id,
+          publish: true,
+          description: 'Updated description',
+          categories: [
+            {
+              index: 1,
+              expense_account_id: expenseAccount.id,
+              amount: 3000,
+              description: '',
+            },
+          ],
+        });
+      expect(res.status).equals(200);
+      
+      const updatedExpense = await Expense.tenant().query()
+        .where('id', expense.id).first();
+
+      expect(updatedExpense.id).equals(expense.id);
+      expect(updatedExpense.referenceNo).equals('123');
+      expect(updatedExpense.description).equals('Updated description');
+      expect(updatedExpense.totalAmount).equals(3000);
+      expect(updatedExpense.paymentAccountId).equals(paymentAccount.id);
+    });
+
+    it('Should delete the expense categories that associated to the expense transaction.', async () => {
+      const expense = await tenantFactory.create('expense');
+      const expenseCategory = await tenantFactory.create('expense_category', {
+        expense_id: expense.id,
+      });
+      const paymentAccount = await tenantFactory.create('account');
+      const expenseAccount = await tenantFactory.create('account');
+
+      const res = await request()
+        .post(`/api/expenses/${expense.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          reference_no: '123',
+          payment_date: moment('2009-01-02').format('YYYY-MM-DD'),
+          payment_account_id: paymentAccount.id,
+          publish: true,
+          description: 'Updated description',
+          categories: [
+            {
+              index: 1,
+              expense_account_id: expenseAccount.id,
+              amount: 3000,
+              description: '',
+            },
+          ],
+        });
+
+      const foundExpenseCategories = await ExpenseCategory.tenant()
+        .query().where('id', expenseCategory.id)
+    
+      expect(foundExpenseCategories.length).equals(0);
+    });
+
+    it('Should insert the expense categories to associated to the expense transaction.', async () => {
+      const expense = await tenantFactory.create('expense');
+      const expenseCategory = await tenantFactory.create('expense_category', {
+        expense_id: expense.id,
+      });
+      const paymentAccount = await tenantFactory.create('account');
+      const expenseAccount = await tenantFactory.create('account');
+
+      const res = await request()
+        .post(`/api/expenses/${expense.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          reference_no: '123',
+          payment_date: moment('2009-01-02').format('YYYY-MM-DD'),
+          payment_account_id: paymentAccount.id,
+          publish: true,
+          description: 'Updated description',
+          categories: [
+            {
+              index: 1,
+              expense_account_id: expenseAccount.id,
+              amount: 3000,
+              description: '__desc__',
+            },
+          ],
+        });
+
+      const foundExpenseCategories = await ExpenseCategory.tenant()
+        .query()
+        .where('expense_id', expense.id)
+
+      expect(foundExpenseCategories.length).equals(1);
+      expect(foundExpenseCategories[0].id).not.equals(expenseCategory.id);
+    });
+
+    it('Should update the expense categories that associated to the expense transactions.', async () => {
+      const expense = await tenantFactory.create('expense');
+      const expenseCategory = await tenantFactory.create('expense_category', {
+        expense_id: expense.id,
+      });
+      const paymentAccount = await tenantFactory.create('account');
+      const expenseAccount = await tenantFactory.create('account');
+
+      const res = await request()
+        .post(`/api/expenses/${expense.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          reference_no: '123',
+          payment_date: moment('2009-01-02').format('YYYY-MM-DD'),
+          payment_account_id: paymentAccount.id,
+          publish: true,
+          description: 'Updated description',
+          categories: [
+            {
+              id: expenseCategory.id,
+              index: 1,
+              expense_account_id: expenseAccount.id,
+              amount: 3000,
+              description: '__desc__',
+            },
+          ],
+        });
+      
+      const foundExpenseCategory = await ExpenseCategory.tenant().query()
+        .where('id', expenseCategory.id);
+
+      expect(foundExpenseCategory.length).equals(1);
+      expect(foundExpenseCategory[0].expenseAccountId).equals(expenseAccount.id);
+      expect(foundExpenseCategory[0].description).equals('__desc__');
+      expect(foundExpenseCategory[0].amount).equals(3000);
+    });
+  });
+
+  describe('DELETE: `/api/expenses`', () => {
+    it('Should response not found expenses ids.', async () => {
+      const res = await request()
+        .delete('/api/expenses')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [100, 200],
+        })
+        .send({});
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'EXPENSES.NOT.FOUND', code: 200,
+      });
+    });
+
+    it('Should delete the given expenses ids.', async () => {
+      const expense1 = await tenantFactory.create('expense');
+      const expense2 = await tenantFactory.create('expense');
+    
+      const res = await request()
+        .delete('/api/expenses')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [expense1.id, expense2.id],
+        })
+        .send({});
+        
+      const foundExpenses = await Expense.tenant().query()
+        .whereIn('id', [expense1.id, expense2.id]);
+        
+      expect(res.status).equals(200);
+      expect(foundExpenses.length).equals(0);
+    })
+  });
+
+  describe('POST: `/api/expenses/:id/publish`', () => {
+    it('Should publish the given expense.', async () => {
+      const expense = await tenantFactory.create('expense', {
+        published: 0,
+      });
+
+      const res = await request()
+        .post(`/api/expenses/${expense.id}/publish`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      const foundExpense = await Expense.tenant().query()
+        .where('id', expense.id).first();
+
+      expect(res.status).equals(200);
+      expect(foundExpense.published).equals(1);
+    });
+  });
+});
diff --git a/packages/server/tests/routes/financial_statements.test.js b/packages/server/tests/routes/financial_statements.test.js
new file mode 100644
index 000000000..e7a0893e1
--- /dev/null
+++ b/packages/server/tests/routes/financial_statements.test.js
@@ -0,0 +1,956 @@
+import moment from 'moment';
+import {
+  request,
+  expect,
+} from '~/testInit';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+import { iteratee } from 'lodash';
+
+let creditAccount;
+let debitAccount;
+let incomeAccount;
+let incomeType;
+
+describe('routes: `/financial_statements`', () => {
+  beforeEach(async () => {
+    // Balance sheet types.
+    const assetType = await tenantFactory.create('account_type', { normal: 'debit', balance_sheet: true });
+    const liabilityType = await tenantFactory.create('account_type', { normal: 'credit', balance_sheet: true });
+
+    // Income statement types.
+    incomeType = await tenantFactory.create('account_type', { normal: 'credit', income_sheet: true });
+    const expenseType = await tenantFactory.create('account_type', { normal: 'debit', income_sheet: true });
+
+    // Assets & liabilites accounts.
+    creditAccount = await tenantFactory.create('account', { account_type_id: liabilityType.id });
+    debitAccount = await tenantFactory.create('account', { account_type_id: assetType.id });
+
+    // Income && expenses accounts.
+    incomeAccount = await tenantFactory.create('account', { account_type_id: incomeType.id });
+    const expenseAccount = await tenantFactory.create('account', { account_type_id: expenseType.id });
+    // const income2Account = await tenantFactory.create('account', { account_type_id: incomeType.id });
+
+    const accountTransactionMixied = { date: '2020-1-10' };
+
+    // Expense --
+    // 1000 Credit  - Credit account 
+    //    1000 Debit - expense account.
+    await tenantFactory.create('account_transaction', {
+      credit: 1000, debit: 0, account_id: debitAccount.id, referenceType: 'Expense',
+      referenceId: 1, ...accountTransactionMixied,
+    });
+    await tenantFactory.create('account_transaction', {
+      credit: 0, debit: 1000, account_id: expenseAccount.id, referenceType: 'Expense',
+      referenceId: 1, ...accountTransactionMixied,
+    });
+
+    // Jounral
+    // 4000 Credit - liability account.
+    //     2000 Debit - Asset account
+    //     2000 Debit - Asset account
+    await tenantFactory.create('account_transaction', {
+      credit: 4000, debit: 0, account_id: creditAccount.id, ...accountTransactionMixied,
+    });
+    await tenantFactory.create('account_transaction', {
+      debit: 2000, credit: 0, account_id: debitAccount.id, ...accountTransactionMixied,
+    });
+    await tenantFactory.create('account_transaction', {
+      debit: 2000, credit: 0, account_id: debitAccount.id, ...accountTransactionMixied,
+    });
+
+    // Income Journal.
+    // 2000 Credit - Income account.
+    //    2000 Debit - Asset account.
+    await tenantFactory.create('account_transaction', {
+      credit: 2000, account_id: incomeAccount.id, ...accountTransactionMixied
+    });
+    await tenantFactory.create('account_transaction', {
+      debit: 2000, credit: 0, account_id: debitAccount.id, ...accountTransactionMixied,
+    });
+
+    // -----------------------------------------
+    // Assets account balance  = 5000  |  Libility account balance = 4000
+    // Expense account balance = 1000  |  Income account balance   = 2000
+  });
+
+
+  describe('routes: `/financial_statements/journal`', () => {
+    it('Should response unauthorized in case the user was not authorized.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/journal')
+        .send();
+
+      expect(res.status).equals(401);
+    });
+
+    it('Should retrieve ledger sheet transactions grouped by reference type and id.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/journal')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(200);
+      expect(res.body.journal.length).to.be.at.least(1);
+
+      expect(res.body.journal[0].credit).to.be.a('number');
+      expect(res.body.journal[0].debit).to.be.a('number');
+      expect(res.body.journal[0].entries).to.be.a('array');
+      expect(res.body.journal[0].id).to.be.a('string');
+
+      expect(res.body.journal[0].entries[0].credit).to.be.a('number');
+      expect(res.body.journal[0].entries[0].debit).to.be.a('number');
+    });
+
+    it('Should retrieve transactions between date range.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/journal')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2018-01-01',
+          to_date: '2019-01-01',
+        })
+        .send();
+
+      expect(res.body.journal.length).equals(0);
+    });
+
+    it('Should retrieve transactions that associated to the queried accounts.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/journal')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          account_ids: [creditAccount.id],
+        })
+        .send();
+
+      expect(res.body.journal[0].entries.length).equals(1);
+      expect(res.body.journal[0].entries[0].account_id).equals(creditAccount.id);
+
+      expect(res.body.journal.length).equals(1);
+    });
+
+    it('Should retrieve tranasactions with the given types.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/journal')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          transaction_types: ['Expense'],
+        });
+
+      expect(res.body.journal.length).equals(1);
+    });
+
+    it('Should retrieve transactions with range amount.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/journal')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_range: 2000,
+          to_range: 2000,
+        })
+        .send();
+
+      expect(res.body.journal[0].credit).satisfy((credit) => {
+        return credit === 0 || credit >= 2000;
+      });
+      expect(res.body.journal[0].debit).satisfy((debit) => {
+        return debit === 0 || debit >= 2000;
+      });
+    });
+
+    it('Should format credit and debit to no cents of retrieved transactions.', async () => {
+
+    });
+
+    it('Should divide credit/debit amount on 1000', async () => {
+      const res = await request()
+        .get('/api/financial_statements/journal')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          number_format: {
+            divide_1000: true,
+          },
+        })
+        .send();
+
+      const journal = res.body.journal.find((j) => j.id === '1-Expense');
+
+      expect(journal.formatted_credit).equals(1);
+      expect(journal.formatted_debit).equals(1);
+    });
+  });
+
+  describe('routes: `/financial_statements/general_ledger`', () => {
+    it('Should response unauthorized in case the user was not authorized.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/general_ledger')
+        .send();
+
+      expect(res.status).equals(401);
+    });
+
+    it('Should retrieve request query meta on response schema.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/general_ledger')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.body.query.from_date).equals(moment().startOf('year').format('YYYY-MM-DD'));
+      expect(res.body.query.to_date).equals(moment().endOf('year').format('YYYY-MM-DD'));
+      expect(res.body.query.basis).equals('cash');
+      expect(res.body.query.number_format.no_cents).equals(false);
+      expect(res.body.query.number_format.divide_1000).equals(false);
+      expect(res.body.query.none_zero).equals(false);
+      expect(res.body.query.accounts_ids).to.be.an('array');
+    });
+
+    it('Should retrieve the general ledger accounts with associated transactions and opening/closing balance.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/general_ledger')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.body.accounts).is.an('array');
+      expect(res.body.accounts[0].id).to.be.an('number');
+      expect(res.body.accounts[0].name).to.be.a('string');
+      expect(res.body.accounts[0].code).to.be.a('string');
+      expect(res.body.accounts[0].transactions).to.be.a('array');
+      expect(res.body.accounts[0].opening).to.be.a('object');
+      expect(res.body.accounts[0].opening.amount).to.be.a('number');
+      expect(res.body.accounts[0].opening.date).to.be.a('string');
+      expect(res.body.accounts[0].closing).to.be.a('object');
+      expect(res.body.accounts[0].closing.amount).to.be.a('number');
+      expect(res.body.accounts[0].closing.date).to.be.a('string');
+    });
+
+    it('Should retrieve opening and closing balance.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/general_ledger')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      const targetAccount = res.body.accounts.find((a) => a.id === creditAccount.id);
+
+      expect(targetAccount).to.be.an('object');
+      expect(targetAccount.opening).to.deep.equal({
+        amount: 0, formatted_amount: 0, date: '2020-01-01',
+      });
+      expect(targetAccount.closing).to.deep.equal({
+        amount: 4000, formatted_amount: 4000, date: '2020-12-31',
+      });
+    });
+
+    it('Should retrieve opening and closing balance between the given date range.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/general_ledger')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2018-01-01',
+          to_date: '2020-03-30',
+          // none_zero: true,
+        })
+        .send();
+
+      const targetAccount = res.body.accounts.find((a) => a.id === creditAccount.id);
+
+      expect(targetAccount).to.be.an('object');
+      expect(targetAccount.opening).to.deep.equal({
+        amount: 0, formatted_amount: 0, date: '2018-01-01',
+      });
+      expect(targetAccount.closing).to.deep.equal({
+        amount: 4000, formatted_amount: 4000, date: '2020-03-30',
+      });
+    });
+
+    it('Should retrieve accounts with associated transactions.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/general_ledger')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          none_zero: true,
+        })
+        .send();
+
+    })
+ 
+    it('Should retrieve accounts transactions only that between date range.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/general_ledger')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2020-01-01',
+          to_date: '2020-03-30',
+          none_zero: true,
+        })
+        .send();
+
+
+      // console.log(res.body.accounts);
+    });
+
+    it('Should retrieve no accounts with given date period has not transactions.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/general_ledger')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2020-01-20',
+          to_date: '2020-03-30',
+          none_zero: true,
+        })
+        .send();
+
+      expect(res.body.accounts.length).equals(0);
+    });
+
+    it('Should retrieve all accounts even it have no transactions in the given date range when `none_zero` is `true`', async () => {
+      const res = await request()
+        .get('/api/financial_statements/general_ledger')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2020-01-01',
+          to_date: '2020-03-30',
+          none_zero: true,
+        })
+        .send();
+
+      const accountsNoTransactions = res.body.accounts.filter(a => a.transactions.length === 0);
+      const accountsWithTransactions = res.body.accounts.filter(a => a.transactions.length > 0);
+
+      expect(accountsNoTransactions.length).equals(0);
+      expect(accountsWithTransactions.length).not.equals(0);
+    });
+
+    it('Should amount transactions divided on `1000` when `number_format.none_zero` is `true`.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/general_ledger')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2020-01-01',
+          to_date: '2020-03-30',
+          accounts_ids: [creditAccount.id],
+          number_format: {
+            divide_1000: true,
+          },
+        })
+        .send();
+
+      expect(res.body.accounts).include.something.deep.equals({
+        id: creditAccount.id,
+        name: creditAccount.name,
+        code: creditAccount.code, 
+        index: null,
+        parentAccountId: null,
+        children: [],
+        transactions: [
+          {
+            id: 1002,
+            note: null,
+            transactionType: null,
+            referenceType: null,
+            referenceId: null,
+            date: '2020-01-09T22:00:00.000Z',
+            createdAt: null,
+            formatted_amount: 4,
+            amount: 4000,
+          }
+        ],
+        opening: { date: '2020-01-01', formatted_amount: 0, amount: 0 },
+        closing: { date: '2020-03-30', formatted_amount: 4, amount: 4000 }
+      });
+    });
+
+    it('Should amount transactions rounded with no decimals when `number_format.no_cents` is `true`.', async () => {
+      await tenantFactory.create('account_transaction', {
+        debit: 0.25, credit: 0, account_id: debitAccount.id, date: '2020-1-10',
+      });
+
+      const res = await request()
+        .get('/api/financial_statements/general_ledger')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2020-01-01',
+          to_date: '2020-03-30',
+          number_format: {
+            divide_1000: true,
+            no_cents: true,
+          },
+          accounts_ids: [debitAccount.id]
+        })
+        .send();
+
+      expect(res.body.accounts[0].transactions[2].formatted_amount).equal(2);
+    });
+
+    it('Should retrieve only accounts that given in the query.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/general_ledger')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2020-01-01',
+          to_date: '2020-03-30',
+          none_zero: true,
+          accounts_ids: [creditAccount.id],
+        })
+        .send();
+
+      expect(res.body.accounts.length).equals(1);
+    });
+
+    it('Should retrieve accounts in nested array structure as parent/children accounts.', async () => {
+      const childAccount = await tenantFactory.create('account', {
+        parent_account_id: debitAccount.id,
+        account_type_id: 1
+      });
+
+      const res = await request()
+        .get('/api/financial_statements/general_ledger')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          accounts_ids: [childAccount.id, debitAccount.id],
+        })
+        .send();
+
+      expect(res.body.accounts[0].children.length).equals(1);
+      expect(res.body.accounts[0].children[0].id).equals(childAccount.id);
+    });
+  });
+
+  describe('routes: `/financial_statements/trial_balance`', () => {
+    it('Should response unauthorized in case the user was not authorized.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/trial_balance_sheet')
+        .send();
+
+      expect(res.status).equals(401);
+    });
+
+    it('Should retrieve the trial balance of accounts.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/trial_balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.body.accounts).include.something.deep.equals({
+        id: debitAccount.id,
+        name: debitAccount.name,
+        code: debitAccount.code,
+        parentAccountId: null,
+        accountNormal: 'debit',
+        credit: 1000,
+        debit: 6000,
+        balance: 5000,
+
+        formatted_credit: 1000,
+        formatted_debit: 6000,
+        formatted_balance: 5000,
+
+        children: [],
+      });
+      expect(res.body.accounts).include.something.deep.equals({
+        id: creditAccount.id,
+        name: creditAccount.name,
+        code: creditAccount.code,
+        accountNormal: 'credit',
+        parentAccountId: null,
+
+        credit: 4000,
+        debit: 0,
+        balance: 4000,
+
+        formatted_credit: 4000,
+        formatted_debit: 0,
+        formatted_balance: 4000,
+
+        children: [],
+      });
+    });
+
+    it('Should not retrieve accounts has no transactions between the given date range.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/trial_balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          // There is no transactions between these dates.
+          from_date: '2002-01-01',
+          to_date: '2003-01-01',
+          none_zero: true,
+        })
+        .send();
+
+      expect(res.body.accounts.length).equals(0);
+    });
+
+    it('Should retrieve trial balance of accounts between the given date range.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/trial_balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          // There is no transactions between these dates.
+          from_date: '2020-01-05',
+          to_date: '2020-01-10',
+          none_zero: true,
+        })
+        .send();
+
+      expect(res.body.accounts).include.something.deep.equals({
+        id: creditAccount.id,
+        name: creditAccount.name,
+        code: creditAccount.code,
+        accountNormal: 'credit',
+        parentAccountId: null,
+        credit: 4000,
+        debit: 0,
+        balance: 4000,
+
+        formatted_credit: 4000,
+        formatted_debit: 0,
+        formatted_balance: 4000,
+
+        children: []
+      });
+    });
+
+    it('Should credit, debit and balance amount be divided on 1000.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/trial_balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          // There is no transactions between these dates.
+          from_date: '2020-01-05',
+          to_date: '2020-01-10',
+          number_format: {
+            divide_1000: true,
+          },
+        })
+        .send();
+
+      expect(res.body.accounts).include.something.deep.equals({
+        id: creditAccount.id,
+        name: creditAccount.name,
+        code: creditAccount.code,
+        accountNormal: 'credit',
+        parentAccountId: null,
+
+        credit: 4000,
+        debit: 0,
+        balance: 4000,
+
+        formatted_credit: 4,
+        formatted_debit: 0,
+        formatted_balance: 4,
+
+        children: [],
+      });
+    });
+
+    it('Should credit, debit and balance amount rounded without cents.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/trial_balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          // There is no transactions between these dates.
+          from_date: '2020-01-05',
+          to_date: '2020-01-10',
+          number_format: {
+            no_cents: true,
+          },
+        })
+        .send();
+    });
+
+    it('Should retrieve associated account details in accounts list.', async () => {
+
+    });
+
+    it('Should retrieve account with nested array structure as parent/children accounts.', async () => {
+      const childAccount = await tenantFactory.create('account', {
+        parent_account_id: debitAccount.id,
+        account_type_id: 1
+      });
+
+      const res = await request()
+        .get('/api/financial_statements/trial_balance_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          account_ids: [debitAccount.id, childAccount.id],
+        })
+        .send();
+
+      expect(res.body.accounts[0].children.length).equals(1);
+      expect(res.body.accounts[0].children[0].id).equals(childAccount.id);
+    });
+  });
+
+  describe('routes: `/api/financial_statements/profit_loss_sheet`', () => {
+    it('Should response unauthorized in case the user was not authorized.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/profit_loos_sheet')
+        .send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should retrieve columns when display type `date_periods` and columns by `month` between date range.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/profit_loss_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2020-01-01',
+          to_date: '2020-12-12',
+          display_columns_type: 'date_periods',
+          display_columns_by: 'month',
+        })
+        .send();
+
+      expect(res.body.columns.length).equals(12);
+      expect(res.body.columns).deep.equals([
+        '2020-01', '2020-02',
+        '2020-03', '2020-04',
+        '2020-05', '2020-06',
+        '2020-07', '2020-08',
+        '2020-09', '2020-10',
+        '2020-11', '2020-12',
+      ]);
+    });
+
+    it('Should retrieve columns when display type `date_periods` and columns by `quarter`.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/profit_loss_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: moment().startOf('year').format('YYYY-MM-DD'),
+          to_date: moment().endOf('year').format('YYYY-MM-DD'),
+          display_columns_type: 'date_periods',
+          display_columns_by: 'quarter',
+        })
+        .send();
+
+      expect(res.body.columns.length).equals(4);
+      expect(res.body.columns).deep.equals([
+        '2020-03', '2020-06', '2020-09', '2020-12',
+      ]);
+    });
+
+    it('Should retrieve columns when display type `date_periods` and columns by `day` between date range.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/profit_loss_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: moment('2020-01-01').startOf('month').format('YYYY-MM-DD'),
+          to_date: moment('2020-01-01').endOf('month').format('YYYY-MM-DD'),
+          display_columns_type: 'date_periods',
+          display_columns_by: 'day',
+        })
+        .send();
+
+      expect(res.body.columns.length).equals(31);
+      expect(res.body.columns).deep.equals([
+        '2020-01-01', '2020-01-02', '2020-01-03',
+        '2020-01-04', '2020-01-05', '2020-01-06',
+        '2020-01-07', '2020-01-08', '2020-01-09',
+        '2020-01-10', '2020-01-11', '2020-01-12',
+        '2020-01-13', '2020-01-14', '2020-01-15',
+        '2020-01-16', '2020-01-17', '2020-01-18',
+        '2020-01-19', '2020-01-20', '2020-01-21',
+        '2020-01-22', '2020-01-23', '2020-01-24',
+        '2020-01-25', '2020-01-26', '2020-01-27',
+        '2020-01-28', '2020-01-29', '2020-01-30',
+        '2020-01-31',
+      ]);
+    });
+
+    it('Should retrieve all income accounts even it has no transactions.', async () => {
+      const zeroAccount = await tenantFactory.create('account', { account_type_id: incomeType.id });
+
+      const res = await request()
+        .get('/api/financial_statements/profit_loss_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: moment('2020-01-01').startOf('month').format('YYYY-MM-DD'),
+          to_date: moment('2020-01-31').endOf('month').format('YYYY-MM-DD'),
+          display_columns_type: 'total',
+          display_columns_by: 'month',
+          none_zero: false,
+        })
+        .send();
+
+      expect(res.body.profitLoss.income.accounts).include.something.deep.equals({
+        id: zeroAccount.id,
+        index: zeroAccount.index,
+        name: zeroAccount.name,
+        code: zeroAccount.code,
+        parentAccountId: null,
+        children: [],
+        total: { amount: 0, date: '2020-01-31', formatted_amount: 0 },
+      });
+    });
+
+    it('Should retrieve total of each income account when display columns by `total`.',  async () => {
+      const toDate = moment('2020-01-01').endOf('month').format('YYYY-MM-DD');
+      const res = await request()
+        .get('/api/financial_statements/profit_loss_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: moment('2020-01-01').startOf('month').format('YYYY-MM-DD'),
+          to_date: toDate,
+        })
+        .send();
+
+      expect(res.body.profitLoss.income.accounts).to.be.an('array');
+      expect(res.body.profitLoss.income.accounts.length).not.equals(0);
+      expect(res.body.profitLoss.income.accounts[0].id).to.be.an('number');
+      expect(res.body.profitLoss.income.accounts[0].name).to.be.an('string');
+      expect(res.body.profitLoss.income.accounts[0].total).to.be.an('object');
+      expect(res.body.profitLoss.income.accounts[0].total.amount).to.be.an('number');
+      expect(res.body.profitLoss.income.accounts[0].total.formatted_amount).to.be.an('number');
+      expect(res.body.profitLoss.income.accounts[0].total.date).equals(toDate);
+    });
+
+    it('Should retrieve credit sumation of income accounts.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/profit_loss_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2020-01-01',
+          to_date: '2021-01-01',
+        })
+        .send();
+
+      expect(res.body.profitLoss.income.total).to.be.an('object');
+      expect(res.body.profitLoss.income.total.amount).equals(2000);
+      expect(res.body.profitLoss.income.total.formatted_amount).equals(2000);
+      expect(res.body.profitLoss.income.total.date).equals('2021-01-01');
+    });
+
+    it('Should retrieve debit sumation of expenses accounts.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/profit_loss_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2020-01-01',
+          to_date: '2021-01-01',
+        })
+        .send();
+
+      expect(res.body.profitLoss.expenses.total).to.be.an('object');
+      expect(res.body.profitLoss.expenses.total.amount).equals(1000);
+      expect(res.body.profitLoss.expenses.total.formatted_amount).equals(1000);
+      expect(res.body.profitLoss.expenses.total.date).equals('2021-01-01');
+    });
+
+    it('Should retrieve credit total of income accounts with `date_periods` columns between the given date range.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/profit_loss_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2019-12-01',
+          to_date: '2020-12-01',
+          display_columns_type: 'date_periods',
+          display_columns_by: 'month',
+        })
+        .send();
+
+      expect(res.body.profitLoss.income.total_periods[0].amount).equals(0);
+      expect(res.body.profitLoss.income.total_periods[1].amount).equals(2000);
+      expect(res.body.profitLoss.income.total_periods[2].amount).equals(2000);
+    });
+
+    it('Should retrieve debit total of expenses accounts with `date_periods` columns between the given date range.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/profit_loss_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2019-12-01',
+          to_date: '2020-12-01',
+          display_columns_type: 'date_periods',
+          display_columns_by: 'month',
+        })
+        .send();
+
+      expect(res.body.profitLoss.expenses.total_periods[0].amount).equals(0);
+      expect(res.body.profitLoss.expenses.total_periods[1].amount).equals(1000);
+      expect(res.body.profitLoss.expenses.total_periods[2].amount).equals(1000);
+    });
+
+    it('Should retrieve total net income with `total column display between the given date range.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/profit_loss_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2019-12-01',
+          to_date: '2020-12-01',
+          display_columns_type: 'total',
+        })
+        .send();
+
+      expect(res.body.profitLoss.net_income.total.amount).equals(1000);
+      expect(res.body.profitLoss.net_income.total.formatted_amount).equals(1000);
+      expect(res.body.profitLoss.net_income.total.date).equals('2020-12-01');
+    });
+
+    it('Should retrieve total net income with `date_periods` columns between the given date range.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/profit_loss_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2019-12-01',
+          to_date: '2020-12-01',
+          display_columns_type: 'date_periods',
+          display_columns_by: 'quarter',
+        })
+        .send();
+
+      expect(res.body.profitLoss.net_income).deep.equals({
+        total_periods: [
+          { date: '2019-12', amount: 0, formatted_amount: 0 },
+          { date: '2020-03', amount: 1000, formatted_amount: 1000 },
+          { date: '2020-06', amount: 1000, formatted_amount: 1000 },
+          { date: '2020-09', amount: 1000, formatted_amount: 1000 },
+          { date: '2020-12', amount: 1000, formatted_amount: 1000 }
+        ],      
+      });
+    });
+
+    it('Should not retrieve income or expenses accounts that has no transactions between the given date range in case none_zero equals true.', async () => {
+      const res = await request()
+        .get('/api/financial_statements/profit_loss_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          from_date: '2020-01-01',
+          to_date: '2021-01-01',
+          display_columns_by: 'month',
+          display_columns_type: 'date_periods',
+          none_zero: true,
+        })
+        .send();
+
+      expect(res.body.profitLoss.income.accounts.length).equals(1);
+    });
+
+    it('Should retrieve accounts in nested array structure as parent/children accounts.', async () => {
+      const childAccount = await tenantFactory.create('account', {
+        parent_account_id: incomeAccount.id,
+        account_type_id: 7
+      });
+
+      const res = await request()
+        .get('/api/financial_statements/profit_loss_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          account_ids: [childAccount.id, incomeAccount.id],
+        })
+        .send();
+
+      expect(res.body.profitLoss.income.accounts.length).equals(1);
+      expect(res.body.profitLoss.income.accounts[0].children.length).equals(1);
+      expect(res.body.profitLoss.income.accounts[0].children[0].id).equals(childAccount.id);
+    });
+
+    it('Should parent account credit/debit sumation of total periods amounts all children accounts.', async () => {
+      const childAccount = await tenantFactory.create('account', {
+        parent_account_id: incomeAccount.id,
+        account_type_id: 7,
+      });
+      await tenantFactory.create('account_transaction', {
+        credit: 1000, debit: 0, account_id: childAccount.id, date: '2020-2-10'
+      });
+
+      const res = await request()
+        .get('/api/financial_statements/profit_loss_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          account_ids: [childAccount.id, incomeAccount.id],
+          from_date: '2020-01-01',
+          to_date: '2020-12-12',
+        })
+        .send();
+
+      expect(res.body.profitLoss.income.accounts[0].total).deep.equals({
+        amount: 3000, date: '2020-12-12', formatted_amount: 3000
+      });
+    });
+
+    it('Should parent account credit/debit sumation of total date periods.', async () => {
+      const childAccount = await tenantFactory.create('account', {
+        parent_account_id: incomeAccount.id,
+        account_type_id: 7,
+      });
+      await tenantFactory.create('account_transaction', {
+        credit: 1000, debit: 0, account_id: childAccount.id, date: '2020-2-10'
+      });
+
+      const res = await request()
+        .get('/api/financial_statements/profit_loss_sheet')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          account_ids: [childAccount.id, incomeAccount.id],
+          display_columns_type: 'date_periods',
+          display_columns_by: 'month',
+          from_date: '2020-01-01',
+          to_date: '2020-12-12',
+        })
+        .send();
+
+      const periods = [
+        { date: '2020-01', amount: 2000, formatted_amount: 2000 },
+        { date: '2020-02', amount: 3000, formatted_amount: 3000 },
+        { date: '2020-03', amount: 3000, formatted_amount: 3000 },
+        { date: '2020-04', amount: 3000, formatted_amount: 3000 },
+        { date: '2020-05', amount: 3000, formatted_amount: 3000 },
+        { date: '2020-06', amount: 3000, formatted_amount: 3000 },
+        { date: '2020-07', amount: 3000, formatted_amount: 3000 },
+        { date: '2020-08', amount: 3000, formatted_amount: 3000 },
+        { date: '2020-09', amount: 3000, formatted_amount: 3000 },
+        { date: '2020-10', amount: 3000, formatted_amount: 3000 },
+        { date: '2020-11', amount: 3000, formatted_amount: 3000 },
+        { date: '2020-12', amount: 3000, formatted_amount: 3000 }
+      ];
+      expect(res.body.profitLoss.income.accounts[0].periods).deep.equals(periods);
+      expect(res.body.profitLoss.income.total_periods).deep.equals(periods);
+    });
+  });
+});
diff --git a/packages/server/tests/routes/inviteUsers.test.js b/packages/server/tests/routes/inviteUsers.test.js
new file mode 100644
index 000000000..b586f0dda
--- /dev/null
+++ b/packages/server/tests/routes/inviteUsers.test.js
@@ -0,0 +1,259 @@
+import knex from '@/database/knex';
+import {
+  request,
+  expect,
+  createUser,
+} from '~/testInit';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+import Invite from '@/system/models/Invite'
+import TenantUser from 'models/TenantUser';
+import SystemUser from '@/system/models/SystemUser';
+
+describe('routes: `/api/invite_users`', () => {
+  describe('POST: `/api/invite_users/send`', () => {
+    it('Should response unauthorized if the user was not authorized.', async () => {
+      const res = await request().get('/api/invite_users/send');
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should email be required.', async () => {
+      const res = await request()
+        .post('/api/invite/send')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'email', location: 'body',
+      });
+    });
+
+    it('Should email not be already registered in the system database.', async () => {
+      const user = await createUser(tenantWebsite, {
+        active: false,
+        email: 'admin@admin.com',
+      });
+      
+      const res = await request()
+        .post('/api/invite/send')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          email: 'admin@admin.com',
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'USER.EMAIL.ALREADY.REGISTERED', code: 100,
+      });
+    });
+
+    it('Should invite token be inserted to the master database.', async () => {
+      const res = await request()
+        .post('/api/invite/send')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          email: 'admin@admin.com'
+        });
+
+      const foundInviteToken = await Invite.query()
+        .where('email', 'admin@admin.com').first();
+      
+      expect(foundInviteToken).is.not.null;
+      expect(foundInviteToken.token).is.not.null;
+    });
+
+    it('Should invite email be insereted to users tenant database.', async () => {
+      const res = await request()
+        .post('/api/invite/send')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          email: 'admin@admin.com'
+        });
+    
+      const foundTenantUser = await TenantUser.tenant().query()
+        .where('email', 'admin@admin.com').first();
+
+      expect(foundTenantUser).is.not.null;
+      expect(foundTenantUser.email).equals('admin@admin.com');
+      expect(foundTenantUser.firstName).equals('admin@admin.com');
+      expect(foundTenantUser.createdAt).is.not.null;
+    });
+  });
+
+  describe('POST: `/api/invite/accept/:token`', () => {
+    let sendInviteRes; 
+    let inviteUser;
+
+    beforeEach(async () => {
+      sendInviteRes = await request()
+        .post('/api/invite/send')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          email: 'admin@admin.com'
+        });
+
+      inviteUser = await Invite.query()
+        .where('email', 'admin@admin.com')
+        .first();
+    });
+
+    it('Should the given token be valid.', async () => {
+      const res = await request()
+        .post('/api/invite/accept/invalid_token')
+        .send({
+          first_name: 'Ahmed',
+          last_name: 'Bouhuolia',
+          password: 'hard-password',
+          phone_number: '0927918381',
+        });
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'INVITE.TOKEN.NOT.FOUND', code: 300,
+      });
+    });
+
+    it('Should first_name be required.', async () => {
+      const res = await request()
+        .post(`/api/invite/accept/${inviteUser.token}`)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'first_name', location: 'body'
+      });
+    });
+
+    it('Should last_name be required.', async () => {
+      const res = await request()
+        .post(`/api/invite/accept/${inviteUser.token}`)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'last_name', location: 'body'
+      });
+    });
+
+    it('Should phone_number be required.', async () => {
+      const res = await request()
+        .post(`/api/invite/accept/${inviteUser.token}`)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'phone_number', location: 'body'
+      });
+    });
+
+    it('Should password be required.', async () => {
+      const res = await request()
+      .post(`/api/invite/accept/${inviteUser.token}`)
+      .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'password', location: 'body'
+      });
+    });
+
+    it('Should phone number not be already registered.', async () => {
+      const user = await createUser(tenantWebsite);
+      const res = await request()
+        .post(`/api/invite/accept/${inviteUser.token}`)
+        .send({
+          first_name: 'Ahmed',
+          last_name: 'Bouhuolia',
+          password: 'hard-password',
+          phone_number: user.phone_number,
+        })
+      
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'PHONE_MUMNER.ALREADY.EXISTS', code: 400,
+      });
+    });
+
+    it('Should tenant user details updated after invite accept.', async () => {
+      const user = await createUser(tenantWebsite);
+      const res = await request()
+        .post(`/api/invite/accept/${inviteUser.token}`)
+        .send({
+          first_name: 'Ahmed',
+          last_name: 'Bouhuolia',
+          password: 'hard-password',
+          phone_number: '0927918381',
+        });
+
+      const foundTenantUser = await TenantUser.tenant().query()
+        .where('email', 'admin@admin.com').first();
+
+      expect(foundTenantUser).is.not.null;
+      expect(foundTenantUser.id).is.not.null;
+      expect(foundTenantUser.email).equals('admin@admin.com');
+      expect(foundTenantUser.firstName).equals('Ahmed');
+      expect(foundTenantUser.lastName).equals('Bouhuolia');
+      expect(foundTenantUser.active).equals(1);
+      expect(foundTenantUser.inviteAcceptedAt).is.not.null;
+      expect(foundTenantUser.createdAt).is.not.null;
+      expect(foundTenantUser.updatedAt).is.not.null;
+    });
+
+    it('Should user details be insereted to the system database', async () => {
+      const user = await createUser(tenantWebsite);
+      const res = await request()
+        .post(`/api/invite/accept/${inviteUser.token}`)
+        .send({
+          first_name: 'Ahmed',
+          last_name: 'Bouhuolia',
+          password: 'hard-password',
+          phone_number: '0927918381',
+        });
+
+      const foundSystemUser = await SystemUser.query()
+        .where('email', 'admin@admin.com').first();
+
+      expect(foundSystemUser).is.not.null;
+      expect(foundSystemUser.id).is.not.null;
+      expect(foundSystemUser.tenantId).equals(inviteUser.tenantId);
+      expect(foundSystemUser.email).equals('admin@admin.com');
+      expect(foundSystemUser.firstName).equals('Ahmed');
+      expect(foundSystemUser.lastName).equals('Bouhuolia');
+      expect(foundSystemUser.active).equals(1);
+      expect(foundSystemUser.lastLoginAt).is.null;
+      expect(foundSystemUser.createdAt).is.not.null;
+      expect(foundSystemUser.updatedAt).is.null;
+    });
+
+    it('Should invite token be deleted after invite accept.', async () => {
+      const res = await request()
+        .post(`/api/invite/accept/${inviteUser.token}`)
+        .send({
+          first_name: 'Ahmed',
+          last_name: 'Bouhuolia',
+          password: 'hard-password',
+          phone_number: '0927918381',
+        });
+      
+      const foundInviteToken = await Invite.query().where('token', inviteUser.token);
+      expect(foundInviteToken.length).equals(0);
+    });
+  });
+
+  describe('GET: `/api/invite_users/:token`', () => {
+    it('Should response token invalid.', () => {
+
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/server/tests/routes/items.test.js b/packages/server/tests/routes/items.test.js
new file mode 100644
index 000000000..4e2858668
--- /dev/null
+++ b/packages/server/tests/routes/items.test.js
@@ -0,0 +1,729 @@
+import {
+  request,
+  expect,
+} from '~/testInit';
+import Item from 'models/Item';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+
+describe('routes: `/items`', () => {
+  describe('POST: `/items`', () => {
+    it('Should not create a new item if the user was not authorized.', async () => {
+      const res = await request()
+        .post('/api/items')
+        .send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should `name` be required.', async () => {
+      const res = await request()
+        .post('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'name', location: 'body',
+      });
+    });
+
+    it('Should `type` be required.', async () => {
+      const res = await request()
+        .post('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'type', location: 'body',
+      });
+    });
+
+    it('Should `type` be one of defined words.', async () => {
+      const res = await request()
+        .post('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          type: 'not-defined',
+        });
+
+      expect(res.body.errors).include.something.deep.equals({
+        value: 'not-defined',
+        msg: 'Invalid value',
+        param: 'type',
+        location: 'body',
+      });
+    });
+
+    it('Should `buy_price` be numeric.', async () => {
+      const res = await request()
+        .post('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          cost_price: 'not_numeric',
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        value: 'not_numeric',
+        msg: 'Invalid value',
+        param: 'cost_price',
+        location: 'body',
+      });
+    });
+
+    it('Should `sell_price` be numeric.', async () => {
+      const res = await request()
+        .post('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          sell_price: 'not_numeric',
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({ 
+        value: 'not_numeric',
+        msg: 'Invalid value',
+        param: 'sell_price',
+        location: 'body',
+      });
+    });
+
+    it('Should `sell_account_id` be integer.', async () => {
+      const res = await request()
+        .post('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          cost_account_id: 'not_numeric',
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        value: 'not_numeric',
+        msg: 'Invalid value',
+        param: 'cost_account_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `cost_account_id` be integer.', async () => {
+      const res = await request()
+        .post('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          sell_account_id: 'not_numeric',
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        value: 'not_numeric',
+        msg: 'Invalid value',
+        param: 'sell_account_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `cost_account_id` be required if `cost_price` was presented.', async () => {
+
+    });
+
+    it('Should `buy_account_id` be required if `buy_price` was presented.', async () => {
+
+    });
+
+    it('Should `inventory_account_id` be required if type was `inventory` item.', async () => {
+      const res = await request()
+        .post('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Item Name',
+          type: 'inventory',
+          sell_price: 10.2,
+          cost_price: 20.2,
+          sell_account_id: 10,
+          cost_account_id: 20,
+        });
+
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'inventory_account_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `inventory_account_id` be not required if type was not `inventory`.', async () => {
+      const res = await request()
+        .post('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Item Name',
+          type: 'service',
+          sell_price: 10.2,
+          cost_price: 20.2,
+          sell_account_id: 10,
+          cost_account_id: 20,
+        });
+
+      expect(res.body.errors).include.something.deep.not.equals({
+        msg: 'Invalid value',
+        param: 'inventory_account_id',
+        location: 'body',
+      });
+    });
+
+    it('Should response bad request in case `cost account` was not exist.', async () => {
+      const res = await request()
+        .post('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Item Name',
+          type: 'service',
+          sell_price: 10.2,
+          cost_price: 20.2,
+          sell_account_id: 10,
+          cost_account_id: 20,
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'COST_ACCOUNT_NOT_FOUND', code: 100,
+      });
+    });
+
+    it('Should response bad request in case sell account was not exist.', async () => {
+      const res = await request()
+        .post('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Item Name',
+          type: 'service',
+          sell_price: 10.2,
+          cost_price: 20.2,
+          sell_account_id: 10,
+          cost_account_id: 20,
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'SELL_ACCOUNT_NOT_FOUND', code: 120,
+      });
+    });
+
+    it('Should response not category found in case item category was not exist.', async () => {
+      const res = await request()
+        .post('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Item Name',
+          type: 'service',
+          sell_price: 10.2,
+          cost_price: 20.2,
+          sell_account_id: 10,
+          cost_account_id: 20,
+          category_id: 20,
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'ITEM_CATEGORY_NOT_FOUND', code: 140,
+      });
+    });
+
+    it('Should response success with correct data format.', async () => {
+      const account = await tenantFactory.create('account');
+      const anotherAccount = await tenantFactory.create('account');
+      const itemCategory = await tenantFactory.create('item_category');
+
+      const res = await request()
+        .post('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Item Name',
+          type: 'service',
+          sell_price: 10.2,
+          cost_price: 20.2,
+          sell_account_id: account.id,
+          cost_account_id: anotherAccount.id,
+          category_id: itemCategory.id,
+        });
+
+      expect(res.status).equals(200);
+    });
+
+    it('Should store the given item details to the storage.', async () => {
+      const account = await tenantFactory.create('account');
+      const anotherAccount = await tenantFactory.create('account');
+      const itemCategory = await tenantFactory.create('item_category');
+
+      const res = await request()
+        .post('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Item Name',
+          type: 'service',
+          sku: 'SKU CODE',
+          sell_price: 10.2,
+          cost_price: 20.2,
+          sell_account_id: account.id,
+          cost_account_id: anotherAccount.id,
+          category_id: itemCategory.id,
+          note: 'note about item'
+        });
+
+      const storedItem = await Item.tenant().query().where('id', res.body.id).first();
+
+      expect(storedItem.name).equals('Item Name');
+      expect(storedItem.type).equals('service');
+
+      expect(storedItem.sellPrice).equals(10.2);
+      expect(storedItem.costPrice).equals(20.2);
+      expect(storedItem.sellAccountId).equals(account.id);
+      expect(storedItem.costAccountId).equals(anotherAccount.id);
+      expect(storedItem.categoryId).equals(itemCategory.id);
+      expect(storedItem.sku).equals('SKU CODE');
+      expect(storedItem.note).equals('note about item');
+      expect(storedItem.userId).is.not.null;
+    });
+  });
+
+  describe('POST: `items/:id`', () => {
+    it('Should response item not found in case item id was not exist.', async () => {
+      const res = await request()
+        .post('/api/items/100')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Item Name',
+          type: 'product',
+          cost_price: 100,
+          sell_price: 200,
+          sell_account_id: 1,
+          cost_account_id: 2,
+          category_id: 2,
+        });
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'ITEM.NOT.FOUND', code: 100,
+      });
+    });
+
+    it('Should `name` be required.', async () => {
+      const item = await tenantFactory.create('item');
+      const res = await request()
+        .post(`/api/items/${item.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'name', location: 'body',
+      });
+    });
+
+    it('Should `type` be required.', async () => {
+      const item = await tenantFactory.create('item');
+      const res = await request()
+        .post(`/api/items/${item.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'type', location: 'body',
+      });
+    });
+
+    it('Should `sell_price` be numeric.', async () => {
+      const item = await tenantFactory.create('item');
+      const res = await request()
+        .post(`/api/items/${item.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          sell_price: 'not_numeric',
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({ 
+        value: 'not_numeric',
+        msg: 'Invalid value',
+        param: 'sell_price',
+        location: 'body',
+      });
+    });
+
+    it('Should `cost_price` be numeric.', async () => {
+      const item = await tenantFactory.create('item');
+      const res = await request()
+        .post(`/api/items/${item.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          cost_price: 'not_numeric',
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({ 
+        value: 'not_numeric',
+        msg: 'Invalid value',
+        param: 'cost_price',
+        location: 'body',
+      });
+    });
+
+    it('Should `sell_account_id` be integer.', async () => {
+      const item = await tenantFactory.create('item');
+      const res = await request()
+        .post(`/api/items/${item.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          sell_account_id: 'not_numeric',
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        value: 'not_numeric',
+        msg: 'Invalid value',
+        param: 'sell_account_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `cost_account_id` be integer.', async () => {
+      const item = await tenantFactory.create('item');
+      const res = await request()
+        .post(`/api/items/${item.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          cost_account_id: 'not_numeric',
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        value: 'not_numeric',
+        msg: 'Invalid value',
+        param: 'cost_account_id',
+        location: 'body',
+      });
+    });
+
+    it ('Should response bad request in case cost account was not exist.', async () => {
+      const item = await tenantFactory.create('item');
+      const res = await request()
+        .post(`/api/items/${item.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Item Name',
+          type: 'service',
+          sell_price: 10.2,
+          cost_price: 20.2,
+          sell_account_id: 10,
+          cost_account_id: 20,
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'COST_ACCOUNT_NOT_FOUND', code: 100,
+      });
+    });
+
+    it('Should response bad request in case sell account was not exist.', async () => {
+      const item = await tenantFactory.create('item');
+      const res = await request()
+        .post(`/api/items/${item.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Item Name',
+          type: 'product',
+          sell_price: 10.2,
+          cost_price: 20.2,
+          sell_account_id: 1000000,
+          cost_account_id: 1000000,
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'SELL_ACCOUNT_NOT_FOUND', code: 120,
+      });
+    });
+
+    it('Should update details of the given item.', async () => {
+      const account = await tenantFactory.create('account');
+      const anotherAccount = await tenantFactory.create('account');
+      const itemCategory = await tenantFactory.create('item_category');
+
+      const item = await tenantFactory.create('item');
+      const res = await request()
+        .post(`/api/items/${item.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'New Item Name',
+          type: 'service',
+          sell_price: 10.2,
+          cost_price: 20.2,
+          sell_account_id: account.id,
+          cost_account_id: anotherAccount.id,
+          category_id: itemCategory.id,
+        });
+
+      const updatedItem = await Item.tenant().query().findById(item.id);
+
+      expect(updatedItem.name).equals('New Item Name');
+      expect(updatedItem.type).equals('service');
+      expect(updatedItem.sellPrice).equals(10.2);
+      expect(updatedItem.costPrice).equals(20.2);
+      expect(updatedItem.sellAccountId).equals(account.id);
+      expect(updatedItem.costAccountId).equals(anotherAccount.id);
+      expect(updatedItem.categoryId).equals(itemCategory.id);
+    });
+  });
+
+  describe('DELETE: `items/:id`', () => {
+    it('Should response not found in case the item was not exist.', async () => {
+      const res = await request()
+        .delete('/api/items/10')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+    });
+
+    it('Should response success in case was exist.', async () => {
+      const item = await tenantFactory.create('item');
+      const res = await request()
+        .delete(`/api/items/${item.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(200);
+    });
+
+    it('Should delete the given item from the storage.', async () => {
+      const item = await tenantFactory.create('item');
+      await request()
+        .delete(`/api/items/${item.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      const storedItems = await Item.tenant().query().where('id', item.id);
+      expect(storedItems).to.have.lengthOf(0);
+    });
+  });
+
+  describe('DELETE: `items?ids=`', () => {
+    it('Should response in case one of items ids where not exists.', async () => {
+      const res = await request()
+        .delete('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [100, 200],
+        })
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'ITEMS.NOT.FOUND', code: 200, ids: [100, 200],
+      });
+    });
+
+    it('Should delete the given items from the storage.', async () => {
+      const item1 = await tenantFactory.create('item');
+      const item2 = await tenantFactory.create('item');
+
+      const res = await request()
+        .delete('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [item1.id, item2.id],
+        })
+        .send();
+
+      const foundItems = await Item.tenant().query();
+
+      expect(res.status).equals(200);
+      expect(foundItems.length).equals(0)
+    });
+  });
+
+  describe('GET: `items`', () => {
+    it('Should response unauthorized access in case the user not authenticated.', async () => {
+      const res = await request()
+        .get('/api/items')
+        .send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should retrieve items list with associated accounts.', async () => {
+      await tenantFactory.create('resource', { name: 'items' });
+      await tenantFactory.create('item');
+
+      const res = await request()
+        .get('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(200);
+
+      expect(res.body.items).to.be.a('object');
+      expect(res.body.items.results).to.be.a('array');
+      expect(res.body.items.results.length).equals(1);
+
+      expect(res.body.items.results[0].cost_account).to.be.an('object');
+      expect(res.body.items.results[0].sell_account).to.be.an('object');
+      expect(res.body.items.results[0].inventory_account).to.be.an('object');
+      expect(res.body.items.results[0].category).to.be.an('object');
+    });
+
+    it('Should retrieve ordered items based on the given `column_sort_order` and `sort_order` query.', async () => {
+      await tenantFactory.create('item', { name: 'ahmed' });
+      await tenantFactory.create('item', { name: 'mohamed' });
+
+      const res = await request()
+        .get('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          column_sort_order: 'name',
+          sort_order: 'desc',
+        })
+        .send();
+
+      expect(res.body.items.results.length).equals(2);
+      expect(res.body.items.results[0].name).equals('mohamed');
+      expect(res.body.items.results[1].name).equals('ahmed');
+    });
+
+    it('Should retrieve pagination meta of items list.', async () => {
+      await tenantFactory.create('resource', { name: 'items' });
+
+      const res = await request()
+        .get('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.body.items.results).to.be.a('array');
+      expect(res.body.items.results.length).equals(0);
+      expect(res.body.items.pagination).to.be.a('object');
+      expect(res.body.items.pagination.total).to.be.a('number');
+      expect(res.body.items.pagination.total).equals(0)
+    });
+
+    it('Should retrieve filtered items based on custom view conditions.', async () => {
+      const item1 = await tenantFactory.create('item', { type: 'service' });
+      const item2 = await tenantFactory.create('item', { type: 'service' });
+      const item3 = await tenantFactory.create('item', { type: 'inventory' });
+      const item4 = await tenantFactory.create('item', { type: 'inventory' });
+
+      const view = await tenantFactory.create('view', {
+        name: 'Items Inventory',
+        resource_id: 2,
+        roles_logic_expression: '1',
+      });
+      const viewCondition = await tenantFactory.create('view_role', {
+        view_id: view.id,
+        index: 1,
+        field_id: 12,
+        value: 'inventory',
+        comparator: 'equals',
+      });
+      const res = await request()
+        .get('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          custom_view_id: view.id,
+        })
+        .send();
+
+      expect(res.body.customViewId).equals(view.id);
+      expect(res.body.viewColumns).to.be.a('array');
+      expect(res.body.viewConditions).to.be.a('array');
+      expect(res.body.items.results.length).equals(2);
+      expect(res.body.items.results[0].type).equals('inventory');
+      expect(res.body.items.results[1].type).equals('inventory');
+    });
+
+    it('Should retrieve filtered items based on filtering conditions.', async () => {
+      const item1 = await tenantFactory.create('item', { type: 'service' });
+      const item2 = await tenantFactory.create('item', { type: 'service', name: 'target' });
+      const item3 = await tenantFactory.create('item', { type: 'inventory' });
+      const item4 = await tenantFactory.create('item', { type: 'inventory' });
+
+      const res = await request()
+        .get('/api/items')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          stringified_filter_roles: JSON.stringify([
+            {
+              condition: 'AND',
+              field_key: 'type',
+              comparator: 'equals',
+              value: 'inventory',
+            },
+            {
+              condition: 'OR',
+              field_key: 'name',
+              comparator: 'equals',
+              value: 'target',
+            },
+          ]),
+        })
+        .send();
+
+      expect(res.body.items.results.length).equals(3);
+      expect(res.body.items.results[0].name).equals('target');
+      expect(res.body.items.results[1].type).equals('inventory');
+      expect(res.body.items.results[2].type).equals('inventory');
+    });
+  });
+});
diff --git a/packages/server/tests/routes/itemsCategories.test.js b/packages/server/tests/routes/itemsCategories.test.js
new file mode 100644
index 000000000..63e1ee1a2
--- /dev/null
+++ b/packages/server/tests/routes/itemsCategories.test.js
@@ -0,0 +1,311 @@
+import {
+  request,
+  expect,
+} from '~/testInit';
+import ItemCategory from 'models/ItemCategory';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+describe('routes: /item_categories/', () => {
+  describe('POST `/items_categories``', async () => {
+    it('Should not create a item category if the user was not authorized.', async () => {
+      const res = await request().post('/api/item_categories').send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should `name` be required.', async () => {
+      const res = await request()
+        .post('/api/item_categories')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+    });
+
+    it('Should `parent_category_id` be exist in the storage.', async () => {
+      const res = await request()
+        .post('/api/item_categories')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Clothes',
+          parent_category_id: 10,
+        });
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'PARENT_CATEGORY_NOT_FOUND', code: 100,
+      });
+    });
+
+    it('Should response success with correct form data.', async () => {
+      const res = await request()
+        .post('/api/item_categories')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Clothes',
+          description: 'Here is description',
+        });
+
+      expect(res.status).equals(200);
+      expect(res.body.category).to.be.a('object');
+      expect(res.body.category.id).to.be.a('number');
+      expect(res.body.category.name).to.be.a('string');
+      expect(res.body.category.description).to.be.a('string');
+    });
+
+    it('Should item category data be saved to the storage.', async () => {
+      const category = await tenantFactory.create('item_category');
+      const res = await request()
+        .post('/api/item_categories')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Clothes',
+          description: 'Here is description',
+          parent_category_id: category.id,
+        });
+
+      expect(res.status).equals(200);
+
+      const storedCategory = await ItemCategory.tenant().query()
+        .where('id', res.body.category.id)
+        .first();
+
+      expect(storedCategory.name).equals('Clothes');
+      expect(storedCategory.description).equals('Here is description');
+      expect(storedCategory.parentCategoryId).equals(category.id);
+      expect(storedCategory.userId).to.be.a('number');
+    });
+  });
+
+  describe('POST `/items_category/{id}`', () => {
+    it('Should not update a item category if the user was not authorized.', async () => {
+      const category = await tenantFactory.create('item_category');
+      const res = await request()
+        .post(`/api/item_categories/${category.id}`)
+        .send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should `name` be required.', async () => {
+      const category = await tenantFactory.create('item_category');
+      const res = await request()
+        .post(`/api/item_categories/${category.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+    });
+
+    it('Should `parent_category_id` be exist in the storage.', async () => {
+      const category = await tenantFactory.create('item_category');
+      const res = await request()
+        .post(`/api/item_categories/${category.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Name',
+          parent_category_id: 10,
+        });
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'PARENT_CATEGORY_NOT_FOUND', code: 100,
+      });
+    });
+
+    it('Should response success with correct data format.', async () => {
+      const category = await tenantFactory.create('item_category');
+      const anotherCategory = await tenantFactory.create('item_category');
+
+      const res = await request()
+        .post(`/api/item_categories/${category.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Name',
+          parent_category_id: anotherCategory.id,
+          description: 'updated description',
+        });
+
+      expect(res.status).equals(200);
+    });
+
+    it('Should item category data be update in the storage.', async () => {
+      const category = await tenantFactory.create('item_category');
+      const anotherCategory = await tenantFactory.create('item_category');
+
+      const res = await request()
+        .post(`/api/item_categories/${category.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'Name',
+          parent_category_id: anotherCategory.id,
+          description: 'updated description',
+        });
+
+      const storedCategory = await ItemCategory.tenant().query()
+        .where('id', res.body.id)
+        .first();
+
+      expect(storedCategory.name).equals('Name');
+      expect(storedCategory.description).equals('updated description');
+      expect(storedCategory.parentCategoryId).equals(anotherCategory.id);
+    });
+  });
+
+  describe('DELETE: `/items_categories`', async () => {
+    it('Should not delete the give item category if the user was not authorized.', async () => {
+      const category = await tenantFactory.create('item_category');
+
+      const res = await request()
+        .delete(`/api/item_categories/${category.id}`)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should not delete if the item category was not found.', async () => {
+      const res = await request()
+        .delete('/api/item_categories/10')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+    });
+
+    it('Should response success after delete the given item category.', async () => {
+      const category = await tenantFactory.create('item_category');
+      const res = await request()
+        .delete(`/api/item_categories/${category.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(200);
+    });
+
+    it('Should delete the give item category from the storage.', async () => {
+      const category = await tenantFactory.create('item_category');
+      const res = await request()
+        .delete(`/api/item_categories/${category.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      const categories = await ItemCategory.tenant().query()
+        .where('id', category.id);
+
+      expect(categories).to.have.lengthOf(0);
+    });
+  });
+
+  describe('GET: `/item_categories`', () => {
+
+    it('Should retrieve list of item categories.', async () => {
+      const category1 = await tenantFactory.create('item_category');
+      const category2 = await tenantFactory.create('item_category', { parent_category_id: category1.id });
+
+      const res = await request()
+        .get('/api/item_categories')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.body.categories).to.be.a('array');
+      expect(res.body.categories.length).equals(2);
+      
+      expect(res.body.categories[0].id).to.be.a('number');
+      expect(res.body.categories[0].name).to.be.a('string');
+      expect(res.body.categories[0].parent_category_id).to.be.a('null');
+      expect(res.body.categories[0].description).to.be.a('string');
+
+      expect(res.body.categories[1].parent_category_id).to.be.a('number');
+    });
+
+
+    it('Should retrieve of related items.', async () => {
+      const category1 = await tenantFactory.create('item_category');
+      const category2 = await tenantFactory.create('item_category', { parent_category_id: category1.id });
+
+      await tenantFactory.create('item', { category_id: category1.id });
+
+      const res = await request()
+        .get('/api/item_categories')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.body.categories[0].count).to.be.a('number');
+      expect(res.body.categories[0].count).equals(1);
+    });
+  });
+
+  describe('GET `/items_category/{id}', () => {
+    it('Should response not found with incorrect item category ID.', () => {
+
+    });
+
+    it('Should response success with exist item category.', () => {
+
+    });
+
+    it('Should response data of item category.', () => {
+
+    });
+  });
+
+  describe('DELETE: `/items_cateogires`', () => {
+    it('Should response bad request in case one of item categories id not exists in the storage.', async () => {
+      const res = await request()
+        .delete('/api/item_categories/bulk')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [1020, 2020],
+        })
+        .send();
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'ITEM.CATEGORIES.IDS.NOT.FOUND', code: 200
+      });
+    });
+
+    it('Should delete the given item categories.', async () => {
+      const itemCategory = await tenantFactory.create('item_category');
+      const itemCategory2 = await tenantFactory.create('item_category');
+
+      const res = await request()
+        .delete('/api/item_categories/bulk')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          ids: [itemCategory.id, itemCategory2.id],
+        })
+        .send();
+
+      const deleteItemCategories = await ItemCategory.tenant().query()
+        .whereIn('id', [itemCategory.id, itemCategory2.id]);
+
+      expect(deleteItemCategories.length).equals(0);
+    });
+  });
+});
diff --git a/packages/server/tests/routes/options.test.js b/packages/server/tests/routes/options.test.js
new file mode 100644
index 000000000..cc7445e30
--- /dev/null
+++ b/packages/server/tests/routes/options.test.js
@@ -0,0 +1,120 @@
+import {
+  request,
+  expect,
+} from '~/testInit';
+import Option from 'models/Option';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+
+describe('routes: `/options`', () => {
+  describe('POST: `/options/`', () => {
+    it('Should response unauthorized if the user was not logged in.', async () => {
+      const res = await request()
+        .post('/api/options')
+        .send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should response the options key and group is not defined.', async () => {
+      const res = await request()
+        .post('/api/options')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          options: [
+            {
+              key: 'key',
+              value: 'hello world',
+              group: 'group',
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'OPTIONS.KEY.NOT.DEFINED',
+        code: 200,
+        keys: [
+          { key: 'key', group: 'group' },
+        ],
+      });
+    });
+
+    it('Should save options to the storage.', async () => {
+      const res = await request()
+        .post('/api/options')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          options: [{
+            key: 'name',
+            group: 'organization',
+            value: 'hello world', 
+          }],
+        });
+      expect(res.status).equals(200);
+
+      const storedOptions = await Option.tenant().query()
+        .where('group', 'organization')
+        .where('key', 'name');
+
+      expect(storedOptions.metadata.length).equals(1);
+    });
+  });
+
+  describe('GET: `/options`', () => {
+    it('Should response unauthorized if the user was not unauthorized.', async () => {
+      const res = await request()
+        .get('/api/options')
+        .query({
+          group: 'organization',
+        })
+        .send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should retrieve options the associated to the given group.', async () => {
+      await tenantFactory.create('option', { group: 'organization', key: 'name' });
+      await tenantFactory.create('option', { group: 'organization', key: 'base_currency' });
+
+      const res = await request()
+        .get('/api/options')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          group: 'organization',
+        })
+        .send();
+
+      expect(res.status).equals(200);
+      expect(res.body.options).is.an('array');
+      expect(res.body.options.length).equals(2);
+    });
+
+    it('Should retrieve options that associated to the given key.', async () => {
+      await tenantFactory.create('option', { group: 'organization', key: 'base_currency' });
+      await tenantFactory.create('option', { group: 'organization', key: 'name' });
+
+      const res = await request()
+        .get('/api/options')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({
+          key: 'name',
+        })
+        .send();
+
+      expect(res.status).equals(200);
+      expect(res.body.options).is.an('array');
+      expect(res.body.options.length).equals(1);
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/server/tests/routes/payable_aging.test.js b/packages/server/tests/routes/payable_aging.test.js
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/server/tests/routes/payment_receives.test.js b/packages/server/tests/routes/payment_receives.test.js
new file mode 100644
index 000000000..c89af23fb
--- /dev/null
+++ b/packages/server/tests/routes/payment_receives.test.js
@@ -0,0 +1,274 @@
+import {
+  request,
+  expect,
+} from '~/testInit';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+import {
+  PaymentReceive,
+  PaymentReceiveEntry,
+} from 'models';
+
+describe('route: `/sales/payment_receives`', () => {
+  describe('POST: `/sales/payment_receives`', () => {
+    it('Should `customer_id` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/payment_receives')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'customer_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `payment_date` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/payment_receives')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'payment_date',
+        location: 'body',
+      });
+    });
+
+    it('Should `deposit_account_id` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/payment_receives')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'deposit_account_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `payment_receive_no` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/payment_receives')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'payment_receive_no',
+        location: 'body',
+      });
+    });
+
+    it('Should invoices IDs be required.', async () => {
+      const res = await request()
+        .post('/api/sales/payment_receives')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'payment_receive_no',
+        location: 'body',
+      });
+    });
+
+    it('Should `customer_id` be exists on the storage.', async () => {
+      const res = await request()
+        .post('/api/sales/payment_receives')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: 123,
+          payment_date: '2020-02-02',
+          reference_no: '123',
+          deposit_account_id: 100,
+          payment_receive_no: '123',
+          entries: [
+            {
+              invoice_id: 1,
+              payment_amount: 1000,
+            }
+          ],
+        });
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'CUSTOMER.ID.NOT.EXISTS', code: 200,
+      });
+    });
+
+    it('Should `deposit_account_id` be exists on the storage.', async () => {
+      const customer = await tenantFactory.create('customer');
+      const res = await request()
+        .post('/api/sales/payment_receives')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: customer.id,
+          payment_date: '2020-02-02',
+          reference_no: '123',
+          deposit_account_id: 10000,
+          payment_receive_no: '123',
+          entries: [
+            {
+              invoice_id: 1,
+              payment_amount: 1000,
+            }
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'DEPOSIT.ACCOUNT.NOT.EXISTS', code: 300,
+      });
+    });
+
+    it('Should invoices IDs be exist on the storage.', async () => {
+      const customer = await tenantFactory.create('customer');
+      const account = await tenantFactory.create('account');
+
+      const res = await request()
+        .post('/api/sales/payment_receives')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: customer.id,
+          payment_date: '2020-02-02',
+          reference_no: '123',
+          deposit_account_id: account.id,
+          payment_receive_no: '123',
+          entries: [
+            {
+              invoice_id: 1,
+              payment_amount: 1000,
+            }
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'DEPOSIT.ACCOUNT.NOT.EXISTS', code: 300,
+      });
+    });
+
+    it('Should payment receive number be unique on the storage.', async () => {
+      const customer = await tenantFactory.create('customer');
+      const account = await tenantFactory.create('account');
+      const paymentReceive = await tenantFactory.create('payment_receive', {
+        payment_receive_no: '123',
+      });
+
+      const res = await request()
+        .post('/api/sales/payment_receives')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: customer.id,
+          payment_date: '2020-02-02',
+          reference_no: '123',
+          deposit_account_id: account.id,
+          payment_receive_no: '123',
+          entries: [
+            {
+              invoice_id: 1,
+              payment_amount: 1000,
+            }
+          ],
+        });
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'PAYMENT.RECEIVE.NUMBER.EXISTS', code: 400,
+      });
+    });
+    
+    it('Should store the payment receive details with associated entries.', async () => {
+      const customer = await tenantFactory.create('customer');
+      const account = await tenantFactory.create('account');
+      const invoice = await tenantFactory.create('sale_invoice');
+      
+      const res = await request()
+        .post('/api/sales/payment_receives')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: customer.id,
+          payment_date: '2020-02-02',
+          reference_no: '123',
+          deposit_account_id: account.id,
+          payment_receive_no: '123',
+          entries: [
+            {
+              invoice_id: invoice.id,
+              payment_amount: 1000,
+            }
+          ],
+        });
+
+      const storedPaymentReceived = await PaymentReceive.tenant().query().where('id', res.body.id).first();
+
+      expect(res.status).equals(200);
+      expect(storedPaymentReceived.customerId).equals(customer.id)
+      expect(storedPaymentReceived.referenceNo).equals('123');
+      expect(storedPaymentReceived.paymentReceiveNo).equals('123');
+    });
+  });
+
+  describe('POST: `/sales/payment_receives/:id`', () => {
+    it('Should update the payment receive details with associated entries.', async () => {
+      const paymentReceive = await tenantFactory.create('payment_receive');
+      const customer = await tenantFactory.create('customer');
+      const account = await tenantFactory.create('account');
+      const invoice = await tenantFactory.create('sale_invoice');
+
+      const res = await request()
+        .post(`/api/sales/payment_receives/${paymentReceive.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: customer.id,
+          payment_date: '2020-02-02',
+          reference_no: '123',
+          deposit_account_id: account.id,
+          payment_receive_no: '123',
+          entries: [
+            {
+              invoice_id: invoice.id,
+              payment_amount: 1000,
+            }
+          ],
+        });
+      expect(res.status).equals(200);
+    });
+  });
+
+  describe('DELETE: `/sales/payment_receives/:id`', () => {
+    it('Should response the given payment receive is not exists on the storage.', async () => {
+      const res = await request()
+        .delete(`/api/sales/payment_receives/123`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'PAYMENT.RECEIVE.NO.EXISTS', code: 600,
+      });
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/server/tests/routes/receivable_aging.test.js b/packages/server/tests/routes/receivable_aging.test.js
new file mode 100644
index 000000000..a08c05fb1
--- /dev/null
+++ b/packages/server/tests/routes/receivable_aging.test.js
@@ -0,0 +1,234 @@
+import {
+  request,
+  expect,
+} from '~/testInit';
+import Item from 'models/Item';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+
+describe('routes: `/financial_statements/receivable_aging_summary`', () => {
+
+  it('Should retrieve customers list.', async () => {
+    const customer1 = await tenantFactory.create('customer', { display_name: 'Ahmed' });
+    const customer2 = await tenantFactory.create('customer', { display_name: 'Mohamed' });
+
+    const res = await request()
+      .get('/api/financial_statements/receivable_aging_summary')
+      .set('x-access-token', loginRes.body.token)
+      .set('organization-id', tenantWebsite.organizationId)
+      .send();
+
+    expect(res.status).equals(200);
+    
+    expect(res.body.aging.customers).is.an('array');
+    expect(res.body.aging.customers.length).equals(2);
+
+    expect(res.body.aging.customers[0].customer_name).equals('Ahmed');
+    expect(res.body.aging.customers[1].customer_name).equals('Mohamed');
+  });
+
+  it('Should respon se the customers ids not found.', async () => {
+    const res = await request()
+      .get('/api/financial_statements/receivable_aging_summary')
+      .set('x-access-token', loginRes.body.token)
+      .set('organization-id', tenantWebsite.organizationId)
+      .query({
+        customer_ids: [3213, 3322],
+      })
+      .send();
+
+    expect(res.status).equals(400);
+    expect(res.body.errors).include.something.deep.equals({
+      type: 'CUSTOMERS.IDS.NOT.FOUND', code: 300, ids: [3213, 3322]
+    })
+  });
+
+  it('Should retrieve aging report columns.', async () => {
+    const customer1 = await tenantFactory.create('customer', { display_name: 'Ahmed' });
+    const customer2 = await tenantFactory.create('customer', { display_name: 'Mohamed' });
+
+    const res = await request()
+      .get('/api/financial_statements/receivable_aging_summary')
+      .set('x-access-token', loginRes.body.token)
+      .set('organization-id', tenantWebsite.organizationId)
+      .query({
+        as_date: '2020-06-01',
+        aging_days_before: 30,
+        aging_periods: 6,
+      })
+      .send();
+
+    expect(res.body.columns).length(6);
+    expect(res.body.columns[0].before_days).equals(0);
+    expect(res.body.columns[0].to_days).equals(30);
+
+    expect(res.body.columns[1].before_days).equals(31);
+    expect(res.body.columns[1].to_days).equals(60);
+    
+    expect(res.body.columns[2].before_days).equals(61);
+    expect(res.body.columns[2].to_days).equals(90);
+
+    expect(res.body.columns[3].before_days).equals(91);
+    expect(res.body.columns[3].to_days).equals(120);
+
+    expect(res.body.columns[4].before_days).equals(121);
+    expect(res.body.columns[4].to_days).equals(150);
+
+    expect(res.body.columns[5].before_days).equals(151);
+    expect(res.body.columns[5].to_days).equals(null);
+  });
+
+  it('Should retrieve receivable total of the customers.', async () => {
+    const customer1 = await tenantFactory.create('customer', { display_name: 'Ahmed' });
+    const customer2 = await tenantFactory.create('customer', { display_name: 'Mohamed' });
+
+    await tenantFactory.create('account_transaction', {
+      contact_id: customer1.id,
+      contact_type: 'customer',
+      debit: 10000,
+      credit: 0,
+      account_id: 10,
+      date: '2020-01-01',
+    });
+    
+    await tenantFactory.create('account_transaction', {
+      contact_id: customer1.id,
+      contact_type: 'customer',
+      debit: 1000,
+      credit: 0,
+      account_id: 10,
+      date: '2020-03-15',
+    });
+
+    // Receive
+    await tenantFactory.create('account_transaction', {
+      contact_id: customer1.id,
+      contact_type: 'customer',
+      debit: 0,
+      credit: 8000,
+      account_id: 10,
+      date: '2020-06-01',
+    });
+    
+    const res = await request()
+      .get('/api/financial_statements/receivable_aging_summary')
+      .set('x-access-token', loginRes.body.token)
+      .set('organization-id', tenantWebsite.organizationId)
+      .query({
+        as_date: '2020-06-01',
+        aging_days_before: 30,
+        aging_periods: 6,
+      })
+      .send();
+
+    expect(res.body.aging.total[0].total).equals(0);
+    expect(res.body.aging.total[1].total).equals(0);
+    expect(res.body.aging.total[2].total).equals(1000);
+    expect(res.body.aging.total[3].total).equals(0);
+    expect(res.body.aging.total[4].total).equals(0);
+    expect(res.body.aging.total[5].total).equals(2000);
+  });
+
+
+  it('Should retrieve customer aging.', async () => {
+    const customer1 = await tenantFactory.create('customer', { display_name: 'Ahmed' });
+    const customer2 = await tenantFactory.create('customer', { display_name: 'Mohamed' });
+
+    await tenantFactory.create('account_transaction', {
+      contact_id: customer1.id,
+      contact_type: 'customer',
+      debit: 10000,
+      credit: 0,
+      account_id: 10,
+      date: '2020-01-14',
+    });
+    
+    await tenantFactory.create('account_transaction', {
+      contact_id: customer1.id,
+      contact_type: 'customer',
+      debit: 1000,
+      credit: 0,
+      account_id: 10,
+      date: '2020-03-15',
+    });
+
+    // Receive
+    await tenantFactory.create('account_transaction', {
+      contact_id: customer1.id,
+      contact_type: 'customer',
+      debit: 0,
+      credit: 8000,
+      account_id: 10,
+      date: '2020-06-01',
+    });
+    
+    const res = await request()
+      .get('/api/financial_statements/receivable_aging_summary')
+      .set('x-access-token', loginRes.body.token)
+      .set('organization-id', tenantWebsite.organizationId)
+      .query({
+        as_date: '2020-06-01',
+        aging_days_before: 30,
+        aging_periods: 6,
+      })
+      .send();
+
+    expect(res.body.aging.customers[0].aging[0].total).equals(0);
+    expect(res.body.aging.customers[0].aging[1].total).equals(0);
+    expect(res.body.aging.customers[0].aging[2].total).equals(1000);
+    expect(res.body.aging.customers[0].aging[3].total).equals(0);
+    expect(res.body.aging.customers[0].aging[4].total).equals(2000);
+    expect(res.body.aging.customers[0].aging[5].total).equals(0);
+  });
+
+  it('Should retrieve the queried customers ids only.', async () => {
+    const customer1 = await tenantFactory.create('customer', { display_name: 'Ahmed' });
+    const customer2 = await tenantFactory.create('customer', { display_name: 'Mohamed' });
+
+    await tenantFactory.create('account_transaction', {
+      contact_id: customer1.id,
+      contact_type: 'customer',
+      debit: 10000,
+      credit: 0,
+      account_id: 10,
+      date: '2020-01-14',
+    });
+    
+    await tenantFactory.create('account_transaction', {
+      contact_id: customer1.id,
+      contact_type: 'customer',
+      debit: 1000,
+      credit: 0,
+      account_id: 10,
+      date: '2020-03-15',
+    });
+
+    // Receive
+    await tenantFactory.create('account_transaction', {
+      contact_id: customer1.id,
+      contact_type: 'customer',
+      debit: 0,
+      credit: 8000,
+      account_id: 10,
+      date: '2020-06-01',
+    });
+    
+    const res = await request()
+      .get('/api/financial_statements/receivable_aging_summary')
+      .set('x-access-token', loginRes.body.token)
+      .set('organization-id', tenantWebsite.organizationId)
+      .query({
+        as_date: '2020-06-01',
+        aging_days_before: 30,
+        aging_periods: 6,
+        customer_ids: [customer1.id],
+      })
+      .send();
+
+    expect(res.body.aging.customers.length).equals(1);
+  })
+});
diff --git a/packages/server/tests/routes/sales_estimates.test.js b/packages/server/tests/routes/sales_estimates.test.js
new file mode 100644
index 000000000..54e20241a
--- /dev/null
+++ b/packages/server/tests/routes/sales_estimates.test.js
@@ -0,0 +1,439 @@
+const { iteratee } = require('lodash');
+import { tenantWebsite, tenantFactory, loginRes } from '~/dbInit';
+import { request, expect } from '~/testInit';
+import { SaleEstimate, SaleEstimateEntry } from '../../src/models';
+
+describe('route: `/sales/estimates`', () => {
+  describe('POST: `/sales/estimates`', () => {
+    it('Should `customer_id` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/estimates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'customer_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `estimate_date` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/estimates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'estimate_date',
+        location: 'body',
+      });
+    });
+
+    it('Should `estimate_number` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/estimates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'estimate_number',
+        location: 'body',
+      });
+    });
+
+    it('Should `entries` be atleast one entry.', async () => {
+      const res = await request()
+        .post('/api/sales/estimates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          entries: [],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        value: [],
+        msg: 'Invalid value',
+        param: 'entries',
+        location: 'body',
+      });
+    });
+
+    it('Should `entries.*.item_id` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/estimates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          entries: [{}],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'entries[0].item_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `entries.*.quantity` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/estimates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          entries: [{}],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'entries[0].quantity',
+        location: 'body',
+      });
+    });
+
+    it('Should be `entries.*.rate` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/estimates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          entries: [{}],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'entries[0].rate',
+        location: 'body',
+      });
+    });
+
+    it('Should `customer_id` be exists on the storage.', async () => {
+      const res = await request()
+        .post('/api/sales/estimates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: 10,
+          estimate_date: '2020-02-02',
+          expiration_date: '2020-03-03',
+          estimate_number: '1',
+          entries: [
+            {
+              item_id: 1,
+              rate: 1,
+              quantity: 2,
+            }
+          ],
+        });
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'CUSTOMER.ID.NOT.FOUND', code: 200,
+      });
+    });
+
+    it('Should `estimate_number` be unique on the storage.', async () => {
+      const saleEstimate = await tenantFactory.create('sale_estimate');
+
+      const res = await request()
+        .post('/api/sales/estimates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: saleEstimate.customerId,
+          estimate_date: '2020-02-02',
+          expiration_date: '2020-03-03',
+          estimate_number: saleEstimate.estimateNumber,
+          entries: [
+            {
+              item_id: 1,
+              rate: 1,
+              quantity: 2,
+            }
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'ESTIMATE.NUMBER.IS.NOT.UNQIUE', code: 300,
+      });
+    });
+
+    it('Should `entries.*.item_id` be exists on the storage.', async () => {
+      const customer = await tenantFactory.create('customer');
+      const res = await request()
+        .post('/api/sales/estimates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: customer.id,
+          estimate_date: '2020-02-02',
+          expiration_date: '2020-03-03',
+          estimate_number: '12',
+          entries: [
+            {
+              item_id: 1,
+              rate: 1,
+              quantity: 2,
+            }
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'ITEMS.IDS.NOT.EXISTS', code: 400,
+      });
+    });
+
+    it('Should store the given details on the storage.', async () => {
+      const customer = await tenantFactory.create('customer');
+      const item = await tenantFactory.create('item');
+
+      const res = await request()
+        .post('/api/sales/estimates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: customer.id,
+          estimate_date: '2020-02-02',
+          expiration_date: '2020-03-03',
+          estimate_number: '12',
+          reference: 'reference',
+          note: 'note here',
+          terms_conditions: 'terms and conditions',
+          entries: [
+            {
+              item_id: item.id,
+              rate: 1,
+              quantity: 2,
+              description: 'desc..'
+            }
+          ],
+        });
+
+      expect(res.status).equals(200);
+
+      const storedEstimate = await SaleEstimate.tenant().query().where('id', res.body.id).first();
+      const storedEstimateEntry = await SaleEstimateEntry.tenant().query().where('estimate_id', res.body.id).first();
+
+      expect(storedEstimate.id).equals(res.body.id);
+      expect(storedEstimate.customerId).equals(customer.id);
+      expect(storedEstimate.reference).equals('reference')
+      expect(storedEstimate.note).equals('note here');
+      expect(storedEstimate.termsConditions).equals('terms and conditions');
+      expect(storedEstimate.estimateNumber).equals('12');
+
+      expect(storedEstimateEntry.itemId).equals(item.id);
+      expect(storedEstimateEntry.rate).equals(1);
+      expect(storedEstimateEntry.quantity).equals(2);
+      expect(storedEstimateEntry.description).equals('desc..');
+    });
+  });
+
+  describe('DELETE: `/sales/estimates/:id`', () => {
+    it('Should estimate id be exists on the storage.', async () => {
+      const estimate = await tenantFactory.create('sale_estimate');
+      const res = await request()
+        .delete(`/api/sales/estimates/123`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'SALE.ESTIMATE.ID.NOT.FOUND', code: 200
+      });
+    });
+
+    it('Should delete the given estimate with associated entries from the storage.', async () => {
+      const estimate = await tenantFactory.create('sale_estimate');
+      const estimateEntry = await tenantFactory.create('sale_estimate_entry', { estimate_id: estimate.id });
+
+      const res = await request()
+        .delete(`/api/sales/estimates/${estimate.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      const foundEstimate = await SaleEstimate.tenant().query().where('id', estimate.id);
+      const foundEstimateEntry = await SaleEstimateEntry.tenant().query().where('estimate_id', estimate.id);
+
+      expect(res.status).equals(200);
+      expect(foundEstimate.length).equals(0);
+      expect(foundEstimateEntry.length).equals(0);
+    });
+  });
+
+  describe('POST: `/sales/estimates/:id`', () => {
+    it('Should estimate id be exists on the storage.', async () => {
+      const customer = await tenantFactory.create('customer');
+      const item = await tenantFactory.create('item');
+
+      const res = await request()
+        .post(`/api/sales/estimates/123`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: customer.id,
+          estimate_date: '2020-02-02',
+          expiration_date: '2020-03-03',
+          estimate_number: '12',
+          reference: 'reference',
+          note: 'note here',
+          terms_conditions: 'terms and conditions',
+          entries: [
+            {
+              item_id: item.id,
+              rate: 1,
+              quantity: 2,
+              description: 'desc..'
+            }
+          ],
+        })
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'SALE.ESTIMATE.ID.NOT.FOUND', code: 200
+      });  
+    });
+
+    it('Should `entries.*.item_id` be exists on the storage.', async () => {
+      const saleEstimate = await tenantFactory.create('sale_estimate');
+      const customer = await tenantFactory.create('customer');
+
+      const res = await request()
+        .post(`/api/sales/estimates/${saleEstimate.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: customer.id,
+          estimate_date: '2020-02-02',
+          expiration_date: '2020-03-03',
+          estimate_number: '12',
+          entries: [
+            {
+              item_id: 1,
+              rate: 1,
+              quantity: 2,
+            }
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'ITEMS.IDS.NOT.EXISTS', code: 400
+      });
+    });
+
+    it('Should sale estimate number unique on the storage.', async () => {
+      const saleEstimate = await tenantFactory.create('sale_estimate');
+      const saleEstimate2 = await tenantFactory.create('sale_estimate');
+
+      const res = await request()
+        .post(`/api/sales/estimates/${saleEstimate.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: saleEstimate.customerId,
+          estimate_date: '2020-02-02',
+          expiration_date: '2020-03-03',
+          estimate_number: saleEstimate2.estimateNumber,
+          entries: [
+            {
+              item_id: 1,
+              rate: 1,
+              quantity: 2,
+            }
+          ],
+        });
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'ESTIMATE.NUMBER.IS.NOT.UNQIUE', code: 300,
+      });
+    });
+
+    it('Should sale estimate entries IDs be exists on the storage and associated to the sale estimate.', async () => {
+      const item = await tenantFactory.create('item');
+      const saleEstimate = await tenantFactory.create('sale_estimate');
+      const saleEstimate2 = await tenantFactory.create('sale_estimate');
+
+      const res = await request()
+        .post(`/api/sales/estimates/${saleEstimate.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: saleEstimate.customerId,
+          estimate_date: '2020-02-02',
+          expiration_date: '2020-03-03',
+          estimate_number: saleEstimate.estimateNumber,
+          entries: [
+            {
+              id: 100,
+              item_id: item.id,
+              rate: 1,
+              quantity: 2,
+            }
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'ESTIMATE.NOT.FOUND.ENTRIES.IDS', code: 500,
+      });
+    });
+
+    it('Should update the given sale estimates with associated entries.', async () => {
+      const customer = await tenantFactory.create('customer');
+      const item = await tenantFactory.create('item');
+      const saleEstimate = await tenantFactory.create('sale_estimate');
+      const saleEstimateEntry = await tenantFactory.create('sale_estimate_entry', {
+        estimate_id: saleEstimate.id,
+      });
+
+      const res = await request()
+        .post(`/api/sales/estimates/${saleEstimate.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: customer.id,
+          estimate_date: '2020-02-02',
+          expiration_date: '2020-03-03',
+          estimate_number: '123',
+          entries: [
+            {
+              id: saleEstimateEntry.id,
+              item_id: item.id,
+              rate: 100,
+              quantity: 200,
+            }
+          ],
+        });
+      expect(res.status).equals(200);
+    });
+  });
+
+
+  describe('GET: `/sales/estimates`', () => {
+    it('Should retrieve sales estimates.', async () => {
+      const res = await request()
+        .get('/api/sales/estimates')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      console.log(res.status, res.body);
+    });
+  });
+});
diff --git a/packages/server/tests/routes/sales_invoices.test.js b/packages/server/tests/routes/sales_invoices.test.js
new file mode 100644
index 000000000..8e759fbdc
--- /dev/null
+++ b/packages/server/tests/routes/sales_invoices.test.js
@@ -0,0 +1,494 @@
+import { tenantWebsite, tenantFactory, loginRes } from '~/dbInit';
+import { request, expect } from '~/testInit';
+import { SaleInvoice } from 'models';
+import { SaleInvoiceEntry } from '../../src/models';
+
+describe('route: `/sales/invoices`', () => {
+  describe('POST: `/sales/invoices`', () => {
+    it('Should `customer_id` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/invoices')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'customer_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `invoice_date` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/invoices')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'invoice_date',
+        location: 'body',
+      });
+    });
+
+    it('Should `due_date` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/invoices')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'due_date',
+        location: 'body',
+      });
+    });
+
+    it('Should `invoice_no` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/invoices')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'invoice_no',
+        location: 'body',
+      });
+    });
+
+    it('Should `status` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/invoices')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'status',
+        location: 'body',
+      });
+    });
+
+    it('Should `entries.*.item_id` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/invoices')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          entries: [{}],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'entries[0].item_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `entries.*.quantity` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/invoices')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          entries: [{}],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'entries[0].quantity',
+        location: 'body',
+      });
+    });
+
+    it('Should `entries.*.rate` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/invoices')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          entries: [{}],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'entries[0].rate',
+        location: 'body',
+      });
+    });
+
+    it('Should `customer_id` be exists on the storage.', async () => {
+      const customer = await tenantFactory.create('customer');
+      const res = await request()
+        .post('/api/sales/invoices')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: 123,
+          invoice_date: '2020-02-02',
+          due_date: '2020-03-03',
+          invoice_no: '123',
+          reference_no: '123',
+          status: 'published',
+          invoice_message: 'Invoice message...',
+          terms_conditions: 'terms and conditions',
+          entries: [
+            {
+              item_id: 1,
+              rate: 1,
+              quantity: 1,
+              discount: 1,
+            }
+          ]
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'CUSTOMER.ID.NOT.EXISTS', code: 200,
+      });
+    });
+
+    it('Should `invoice_date` be bigger than `due_date`.', async () => {
+      
+    });
+
+    it('Should `invoice_no` be unique on the storage.', async () => {
+      const saleInvoice = await tenantFactory.create('sale_invoice', {
+        invoice_no: '123',
+      });
+      const res = await request()
+        .post('/api/sales/invoices')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: 123,
+          invoice_date: '2020-02-02',
+          due_date: '2020-03-03',
+          invoice_no: '123',
+          reference_no: '123',
+          status: 'published',
+          invoice_message: 'Invoice message...',
+          terms_conditions: 'terms and conditions',
+          entries: [
+            {
+              item_id: 1,
+              rate: 1,
+              quantity: 1,
+              discount: 1,
+            }
+          ]
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'SALE.INVOICE.NUMBER.IS.EXISTS', code: 200
+      });
+    });
+
+    it('Should `entries.*.item_id` be exists on the storage.', async () => {
+      const res = await request()
+        .post('/api/sales/invoices')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: 123,
+          invoice_date: '2020-02-02',
+          due_date: '2020-03-03',
+          invoice_no: '123',
+          reference_no: '123',
+          status: 'published',
+          invoice_message: 'Invoice message...',
+          terms_conditions: 'terms and conditions',
+          entries: [
+            {
+              item_id: 1,
+              rate: 1,
+              quantity: 1,
+              discount: 1,
+            }
+          ]
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'ITEMS.IDS.NOT.EXISTS', code: 300,
+      });
+    });
+
+    it('Should save the given sale invoice details with associated entries.', async () => {
+      const customer = await tenantFactory.create('customer');
+      const item = await tenantFactory.create('item');
+      const res = await request()
+        .post('/api/sales/invoices')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: customer.id,
+          invoice_date: '2020-02-02',
+          due_date: '2020-03-03',
+          invoice_no: '123',
+          reference_no: '123',
+          status: 'published',
+          invoice_message: 'Invoice message...',
+          terms_conditions: 'terms and conditions',
+          entries: [
+            {
+              item_id: item.id,
+              rate: 1,
+              quantity: 1,
+              discount: 1,
+            }
+          ]
+        });
+      expect(res.status).equals(200);
+    });
+  });
+
+  describe('POST: `/api/sales/invoices/:id`', () => {
+    it('Should `customer_id` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/invoices/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'customer_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `invoice_date` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/invoices/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'invoice_date',
+        location: 'body',
+      });
+    });
+    
+
+    it('Should `status` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/invoices/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'status',
+        location: 'body',
+      });
+    });
+
+    it('Should `entries.*.item_id` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/invoices/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          entries: [{}],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'entries[0].item_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `entries.*.quantity` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/invoices/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          entries: [{}],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'entries[0].quantity',
+        location: 'body',
+      });
+    });
+
+    it('Should `entries.*.rate` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/invoices/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          entries: [{}],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'entries[0].rate',
+        location: 'body',
+      });
+    });
+
+    it('Should `customer_id` be exists on the storage.', async () => {
+      const customer = await tenantFactory.create('customer');
+      const saleInvoice = await tenantFactory.create('sale_invoice');
+
+      const res = await request()
+        .post(`/api/sales/invoices/${saleInvoice.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: 123,
+          invoice_date: '2020-02-02',
+          due_date: '2020-03-03',
+          invoice_no: '123',
+          reference_no: '123',
+          status: 'published',
+          invoice_message: 'Invoice message...',
+          terms_conditions: 'terms and conditions',
+          entries: [
+            {
+              item_id: 1,
+              rate: 1,
+              quantity: 1,
+              discount: 1,
+            }
+          ]
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'CUSTOMER.ID.NOT.EXISTS', code: 200,
+      });
+    });
+
+    it('Should `invoice_date` be bigger than `due_date`.', async () => {
+      
+    });
+
+    it('Should `invoice_no` be unique on the storage.', async () => {
+      const saleInvoice = await tenantFactory.create('sale_invoice', {
+        invoice_no: '123',
+      });
+      const res = await request()
+        .post('/api/sales/invoices')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: 123,
+          invoice_date: '2020-02-02',
+          due_date: '2020-03-03',
+          invoice_no: '123',
+          reference_no: '123',
+          status: 'published',
+          invoice_message: 'Invoice message...',
+          terms_conditions: 'terms and conditions',
+          entries: [
+            {
+              item_id: 1,
+              rate: 1,
+              quantity: 1,
+              discount: 1,
+            }
+          ]
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'SALE.INVOICE.NUMBER.IS.EXISTS', code: 200
+      });
+    });
+
+    it('Should update the sale invoice details with associated entries.', async () => {
+      const saleInvoice = await tenantFactory.create('sale_invoice');
+      const customer = await tenantFactory.create('customer');
+      const item = await tenantFactory.create('item');
+
+      const res = await request()
+        .post(`/api/sales/invoices/${saleInvoice.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          customer_id: customer.id,
+          invoice_date: '2020-02-02',
+          due_date: '2020-03-03',
+          invoice_no: '1',
+          reference_no: '123',
+          status: 'published',
+          invoice_message: 'Invoice message...',
+          terms_conditions: 'terms and conditions',
+          entries: [
+            {
+              item_id: item.id,
+              rate: 1,
+              quantity: 1,
+              discount: 1,
+            }
+          ]
+        });
+      expect(res.status).equals(200);
+    });
+  });
+
+  describe('DELETE: `/sales/invoices/:id`', () => {
+    it('Should retrieve sale invoice not found.', async () => {
+      const res = await request()
+        .delete('/api/sales/invoices/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'SALE.INVOICE.NOT.FOUND', code: 200,
+      });
+    });
+
+    it('Should delete the given sale invoice with assocaited entries.', async () => {
+      const saleInvoice = await tenantFactory.create('sale_invoice');
+      const saleInvoiceEntey = await tenantFactory.create('sale_invoice_entry', {
+        sale_invoice_id: saleInvoice.id,
+      });
+
+      const res = await request()
+        .delete(`/api/sales/invoices/${saleInvoice.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      const storedSaleInvoice = await SaleInvoice.tenant().query().where('id', saleInvoice.id);
+      const storedSaleInvoiceEntry = await SaleInvoiceEntry.tenant().query().where('id', saleInvoiceEntey.id);
+
+      expect(res.status).equals(200);
+      expect(storedSaleInvoice.length).equals(0);
+      expect(storedSaleInvoiceEntry.length).equals(0);
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/server/tests/routes/sales_receipts.test.js b/packages/server/tests/routes/sales_receipts.test.js
new file mode 100644
index 000000000..5d112acb1
--- /dev/null
+++ b/packages/server/tests/routes/sales_receipts.test.js
@@ -0,0 +1,294 @@
+import { tenantWebsite, tenantFactory, loginRes } from '~/dbInit';
+import { request, expect } from '~/testInit';
+import { SaleReceipt } from 'models';
+
+describe('route: `/sales/receipts`', () => {
+  describe('POST: `/sales/receipts`', () => {
+    it('Should `deposit_account_id` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/receipts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'deposit_account_id',
+        location: 'body',
+      });
+    });
+
+    it('Should `customer_id` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/receipts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'customer_id',
+        location: 'body',
+      });
+    });
+
+    it('should `receipt_date` be required.', async () => {
+      const res = await request()
+        .post('/api/sales/receipts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'receipt_date',
+        location: 'body',
+      });
+    });
+
+    it('Should `entries.*.item_id` be required.', async () => {});
+
+    it('Should `deposit_account_id` be exists.', async () => {
+      const res = await request()
+        .post('/api/sales/receipts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          deposit_account_id: 12220,
+          customer_id: 1,
+          receipt_date: '2020-02-02',
+          reference_no: '123',
+          entries: [
+            {
+              item_id: 1,
+              quantity: 1,
+              rate: 2,
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'DEPOSIT.ACCOUNT.NOT.EXISTS',
+        code: 300,
+      });
+    });
+
+    it('Should `customer_id` be exists.', async () => {
+      const res = await request()
+        .post('/api/sales/receipts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          deposit_account_id: 12220,
+          customer_id: 1001,
+          receipt_date: '2020-02-02',
+          reference_no: '123',
+          entries: [
+            {
+              item_id: 1,
+              quantity: 1,
+              rate: 2,
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'CUSTOMER.ID.NOT.EXISTS',
+        code: 200,
+      });
+    });
+
+    it('Should all `entries.*.item_id` be exists on the storage.', async () => {
+      const res = await request()
+        .post('/api/sales/receipts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          deposit_account_id: 12220,
+          customer_id: 1001,
+          receipt_date: '2020-02-02',
+          reference_no: '123',
+          entries: [
+            {
+              item_id: 1000,
+              quantity: 1,
+              rate: 2,
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'ITEMS.IDS.NOT.EXISTS',
+        code: 400,
+      });
+    });
+
+    it('Should store the sale receipt details with entries to the storage.', async () => {
+      const item = await tenantFactory.create('item');
+      const customer = await tenantFactory.create('customer');
+      const account = await tenantFactory.create('account');
+
+      const res = await request()
+        .post('/api/sales/receipts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          deposit_account_id: account.id,
+          customer_id: customer.id,
+          receipt_date: '2020-02-02',
+          reference_no: '123',
+          receipt_message: 'Receipt message...',
+          statement: 'Receipt statement...',
+          entries: [
+            {
+              item_id: item.id,
+              quantity: 1,
+              rate: 2,
+            },
+          ],
+        });
+
+      const storedSaleReceipt = await SaleReceipt.tenant()
+        .query()
+        .where('id', res.body.id)
+        .first();
+
+      expect(res.status).equals(200);
+      expect(storedSaleReceipt.depositAccountId).equals(account.id);
+      expect(storedSaleReceipt.referenceNo).equals('123');
+      expect(storedSaleReceipt.customerId).equals(customer.id);
+
+      expect(storedSaleReceipt.receiptMessage).equals('Receipt message...');
+      expect(storedSaleReceipt.statement).equals('Receipt statement...');
+    });
+  });
+
+  describe('DELETE: `/sales/receipts/:id`', () => {
+    it('Should the given sale receipt id be exists on the storage.', async () => {
+      const res = await request()
+        .delete('/api/sales/receipts/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'SALE.RECEIPT.NOT.FOUND',
+        code: 200,
+      });
+    });
+
+    it('Should delete the sale receipt with associated entries and journal transactions.', async () => {
+      const saleReceipt = await tenantFactory.create('sale_receipt');
+      const saleReceiptEntry = await tenantFactory.create(
+        'sale_receipt_entry',
+        {
+          sale_receipt_id: saleReceipt.id,
+        }
+      );
+      const res = await request()
+        .delete(`/api/sales/receipts/${saleReceipt.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      const storedSaleReceipt = await SaleReceipt.tenant()
+        .query()
+        .where('id', saleReceipt.id);
+      const storedSaleReceiptEntries = await SaleReceipt.tenant()
+        .query()
+        .where('id', saleReceiptEntry.id);
+
+      expect(res.status).equals(200);
+      expect(storedSaleReceipt.length).equals(0);
+      expect(storedSaleReceiptEntries.length).equals(0);
+    });
+  });
+
+  describe('POST: `/sales/receipts/:id`', () => {
+    it('Should the given sale receipt id be exists on the storage.', async () => {
+      const res = await request()
+        .post('/api/sales/receipts/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          deposit_account_id: 123,
+          customer_id: 123,
+          receipt_date: '2020-02-02',
+          reference_no: '123',
+          receipt_message: 'Receipt message...',
+          statement: 'Receipt statement...',
+          entries: [
+            {
+              item_id: 123,
+              quantity: 1,
+              rate: 2,
+            },
+          ],
+        });
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'SALE.RECEIPT.NOT.FOUND',
+        code: 200,
+      });
+    });
+
+    it('Should update the sale receipt details with associated entries.', async () => {
+      const saleReceipt = await tenantFactory.create('sale_receipt');
+      const depositAccount = await tenantFactory.create('account');
+      const customer = await tenantFactory.create('customer');
+      const item = await tenantFactory.create('item');
+
+      const res = await request()
+        .post(`/api/sales/receipts/${saleReceipt.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          deposit_account_id: depositAccount.id,
+          customer_id: customer.id,
+          receipt_date: '2020-02-02',
+          reference_no: '123',
+          receipt_message: 'Receipt message...',
+          statement: 'Receipt statement...',
+          entries: [
+            {
+              id: 100,
+              item_id: item.id,
+              quantity: 1,
+              rate: 2,
+            },
+          ],
+        });
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'ENTRIES.IDS.NOT.FOUND', code: 500,
+      });
+    });
+  });
+
+  describe('GET: `/sales/receipts`', () => {
+    it('Should response the custom view id not exists on the storage.', async () => {
+      const res = await request()
+        .get('/api/sales/receipts')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          
+        });
+
+      console.log(res.status, res.body);
+    });
+    
+    it('Should retrieve all sales receipts on the storage with pagination meta.', () => {
+
+    });
+  });
+});
diff --git a/packages/server/tests/routes/users.test.js b/packages/server/tests/routes/users.test.js
new file mode 100644
index 000000000..9c42d4c69
--- /dev/null
+++ b/packages/server/tests/routes/users.test.js
@@ -0,0 +1,203 @@
+import knex from '@/database/knex';
+import {
+  request,
+  expect,
+} from '~/testInit';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+
+describe('routes: `/routes`', () => {
+  describe('GET: `/users`', () => {
+    it('Should response unauthorized if the user was not authorized.', async () => {
+      const res = await request().get('/api/users');
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should retrieve the stored users with pagination meta.', async () => {
+      await tenantFactory.create('user');
+
+      const res = await request()
+        .get('/api/users')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.body.users.results.length).equals(2);
+      expect(res.body.users.total).equals(2);
+    });
+  });
+
+  describe('POST: `/users/:id`', () => {
+    it('Should create a new user if the user was not authorized.', async () => {
+      const user = await tenantFactory.create('user');
+      const res = await request()
+        .post(`/api/users/${user.id}`);
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should `first_name` be required.', async () => {
+      const user = await  tenantFactory.create('user');
+      const res = await request()
+        .post(`/api/users/${user.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+
+      const foundFirstNameParam = res.body.errors.find((error) => error.param === 'first_name');
+      expect(!!foundFirstNameParam).equals(true);
+    });
+
+    it('Should `last_name` be required.', async () => {
+      const user = await tenantFactory.create('user');
+      const res = await request()
+        .post(`/api/users/${user.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+
+      const foundFirstNameParam = res.body.errors.find((error) => error.param === 'last_name');
+      expect(!!foundFirstNameParam).equals(true);
+    });
+
+    it('Should `email` be required.', async () => {
+      const user = await tenantFactory.create('user');
+      const res = await request()
+        .post(`/api/users/${user.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+
+      const foundEmailParam = res.body.errors.find((error) => error.param === 'email');
+      expect(!!foundEmailParam).equals(true);
+    });
+
+    it('Should be `email` be valid format.', async () => {
+      const user = await tenantFactory.create('user');
+      const res = await request()
+        .post(`/api/users/${user.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          first_name: user.first_name,
+          last_name: user.last_name,
+          email: 'email',
+          phone_number: user.phone_number,
+          status: 1,
+        });
+
+      expect(res.status).equals(422);
+
+      const foundEmailParam = res.body.errors.find((error) => error.param === 'email');
+      expect(!!foundEmailParam).equals(true);
+    });
+
+    it('Should `phone_number` be valid format.', async () => {
+      const user = tenantFactory.create('user');
+      const res = await request()
+        .post(`/api/users/${user.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          first_name: user.first_name,
+          last_name: user.last_name,
+          email: user.email,
+          phone_number: 'phone_number',
+          status: 1,
+        });
+
+      expect(res.status).equals(422);
+
+      const phoneNumberParam = res.body.errors.find((error) => error.param === 'phone_number');
+      expect(!!phoneNumberParam).equals(true);
+    });
+  });
+
+  describe('GET: `/users/:id`', () => {
+    it('Should not success if the user was not authorized.', async () => {
+      const res = await request().get('/api/users/1');
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should response not found if the user was not exist.', async () => {
+      const res = await request()
+        .get('/api/users/10')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+    });
+
+    it('Should response success if the user was exist.', async () => {
+      const user = await tenantFactory.create('user');
+      const res = await request()
+        .get(`/api/users/${user.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(200);
+    });
+  });
+
+  describe('DELETE: `/users/:id`', () => {
+    it('Should not success if the user was not authorized.', async () => {
+      const res = await request().delete('/api/users/1');
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should response not found if the user was not exist.', async () => {
+      const res = await request()
+        .delete('/api/users/10')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'USER_NOT_FOUND', code: 100,
+      });
+    });
+
+    it('Should response success if the user was exist.', async () => {
+      const user = await tenantFactory.create('user');
+      const res = await request()
+        .delete(`/api/users/${user.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(200);      
+    });
+
+    it('Should delete the give user from the storage.', async () => {
+      const user = await tenantFactory.create('user');
+      await request()
+        .delete(`/api/users/${user.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      const storedUsers = await knex('users').where('id', user.id);
+      expect(storedUsers).to.have.lengthOf(0);
+    });
+  });
+});
diff --git a/packages/server/tests/routes/vendors.test.js b/packages/server/tests/routes/vendors.test.js
new file mode 100644
index 000000000..0fb1661c2
--- /dev/null
+++ b/packages/server/tests/routes/vendors.test.js
@@ -0,0 +1,193 @@
+import {
+  request,
+  expect,
+} from '~/testInit';
+import Currency from 'models/Currency';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+import Vendor from 'models/Vendor';
+
+describe('route: `/vendors`', () => {
+  describe('POST: `/vendors`', () => {
+    it('Should response unauthorized in case the user was not logged in.', async () => {
+      const res = await request()
+        .post('/api/vendors')
+        .send({});
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should `display_name` be required field.', async () => {
+      const res = await request()
+        .post('/api/vendors')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'display_name', location: 'body',
+      })
+    });
+
+    it('Should store the vendor data to the storage.', async () => {
+      const res = await request()
+        .post('/api/vendors')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          first_name: 'Ahmed',
+          last_name: 'Bouhuolia',
+
+          company_name: 'Bigcapital',
+
+          display_name: 'Ahmed Bouhuolia, Bigcapital',
+
+          email: 'a.bouhuolia@live.com',
+          work_phone: '0927918381',
+          personal_phone: '0925173379',
+
+          billing_address_city: 'Tripoli',
+          billing_address_country: 'Libya',
+          billing_address_email: 'a.bouhuolia@live.com',
+          billing_address_state: 'State Tripoli',
+          billing_address_zipcode: '21892',
+
+          shipping_address_city: 'Tripoli',
+          shipping_address_country: 'Libya',
+          shipping_address_email: 'a.bouhuolia@live.com',
+          shipping_address_state: 'State Tripoli',
+          shipping_address_zipcode: '21892',
+          
+          note: '__desc__',
+
+          active: true,
+        });
+
+      expect(res.status).equals(200);
+
+      const foundVendor = await Vendor.tenant().query().where('id', res.body.id);
+
+      expect(foundVendor[0].firstName).equals('Ahmed');
+      expect(foundVendor[0].lastName).equals('Bouhuolia');
+      expect(foundVendor[0].companyName).equals('Bigcapital');
+      expect(foundVendor[0].displayName).equals('Ahmed Bouhuolia, Bigcapital');
+
+      expect(foundVendor[0].email).equals('a.bouhuolia@live.com');
+      
+      expect(foundVendor[0].workPhone).equals('0927918381');
+      expect(foundVendor[0].personalPhone).equals('0925173379');
+
+      expect(foundVendor[0].billingAddressCity).equals('Tripoli');
+      expect(foundVendor[0].billingAddressCountry).equals('Libya');
+      expect(foundVendor[0].billingAddressEmail).equals('a.bouhuolia@live.com');
+      expect(foundVendor[0].billingAddressState).equals('State Tripoli');
+      expect(foundVendor[0].billingAddressZipcode).equals('21892');
+      
+      expect(foundVendor[0].shippingAddressCity).equals('Tripoli');
+      expect(foundVendor[0].shippingAddressCountry).equals('Libya');
+      expect(foundVendor[0].shippingAddressEmail).equals('a.bouhuolia@live.com');
+      expect(foundVendor[0].shippingAddressState).equals('State Tripoli');
+      expect(foundVendor[0].shippingAddressZipcode).equals('21892');
+    });
+  });
+
+  describe('GET: `/vendors/:id`', () => {
+    it('Should response not found in case the given vendor id was not exists on the storage.', async () => {
+      const res = await request()
+        .get('/api/vendors/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'VENDOR.NOT.FOUND', code: 200,
+      });
+    });
+  });
+
+  describe('GET: `vendors`', () => {
+    it('Should response vendors items', async () => {
+      await tenantFactory.create('vendor');
+      await tenantFactory.create('vendor');
+
+      const res = await request()
+        .get('/api/vendors')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.body.vendors.results.length).equals(2);
+    });
+  });
+
+  describe('DELETE: `/vendors/:id`', () => {
+    it('Should response not found in case the given vendor id was not exists on the storage.', async () => {
+      const res = await request()
+        .delete('/api/vendors/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'VENDOR.NOT.FOUND', code: 200,
+      });
+    });
+
+    it('Should delete the given vendor from the storage.', async () => {
+      const vendor = await tenantFactory.create('vendor');
+      const res = await request()
+        .delete(`/api/vendors/${vendor.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(200);
+
+      const foundVendor = await Vendor.tenant().query().where('id', vendor.id);
+      expect(foundVendor.length).equals(0);
+    })
+  });
+
+  describe('POST: `/vendors/:id`', () => {
+    it('Should response vendor not found', async () => {
+      const res = await request()
+        .post('/api/vendors/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          display_name: 'Ahmed Bouhuolia, Bigcapital',
+        });
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.deep.equals({
+        type: 'VENDOR.NOT.FOUND', code: 200,
+      });
+    });
+
+    it('Should update details of the given vendor.', async () => {
+      const vendor = await tenantFactory.create('vendor');
+      const res = await request()
+        .post(`/api/vendors/${vendor.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          display_name: 'Ahmed Bouhuolia, Bigcapital',
+        });
+
+      expect(res.status).equals(200);
+      const foundVendor = await Vendor.tenant().query().where('id', res.body.id);
+
+      expect(foundVendor.length).equals(1);
+      expect(foundVendor[0].displayName).equals('Ahmed Bouhuolia, Bigcapital');
+    })
+  });
+});
diff --git a/packages/server/tests/routes/views.test.js b/packages/server/tests/routes/views.test.js
new file mode 100644
index 000000000..0dedf29f6
--- /dev/null
+++ b/packages/server/tests/routes/views.test.js
@@ -0,0 +1,936 @@
+import {
+  request,
+  expect,
+} from '~/testInit';
+import View from 'models/View';
+import ViewRole from 'models/ViewRole';
+import 'models/ResourceField';
+import ViewColumn from '../../src/models/ViewColumn';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+
+
+describe('routes: `/views`', () => {
+  describe('GET: `/views`', () => {
+    it('Should response unauthorized in case the user was not authorized.', async () => {
+      const res = await request().get('/api/views');
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should retrieve all views of the given resource name.', async () => {
+      const resource = await tenantFactory.create('resource', { name: 'resource_name' });
+      const resourceFields = await tenantFactory.create('view', {
+        name: 'Resource View',
+        resource_id: resource.id,
+        roles_logic_expression: '',
+      });
+
+      const res = await request()
+        .get('/api/views')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .query({ resource_name: 'resource_name' })
+        .send();
+
+      expect(res.status).equals(200);
+      expect(res.body.views.length).equals(1);
+    });
+  });
+
+  describe('GET `/views/:id`', () => {
+    it('Should response unauthorized in case the user was not authorized.', async () => {
+      const resource = await tenantFactory.create('resource', { name: 'resource_name' });
+      const resourceView = await tenantFactory.create('view', {
+        name: 'Resource View',
+        resource_id: resource.id,
+        roles_logic_expression: '',
+      });
+
+      const res = await request()
+        .get(`/api/views/${resourceView.id}`)
+        .query({ resource_name: 'resource_name' })
+        .send();
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should response not found in case the given view was not found.', async () => {
+      const resource = await tenantFactory.create('resource', { name: 'resource_name' });
+      const resourceView = await tenantFactory.create('view', {
+        name: 'Resource View',
+        resource_id: resource.id,
+        roles_logic_expression: '',
+      });
+
+      const res = await request()
+        .get('/api/views/123')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors[0]).deep.equals({
+        type: 'VIEW_NOT_FOUND', code: 100,
+      });
+    });
+
+    it('Should retrieve details of the given view with associated graphs.', async () => {
+      const resource = await tenantFactory.create('resource', { name: 'resource_name' });
+      const resourceView = await tenantFactory.create('view', {
+        name: 'Resource View',
+        resource_id: resource.id,
+        roles_logic_expression: '1 AND 2',
+      });
+      const resourceField = await tenantFactory.create('resource_field', {
+        label_name: 'Expense Account',
+        key: 'expense_account',
+        data_type: 'integer',
+        resource_id: resource.id,
+        active: true,
+        predefined: true,
+        builtin: true,
+      });
+      const viewRole = await tenantFactory.create('view_role', {
+        view_id: resourceView.id,
+        index: 1,
+        field_id: resourceField.id,
+        value: '12',
+        comparator: 'equals',
+      });
+
+      const res = await request()
+        .get(`/api/views/${resourceView.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(200);
+      expect(res.body.view.name).equals(resourceView.name);
+      expect(res.body.view.resource_id).equals(resourceView.resourceId);
+      expect(res.body.view.roles_logic_expression).equals(resourceView.rolesLogicExpression);
+
+      expect(res.body.view.roles.length).equals(1);
+      expect(res.body.view.roles[0].view_id).equals(viewRole.viewId);
+    });
+  });
+
+  describe('POST: `/views`', () => {
+    it('Should response unauthorzied in case the user was not authorized.', async () => {
+      const res = await request().post('/api/views');
+
+      expect(res.status).equals(401);
+      expect(res.body.message).equals('Unauthorized');
+    });
+
+    it('Should `name` be required.', async () => {
+      await tenantFactory.create('resource');
+      const res = await request()
+        .post('/api/views')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId);
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'name', location: 'body',
+      });
+    });
+
+    it('Should `resource_name` be required.', async () => {
+      await tenantFactory.create('resource');
+      const res = await request()
+        .post('/api/views')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId);
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'resource_name', location: 'body',
+      });
+    });
+
+    it('Should `columns` be minimum limited', async () => {
+      await tenantFactory.create('resource');
+      const res = await request()
+        .post('/api/views', {
+          label: 'View Label',
+          columns: [],
+        })
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId);
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'columns', location: 'body',
+      });
+    });
+
+    it('Should `columns` be array.', async () => {
+      await tenantFactory.create('resource');
+      const res = await request()
+        .post('/api/views', {
+          label: 'View Label',
+          columns: 'not_array',
+        })
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId);
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'columns', location: 'body',
+      });
+    });
+
+    it('Should `roles.*.field_key` be required.', async () => {
+      const resource = await tenantFactory.create('resource');
+      const res = await request()
+        .post('/api/views')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          resource_name: resource.name,
+          label: 'View Label',
+          roles: [{}],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'roles[0].field_key', location: 'body',
+      });
+    });
+
+    it('Should `roles.*.comparator` be valid.', async () => {
+      const resource = await tenantFactory.create('resource');
+      const res = await request()
+        .post('/api/views')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          resource_name: resource.name,
+          label: 'View Label',
+          roles: [{}],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+
+      const paramsErrors = res.body.errors.map((error) => error.param);
+      expect(paramsErrors).to.include('roles[0].comparator');
+    });
+
+    it('Should `roles.*.index` be number as integer.', async () => {
+      const resource = await tenantFactory.create('resource');
+      const res = await request()
+        .post('/api/views')
+        .send({
+          resource_name: resource.name,
+          label: 'View Label',
+          roles: [
+            { index: 'not_numeric' },
+          ],
+        })
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId);
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        value: 'not_numeric',
+        msg: 'Invalid value',
+        param: 'roles[0].index',
+        location: 'body',
+      });
+    });
+
+    it('Should response not found in case resource was not exist.', async () => {
+      const res = await request()
+        .post('/api/views')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          resource_name: 'not_found',
+          name: 'View Label',
+          columns: [
+            { key: 'amount', index: 1 },
+            { key: 'thumbnail', index: 1 },
+            { key: 'status', index: 1 },
+          ],
+          roles: [{
+            index: 1,
+            field_key: 'amount',
+            comparator: 'equals',
+            value: '100',
+          }],
+          logic_expression: '1',
+        });
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'RESOURCE_NOT_FOUND', code: 100,
+      });
+    });
+
+    it('Should response invalid logic expression.', async () =>{
+      const resource = await tenantFactory.create('resource');
+      await tenantFactory.create('resource_field', {
+        resource_id: resource.id,
+        label_name: 'Amount',
+        key: 'amount',
+      });
+      const res = await request()
+        .post('/api/views')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          resource_name: resource.name,
+          logic_expression: '100 && 100',
+          name: 'View Label',
+          columns: [
+            { key: 'amount', index: 1 },
+          ],
+          roles: [{
+            index: 1,
+            field_key: 'amount',
+            comparator: 'equals',
+            value: '100',
+          }],
+        });
+
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'VIEW.ROLES.LOGIC.EXPRESSION.INVALID', code: 400,
+      });
+    });
+
+    it('Should response the roles fields not exist in case role field was not exist.', async () => {
+      const resource = await tenantFactory.create('resource');
+      await tenantFactory.create('resource_field', { resource_id: resource.id, label_name: 'Amount' });
+
+      const res = await request()
+        .post('/api/views')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          resource_name: resource.name,
+          name: 'View Label',
+          logic_expression: '1',
+          columns: [
+            { key: 'amount', index: 1 },
+            { key: 'thumbnail', index: 1 },
+            { key: 'status', index: 1 },
+          ],
+          roles: [{
+            index: 1,
+            field_key: 'price',
+            comparator: 'equals',
+            value: '100',
+          }],
+        });
+
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'RESOURCE_FIELDS_NOT_EXIST', code: 100, fields: ['price'],
+      });
+    });
+
+    it('Should response the columns that not exists in case column was not exist.', async () => {
+      const resource = await tenantFactory.create('resource');
+      const resourceField = await tenantFactory.create('resource_field', {
+        resource_id: resource.id,
+        label_name: 'Amount',
+        key: 'amount',
+      });
+      const res = await request()
+        .post('/api/views')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          resource_name: resource.name,
+          name: 'View Label',
+          logic_expression: '1',
+          columns: [
+            { key: 'amount', index: 1 },
+            { key: 'thumbnail', index: 2 },
+            { key: 'status', index: 3 },
+          ],
+          roles: [{
+            index: 1,
+            field_key: 'price',
+            comparator: 'equals',
+            value: '100',
+          }],
+        });
+
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'COLUMNS_NOT_EXIST', code: 200, columns: ['thumbnail', 'status'],
+      });
+    });
+
+    it('Should save the given details of the view.', async () => {
+      const resource = await tenantFactory.create('resource');
+      await tenantFactory.create('resource_field', {
+        resource_id: resource.id,
+        label_name: 'Amount',
+        key: 'amount',
+      });
+      const res = await request()
+        .post('/api/views')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          resource_name: resource.name,
+          name: 'View Label',
+          logic_expression: '1',
+          columns: [
+            { key: 'amount', index: 1 },
+          ],
+          roles: [{
+            index: 1,
+            field_key: 'amount',
+            comparator: 'equals',
+            value: '100',
+          }],
+        });
+
+      const storedView = await View.tenant().query().where('name', 'View Label').first();
+
+      expect(storedView.name).equals('View Label');
+      expect(storedView.predefined).equals(0);
+      expect(storedView.resourceId).equals(resource.id);
+    });
+
+    it('Should save the given details of view fields that associated to the given view id.', async () => {
+      const resource = await tenantFactory.create('resource');
+      const resourceField = await tenantFactory.create('resource_field', {
+        resource_id: resource.id,
+        label_name: 'Amount',
+        key: 'amount',
+      });
+
+      const res = await request()
+        .post('/api/views')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          resource_name: resource.name,
+          name: 'View Label',
+          columns: [{ key: 'amount', index: 1 }],
+          logic_expression: '1',
+          roles: [{
+            index: 1,
+            field_key: 'amount',
+            comparator: 'equals',
+            value: '100',
+          }],
+        });
+
+      const viewRoles = await ViewRole.tenant().query().where('view_id', res.body.id);
+
+      expect(viewRoles.length).equals(1);
+      expect(viewRoles[0].index).equals(1);
+      expect(viewRoles[0].fieldId).equals(resourceField.id);
+      expect(viewRoles[0].value).equals('100');
+      expect(viewRoles[0].comparator).equals('equals');
+    });
+
+    it('Should save columns that associated to the given view.', async () => {
+      const resource = await tenantFactory.create('resource');
+      const resourceField = await tenantFactory.create('resource_field', {
+        resource_id: resource.id,
+        label_name: 'Amount',
+        key: 'amount',
+      });
+
+      const res = await request()
+        .post('/api/views')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          resource_name: resource.name,
+          name: 'View Label',
+          logic_expression: '1',
+          columns: [
+            { key: 'amount', index: 1 },
+          ],
+          roles: [{
+            index: 1,
+            field_key: 'amount',
+            comparator: 'equals',
+            value: '100',
+          }],
+        });
+
+      const viewColumns = await ViewColumn.tenant().query().where('view_id', res.body.id);
+      expect(viewColumns.length).equals(1);
+    });
+
+   
+  });
+
+  describe('POST: `/views/:view_id`', () => {
+    it('Should `name` be required.', async () => {
+      const view = await tenantFactory.create('view');
+      const res = await request()
+        .post(`/api/views/${view.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'name', location: 'body',
+      });
+    });
+
+    it('Should columns be minimum limited', async () => {
+      const view = await tenantFactory.create('view');
+      const res = await request()
+        .post(`/api/views/${view.id}`, {
+          label: 'View Label',
+          columns: [],
+        })
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'columns', location: 'body',
+      });
+    });
+
+    it('Should columns be array.', async () => {
+      const view = await tenantFactory.create('view');
+      const res = await request()
+        .post(`/api/views/${view.id}`, {
+          label: 'View Label',
+          columns: 'not_array',
+        })
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          columns: 'columns'
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'columns', location: 'body', value: 'columns',
+      });
+    });
+
+    it('Should `roles.*.field_key` be required.', async () => {
+      const view = await tenantFactory.create('view');
+      const res = await request()
+        .post(`/api/views/${view.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          label: 'View Label',
+          roles: [{}],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'roles[0].field_key', location: 'body',
+      });
+    });
+
+    it('Should `roles.*.comparator` be required.', async () => {
+      const view = await tenantFactory.create('view');
+      const res = await request()
+        .post(`/api/views/${view.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          label: 'View Label',
+          roles: [{}],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value', param: 'roles[0].comparator', location: 'body',
+      });
+    });
+
+    it('Should `roles.*.index` be number as integer.', async () => {
+      const view = await tenantFactory.create('view');
+      const res = await request()
+        .post(`/api/views/${view.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          label: 'View Label',
+          roles: [{ index: 'not_numeric' }],
+        });
+
+      expect(res.status).equals(422);
+      expect(res.body.code).equals('validation_error');
+      expect(res.body.errors).include.something.deep.equals({
+        msg: 'Invalid value',
+        param: 'roles[0].index',
+        location: 'body',
+        value: 'not_numeric',
+      });
+    });
+
+    it('Should response the roles fields not exist in case role field was not exist.', async () => {
+      const view = await tenantFactory.create('view');
+      await tenantFactory.create('resource_field', {
+        resource_id: view.resource_id,
+        label_name: 'Amount',
+      });
+      const res = await request()
+        .post(`/api/views/${view.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'View Label',
+          logic_expression: '1',
+          columns: [{
+            key: 'amount',
+            index: 1,
+          }, {
+            key: 'thumbnail',
+            index: 2,
+          }, {
+            key: 'status',
+            index: 3,
+          }],
+          roles: [{
+            index: 1,
+            field_key: 'price',
+            comparator: 'equals',
+            value: '100',
+          }],
+        });
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'RESOURCE_FIELDS_NOT_EXIST', code: 100, fields: ['price'],
+      });
+    });
+
+    it('Should response the resource columns not exists in case the column keys was not exist.', async () => {
+      const view = await tenantFactory.create('view');
+      await tenantFactory.create('resource_field', {
+        resource_id: view.resource_id,
+        label_name: 'Amount',
+      });
+      const res = await request()
+        .post(`/api/views/${view.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'View Label',
+          logic_expression: '1',
+          columns: [{
+            key: 'amount',
+            index: 1,
+          }, {
+            key: 'thumbnail',
+            index: 2,
+          }, {
+            key: 'status',
+            index: 3,
+          }],
+          roles: [{
+            index: 1,
+            field_key: 'price',
+            comparator: 'equals',
+            value: '100',
+          }],
+        });
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'RESOURCE_COLUMNS_NOT_EXIST',
+        code: 200,
+        columns: ['amount', 'thumbnail', 'status'],
+      });
+    });
+
+    it('Should validate the logic expressions with the given conditions.', () => {
+
+    });
+
+    it('Should delete the view roles that not presented the post data.', async () => {
+      const resource = await tenantFactory.create('resource');
+      const resourceField = await tenantFactory.create('resource_field', {
+        resource_id: resource.id,
+        label_name: 'Amount',
+        key: 'amount',
+      });
+
+      const view = await tenantFactory.create('view', { resource_id: resource.id });
+      const viewRole = await tenantFactory.create('view_role', {
+        view_id: view.id,
+        field_id: resourceField.id,
+      });
+      const res = await request()
+        .post(`/api/views/${view.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'View Label',
+          logic_expression: '1',
+          columns: [{
+            key: resourceField.key,
+            index: 1,
+          }],
+          roles: [{
+            index: 1,
+            field_key: resourceField.key,
+            comparator: 'equals',
+            value: '100',
+          }],
+        });
+
+      const foundViewRole = await ViewRole.tenant().query().where('id', viewRole.id);
+      expect(foundViewRole.length).equals(0);
+    });
+
+    it('Should update the view roles that presented in the given data.', async () => {
+      const resource = await tenantFactory.create('resource');
+      const resourceField = await tenantFactory.create('resource_field', {
+        resource_id: resource.id,
+        label_name: 'Amount',
+        key: 'amount',
+      });
+
+      const view = await tenantFactory.create('view', { resource_id: resource.id });
+      const viewRole = await tenantFactory.create('view_role', {
+        view_id: view.id,
+        field_id: resourceField.id,
+      });
+      const res = await request()
+        .post(`/api/views/${view.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'View Label',
+          logic_expression: '1',
+          columns: [{
+            key: resourceField.key,
+            index: 1,
+          }],
+          roles: [{
+            id: viewRole.id,
+            index: 1,
+            field_key: resourceField.key,
+            comparator: 'equals',
+            value: '100',
+          }],
+        });
+
+      const foundViewRole = await ViewRole.tenant().query().where('id', viewRole.id);
+
+      expect(foundViewRole.length).equals(1);
+      expect(foundViewRole[0].id).equals(viewRole.id);
+      expect(foundViewRole[0].index).equals(1);
+      expect(foundViewRole[0].value).equals('100');
+      expect(foundViewRole[0].comparator).equals('equals');
+    });
+
+    it('Should response not found roles ids in case not exists in the storage.', async () => {
+      const resource = await tenantFactory.create('resource');
+      const resourceField = await tenantFactory.create('resource_field', {
+        resource_id: resource.id,
+        label_name: 'Amount',
+        key: 'amount',
+      });
+      const view = await tenantFactory.create('view', { resource_id: resource.id });
+
+      const res = await request()
+        .post(`/api/views/${view.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'View Label',
+          logic_expression: '1',
+          columns: [{
+            key: resourceField.key,
+            index: 1,
+          }],
+          roles: [{
+            id: 1,
+            index: 1,
+            field_key: resourceField.key,
+            comparator: 'equals',
+            value: '100',
+          }],
+        });
+
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'VIEW.ROLES.IDS.NOT.FOUND', code: 500, ids: [1],
+      });
+    });
+
+    it('Should delete columns from storage in case view columns ids not presented.', async () => {
+      const resource = await tenantFactory.create('resource');
+      const resourceField = await tenantFactory.create('resource_field', {
+        resource_id: resource.id,
+        label_name: 'Amount',
+        key: 'amount',
+      });
+      const view = await tenantFactory.create('view', { resource_id: resource.id });
+      const viewColumn = await tenantFactory.create('view_column', { view_id: view.id });
+
+      const res = await request()
+        .post(`/api/views/${view.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'View Label',
+          logic_expression: '1',
+          columns: [{
+            key: resourceField.key,
+            index: 1,
+          }],
+          roles: [{
+            index: 1,
+            field_key: resourceField.key,
+            comparator: 'equals',
+            value: '100',
+          }],
+        });
+      const foundViewColumns = await ViewColumn.tenant().query().where('id', viewColumn.id);
+      expect(foundViewColumns.length).equals(0);
+    });
+
+    it('Should insert columns to the storage if where new columns', async () => {
+      const resource = await tenantFactory.create('resource');
+      const resourceField = await tenantFactory.create('resource_field', {
+        resource_id: resource.id,
+        label_name: 'Amount',
+        key: 'amount',
+      });
+      const view = await tenantFactory.create('view', { resource_id: resource.id });
+
+      const res = await request()
+        .post(`/api/views/${view.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'View Label',
+          logic_expression: '1',
+          columns: [{
+            key: resourceField.key,
+            index: 1,
+          }],
+          roles: [{
+            index: 1,
+            field_key: resourceField.key,
+            comparator: 'equals',
+            value: '100',
+          }],
+        });
+
+      const foundViewColumns = await ViewColumn.tenant().query().where('view_id', view.id);
+
+      expect(foundViewColumns.length).equals(1);
+      expect(foundViewColumns[0].viewId).equals(view.id);
+      expect(foundViewColumns[0].index).equals(1);
+      expect(foundViewColumns[0].fieldId).equals(resourceField.id);
+    });
+
+
+    it('Should update columns on the storage.', async () => {
+      const resource = await tenantFactory.create('resource');
+      const resourceField = await tenantFactory.create('resource_field', {
+        resource_id: resource.id,
+        label_name: 'Amount',
+        key: 'amount',
+      });
+      const view = await tenantFactory.create('view', { resource_id: resource.id });
+      const viewColumn = await tenantFactory.create('view_column', { view_id: view.id });
+
+      const res = await request()
+        .post(`/api/views/${view.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send({
+          name: 'View Label',
+          logic_expression: '1',
+          columns: [{ 
+            id: viewColumn.id,
+            key: resourceField.key,
+            index: 10,
+          }],
+          roles: [{
+            index: 1,
+            field_key: resourceField.key,
+            comparator: 'equals',
+            value: '100',
+          }],
+        });
+
+      console.log(res.body)
+
+      const foundViewColumns = await ViewColumn.tenant().query().where('id', viewColumn.id);
+
+      expect(foundViewColumns.length).equals(1);
+      expect(foundViewColumns[0].id).equals(viewColumn.id);
+      expect(foundViewColumns[0].viewId).equals(view.id);
+      expect(foundViewColumns[0].index).equals(10);
+      // expect(foundViewColumns[0].fieldId).equals();
+    })
+  });
+
+  describe('DELETE: `/views/:resource_id`', () => {
+    it('Should not delete predefined view.', async () => {
+      const view = await tenantFactory.create('view', { predefined: true });
+      const res = await request()
+        .delete(`/api/views/${view.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(400);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'PREDEFINED_VIEW', code: 200,
+      });
+    });
+
+    it('Should response not found in case view was not exist.', async () => {
+      const res = await request()
+        .delete('/api/views/100')
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.status).equals(404);
+      expect(res.body.errors).include.something.that.deep.equals({
+        type: 'VIEW_NOT_FOUND', code: 100,
+      });
+    });
+
+    it('Should delete the given view and associated view columns and roles.', async () => {
+      const view = await tenantFactory.create('view', { predefined: false });
+      await tenantFactory.create('view_role', { view_id: view.id });
+      await tenantFactory.create('view_column', { view_id: view.id });
+
+      const res = await request()
+        .delete(`/api/views/${view.id}`)
+        .set('x-access-token', loginRes.body.token)
+        .set('organization-id', tenantWebsite.organizationId)
+        .send();
+
+      expect(res.body.id).equals(view.id);
+
+      const foundViews = await View.tenant().query().where('id', view.id);
+      const foundViewRoles = await ViewRole.tenant().query().where('view_id', view.id);
+
+      expect(foundViews).to.have.lengthOf(0);
+      expect(foundViewRoles).to.have.lengthOf(0);
+    });
+  });
+});
diff --git a/packages/server/tests/services/JournalPoster.test.js b/packages/server/tests/services/JournalPoster.test.js
new file mode 100644
index 000000000..171dc8cf7
--- /dev/null
+++ b/packages/server/tests/services/JournalPoster.test.js
@@ -0,0 +1,406 @@
+import { expect } from '~/testInit';
+import JournalPoster from '@/services/Accounting/JournalPoster';
+import JournalEntry from '@/services/Accounting/JournalEntry';
+import AccountBalance from 'models/AccountBalance';
+import AccountTransaction from 'models/AccountTransaction';
+import Account from 'models/Account';
+import {
+  tenantWebsite,
+  tenantFactory,
+  loginRes
+} from '~/dbInit';
+import { omit } from 'lodash';
+import DependencyGraph from '@/lib/DependencyGraph';
+
+let accountsDepGraph;
+
+describe('JournalPoster', () => {
+  beforeEach(async () => {
+    accountsDepGraph = await Account.tenant().depGraph().query().remember();
+  });
+  describe('credit()', () => {
+    it('Should write credit entry to journal entries stack.', () => {
+      const journalEntries = new JournalPoster(accountsDepGraph);
+      const journalEntry = new JournalEntry({
+        referenceId: 1,
+        referenceType: 'Expense',
+        credit: 100,
+        account: 1,
+      });
+      journalEntries.credit(journalEntry);
+      expect(journalEntries.entries.length).equals(1);
+    });
+  });
+
+  describe('debit()', () => {
+    it('Should write debit entry to journal entries stack.', () => {
+      const journalEntries = new JournalPoster(accountsDepGraph);
+      const journalEntry = new JournalEntry({
+        referenceId: 1,
+        referenceType: 'Expense',
+        debit: 100,
+        account: 1,
+      });
+
+      journalEntries.debit(journalEntry);
+      expect(journalEntries.entries.length).equals(1);
+    });
+  });
+
+  describe('setBalanceChange()', () => {
+    it('Should increment balance amount after credit entry with credit normal account.', () => {
+      const journalEntries = new JournalPoster(accountsDepGraph);
+      const journalEntry = new JournalEntry({
+        referenceId: 1,
+        referenceType: 'Expense',
+        credit: 100,
+        debit: 0,
+        account: 1,
+        accountNormal: 'debit',
+      });
+      journalEntries.credit(journalEntry);
+      expect(journalEntries.balancesChange).to.have.property(1, -100);
+    });
+
+    it('Should decrement balance amount after debit entry wiht debit normal account.', () => {
+      const journalEntries = new JournalPoster(accountsDepGraph);
+      const journalEntry = new JournalEntry({
+        referenceId: 1,
+        referenceType: 'Expense',
+        debit: 100,
+        account: 1,
+        accountNormal: 'debit',
+      });
+      journalEntries.debit(journalEntry);
+      expect(journalEntries.balancesChange).to.have.property(1, 100);
+    });
+  });
+
+  describe('setContactAccountBalance', () => {
+    it('Should increment balance amount after credit/debit entry.', () => {
+
+    });
+
+    it('Should decrement balance amount after credit/debit customer/vendor entry.', () => {
+      
+    });
+  });
+
+  describe('saveEntries()', () => {
+    it('Should save all stacked entries to the storage.', async () => {
+      const journalEntries = new JournalPoster(accountsDepGraph);
+      const journalEntry = new JournalEntry({
+        referenceId: 1,
+        referenceType: 'Expense',
+        debit: 100,
+        account: 1,
+        accountNormal: 'debit',
+      });
+
+      journalEntries.debit(journalEntry);
+      await journalEntries.saveEntries();
+
+      const storedJournalEntries = await AccountTransaction.tenant().query();
+
+      expect(storedJournalEntries.length).equals(1);
+      expect(storedJournalEntries[0]).to.deep.include({
+        referenceType: 'Expense',
+        referenceId: 1,
+        debit: 100,
+        credit: 0,
+        accountId: 1,
+      });
+    });
+  });
+
+  describe('saveBalance()', () => {
+    it('Should save account balance increment.', async () => {
+      const account = await tenantFactory.create('account');
+      const depGraph = await Account.tenant().depGraph().query();
+
+      const journalEntries = new JournalPoster(depGraph);
+      const journalEntry = new JournalEntry({
+        referenceId: 1,
+        referenceType: 'Expense',
+        debit: 100,
+        account: account.id,
+        accountNormal: 'debit',
+      });
+      journalEntries.debit(journalEntry);
+
+      await journalEntries.saveBalance();
+
+      const storedAccountBalance = await AccountBalance.tenant().query();
+
+      expect(storedAccountBalance.length).equals(1);
+      expect(storedAccountBalance[0].amount).equals(100);
+    });
+
+    it('Should save account balance decrement.', async () => {
+      const account = await tenantFactory.create('account');
+      const depGraph = await Account.tenant().depGraph().query();
+
+      const journalEntries = new JournalPoster(depGraph);
+      const journalEntry = new JournalEntry({
+        referenceId: 1,
+        referenceType: 'Expense',
+        credit: 100,
+        account: account.id,
+        accountNormal: 'debit',
+      });
+      journalEntries.credit(journalEntry);
+
+      await journalEntries.saveBalance();
+
+      const storedAccountBalance = await AccountBalance.tenant().query();
+
+      expect(storedAccountBalance.length).equals(1);
+      expect(storedAccountBalance[0].amount).equals(-100);
+    });
+  });
+
+  describe('getClosingBalance', () => {
+    it('Should retrieve closing balance the given account id.', () => {
+      const journalEntries = new JournalPoster(accountsDepGraph);
+      const journalEntry = new JournalEntry({
+        referenceId: 1,
+        referenceType: 'Expense',
+        debit: 100,
+        account: 1,
+        accountNormal: 'debit',
+        date: '2020-1-10',
+      });
+      const journalEntry2 = new JournalEntry({
+        referenceId: 1,
+        referenceType: 'Income',
+        credit: 100,
+        account: 2,
+        accountNormal: 'credit',
+        date: '2020-1-12',
+      });
+      journalEntries.credit(journalEntry);
+      journalEntries.credit(journalEntry2);
+
+      const closingBalance = journalEntries.getClosingBalance(1, '2020-1-30');
+      expect(closingBalance).equals(100);
+    });
+
+    it('Should retrieve closing balance the given closing date period.', () => {
+      const journalEntries = new JournalPoster(accountsDepGraph);
+      const journalEntry = new JournalEntry({
+        referenceId: 1,
+        referenceType: 'Expense',
+        debit: 100,
+        account: 1,
+        accountNormal: 'debit',
+        date: '2020-1-10',
+      });
+      const journalEntry2 = new JournalEntry({
+        referenceId: 1,
+        referenceType: 'Income',
+        credit: 100,
+        account: 2,
+        accountNormal: 'credit',
+        date: '2020-1-12',
+      });
+      journalEntries.credit(journalEntry);
+      journalEntries.credit(journalEntry2);
+
+      const closingBalance = journalEntries.getClosingBalance(1, '2020-1-2');
+      expect(closingBalance).equals(0);
+    });
+  });
+
+  describe('getTrialBalance(account, closeDate, dateType)', () => {
+    it('Should retrieve the trial balance of the given account id.', () => {
+      const journalEntries = new JournalPoster(accountsDepGraph);
+      const journalEntry = new JournalEntry({
+        referenceId: 1,
+        referenceType: 'Expense',
+        debit: 200,
+        account: 1,
+        accountNormal: 'debit',
+        date: '2020-1-10',
+      });
+      const journalEntry2 = new JournalEntry({
+        referenceId: 1,
+        referenceType: 'Income',
+        credit: 100,
+        account: 1,
+        accountNormal: 'credit',
+        date: '2020-1-12',
+      });
+
+      journalEntries.debit(journalEntry);
+      journalEntries.credit(journalEntry2);
+
+      const trialBalance = journalEntries.getTrialBalance(1);
+
+      expect(trialBalance.credit).equals(100);
+      expect(trialBalance.debit).equals(200);
+    });
+  });
+
+  describe('groupingEntriesByDate(accountId, dateGroupType)', () => {
+
+  });
+
+  describe('removeEntries', () => {
+    it('Should remove all entries in the collection.', () => {
+      const journalPoster = new JournalPoster(accountsDepGraph);
+      const journalEntry1 = new JournalEntry({
+        id: 1,
+        credit: 1000,
+        account: 1,
+        accountNormal: 'credit',
+      });
+      const journalEntry2 = new JournalEntry({
+        id: 2,
+        debit: 1000,
+        account: 2,
+        accountNormal: 'debit',
+      });
+      journalPoster.credit(journalEntry1);
+      journalPoster.debit(journalEntry2);
+
+      journalPoster.removeEntries();
+
+      expect(journalPoster.entries.length).equals(0);
+    });
+
+    it('Should remove the given entries ids from the collection.', () => {
+      const journalPoster = new JournalPoster(accountsDepGraph);
+      const journalEntry1 = new JournalEntry({
+        id: 1,
+        credit: 1000,
+        account: 1,
+        accountNormal: 'credit',
+      });
+      const journalEntry2 = new JournalEntry({
+        id: 2,
+        debit: 1000,
+        account: 2,
+        accountNormal: 'debit',
+      });
+      journalPoster.credit(journalEntry1);
+      journalPoster.debit(journalEntry2);
+
+      journalPoster.removeEntries([1]);
+      expect(journalPoster.entries.length).equals(1);
+    });
+
+    it('Should the removed entries ids be stacked to deleted entries ids.', () => {
+      const journalPoster = new JournalPoster(accountsDepGraph);
+      const journalEntry1 = new JournalEntry({
+        id: 1,
+        credit: 1000,
+        account: 1,
+        accountNormal: 'credit',
+      });
+      const journalEntry2 = new JournalEntry({
+        id: 2,
+        debit: 1000,
+        account: 2,
+        accountNormal: 'debit',
+      });
+      journalPoster.credit(journalEntry1);
+      journalPoster.debit(journalEntry2);
+
+      journalPoster.removeEntries();
+
+      expect(journalPoster.deletedEntriesIds.length).equals(2);
+      expect(journalPoster.deletedEntriesIds[0]).equals(1);
+      expect(journalPoster.deletedEntriesIds[1]).equals(2);
+    });
+
+    it('Should revert the account balance after remove the entries.', () => {
+      const journalPoster = new JournalPoster(accountsDepGraph);
+      const journalEntry1 = new JournalEntry({
+        id: 1,
+        credit: 1000,
+        account: 1,
+        accountNormal: 'credit',
+      });
+      const journalEntry2 = new JournalEntry({
+        id: 2,
+        debit: 1000,
+        account: 2,
+        accountNormal: 'debit',
+      });
+      journalPoster.credit(journalEntry1);
+      journalPoster.debit(journalEntry2);
+
+      journalPoster.removeEntries([1]);
+
+      expect(journalPoster.balancesChange['1']).equals(0);
+      expect(journalPoster.balancesChange['2']).equals(1000);
+    })
+  });
+
+  describe('deleteEntries', () => {
+    it('Should delete all entries from the storage based on the stacked deleted entries ids.', () => {
+
+    });
+  });
+
+  describe('effectParentAccountsBalance()', () => {
+    it('Should all parent accounts increment after one of child accounts balance increment.', async () => {
+      const debitType = await tenantFactory.create('account_type', { normal: 'debit', balance_sheet: true });
+      const mixin = { account_type_id: debitType.id };
+
+      const accountA = await tenantFactory.create('account', { ...mixin });
+      const accountB = await tenantFactory.create('account', { ...mixin });
+
+      const accountAC = await tenantFactory.create('account', { parent_account_id: accountA.id, ...mixin });
+      const accountBD = await tenantFactory.create('account', { ...mixin });
+
+      const depGraph = await Account.tenant().depGraph().query();
+      const journalPoster = new JournalPoster(depGraph);
+      const journalEntryA = new JournalEntry({
+        id: 1,
+        debit: 1000,
+        account: accountAC.id,
+        accountNormal: 'debit',
+      });
+      const journalEntryB = new JournalEntry({
+        id: 1,
+        debit: 1000,
+        account: accountBD.id,
+        accountNormal: 'debit',
+      });
+
+      journalPoster.debit(journalEntryA);
+      journalPoster.debit(journalEntryB);
+      
+      await journalPoster.saveBalance();
+
+      const accountBalances = await AccountBalance.tenant().query();
+      const simplifiedArray = accountBalances.map(x => ({ ...omit(x, ['id']) }));
+
+      expect(simplifiedArray.length).equals(3);
+      expect(simplifiedArray).to.include.something.deep.equals({
+        accountId: accountA.id,
+        amount: 1000,
+        currencyCode: 'USD'
+      });
+      expect(simplifiedArray).to.include.something.deep.equals({
+        accountId: accountAC.id,
+        amount: 1000,
+        currencyCode: 'USD'
+      });      
+      expect(simplifiedArray).to.include.something.deep.equals({
+        accountId: accountBD.id,
+        amount: 1000,
+        currencyCode: 'USD'
+      });
+    });
+  });
+
+  describe('reverseEntries()', () => {
+
+  });
+
+  describe('loadFromCollection', () => {
+
+  });
+});
diff --git a/packages/server/tests/testInit.js b/packages/server/tests/testInit.js
new file mode 100644
index 000000000..23750a6eb
--- /dev/null
+++ b/packages/server/tests/testInit.js
@@ -0,0 +1,88 @@
+import chai from 'chai';
+import chaiHttp from 'chai-http';
+import chaiThings from 'chai-things';
+import systemDb from '@/database/knex';
+import app from 'app';
+import createTenantFactory from '@/database/factories';
+import TenantsManager from '@/system/TenantsManager';
+import faker from 'faker';
+import { hashPassword } from 'utils';
+import TenantModel from 'models/TenantModel';
+import createSystemFactory from '@/database/factories/system';
+
+
+const { expect } = chai;
+const request = () => chai.request(app);
+
+beforeEach(async () => {
+  // Rollback/migrate the system database.
+  await systemDb.migrate.rollback();
+  await systemDb.migrate.latest();
+});
+
+afterEach(async () => {
+});
+
+chai.use(chaiHttp);
+chai.use(chaiThings);
+
+// Create tenant database.
+const createTenant = () => {  
+  return TenantsManager.createTenant();
+};
+
+// Drops tenant database.
+const dropTenant = async (tenantWebsite) => {
+  return TenantsManager.dropTenant(tenantWebsite);
+};
+
+// Create a new user that associate to the given tenant Db.
+const createUser = async (tenantWebsite, givenUser) => {
+  const userPassword = (givenUser && givenUser.password) ? givenUser.password : 'admin'
+  const hashedPassword = await hashPassword(userPassword);
+
+  const userInfo = {
+    first_name: faker.lorem.word(),
+    last_name: faker.lorem.word(),
+    email: faker.internet.email(),
+    active: 1,
+    phone_number: faker.phone.phoneNumberFormat().replace('-', ''),
+    password: hashedPassword,
+    ...givenUser,
+  };
+  const user = await TenantsManager.createTenantUser(tenantWebsite, userInfo);
+  return user;
+};
+
+const login = async (tenantWebsite, givenUser) => {
+  let user = givenUser;
+
+  if (!givenUser && tenantWebsite) {
+    const createdUser = await createUser(tenantWebsite, givenUser);
+    user = createdUser;
+  }
+  return request()
+    .post('/api/auth/login')
+    .send({
+      crediential: user.email,
+      password: 'admin',
+    });
+};
+
+const bindTenantModel = (tenantDb) => {
+  TenantModel.knexBinded = tenantDb;
+};
+
+const systemFactory = createSystemFactory();
+
+export {
+  login,
+  systemFactory,
+  createTenantFactory, 
+  createTenant,
+  createUser,
+  dropTenant,
+  expect,
+  request,
+  bindTenantModel,
+};
diff --git a/packages/server/tests/utils/utils.test.js b/packages/server/tests/utils/utils.test.js
new file mode 100644
index 000000000..4dc6ae640
--- /dev/null
+++ b/packages/server/tests/utils/utils.test.js
@@ -0,0 +1,16 @@
+import { dateRangeCollection } from 'utils';
+import { expect } from '../testInit';
+
+describe('utils', () => {
+
+  describe('dateRangeCollection()', () => {
+    it('Should retrieve all range dates.', () => {
+      const fromDate = new Date('2020-1-1');
+      const toDate = new Date('2020-1-25');
+
+      const range = dateRangeCollection(fromDate, toDate);
+
+      expect(range.length).equals(25);
+    });
+  });
+});
diff --git a/packages/server/tsconfig.json b/packages/server/tsconfig.json
new file mode 100644
index 000000000..8312fd145
--- /dev/null
+++ b/packages/server/tsconfig.json
@@ -0,0 +1,36 @@
+{
+  "compilerOptions": {
+    "target": "es2017",
+    "lib": [
+      "es2017",
+      "esnext.asynciterable"
+    ],
+    "typeRoots": [
+      "./node_modules/@types",
+      "./src/types"
+    ],
+    "allowSyntheticDefaultImports": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "module": "commonjs",
+    "pretty": true,
+    "sourceMap": true,
+    "outDir": "./build",
+    "allowJs": true,
+    "noEmit": false,
+    "esModuleInterop": true,
+    "baseUrl": "./src",
+    "paths": {
+      "@/*": ["./*"]
+    },
+  },
+  "include": [
+    "./src/**/*"
+  ],
+  "exclude": [
+    "./node_modules",
+    "tests"
+  ]
+}
\ No newline at end of file
diff --git a/packages/server/views/images/bigcapital.png b/packages/server/views/images/bigcapital.png
new file mode 100644
index 000000000..72cbc0608
Binary files /dev/null and b/packages/server/views/images/bigcapital.png differ
diff --git a/packages/server/views/mail/LicenseReceive.html b/packages/server/views/mail/LicenseReceive.html
new file mode 100644
index 000000000..6a8c721e3
--- /dev/null
+++ b/packages/server/views/mail/LicenseReceive.html
@@ -0,0 +1,411 @@
+<!doctype html>
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width" />
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+    <title>Bigcapital | Reset your password</title>
+    <style>
+      /* -------------------------------------
+          GLOBAL RESETS
+      ------------------------------------- */
+      
+      /*All the styling goes here*/
+      
+      img {
+        border: none;
+        -ms-interpolation-mode: bicubic;
+        max-width: 100%; 
+      }
+
+      body {
+        background-color: #f6f6f6;
+        font-family: sans-serif;
+        -webkit-font-smoothing: antialiased;
+        font-size: 14px;
+        line-height: 1.4;
+        margin: 0;
+        padding: 0;
+        -ms-text-size-adjust: 100%;
+        -webkit-text-size-adjust: 100%; 
+      }
+
+      table {
+        border-collapse: separate;
+        mso-table-lspace: 0pt;
+        mso-table-rspace: 0pt;
+        width: 100%; }
+        table td {
+          font-family: sans-serif;
+          font-size: 14px;
+          vertical-align: top; 
+      }
+
+      /* -------------------------------------
+          BODY & CONTAINER
+      ------------------------------------- */
+
+      .body {
+        background-color: #f6f6f6;
+        width: 100%; 
+      }
+
+      /* Set a max-width, and make it display as block so it will automatically stretch to that width, but will also shrink down on a phone or something */
+      .container {
+        display: block;
+        margin: 0 auto !important;
+        /* makes it centered */
+        max-width: 580px;
+        padding: 10px;
+        width: 580px; 
+      }
+
+      /* This should also be a block element, so that it will fill 100% of the .container */
+      .content {
+        box-sizing: border-box;
+        display: block;
+        margin: 0 auto;
+        max-width: 580px;
+        padding: 10px; 
+      }
+
+      /* -------------------------------------
+          HEADER, FOOTER, MAIN
+      ------------------------------------- */
+      .main {
+        background: #ffffff;
+        border-radius: 3px;
+        width: 100%; 
+      }
+
+      .wrapper {
+        box-sizing: border-box;
+        padding: 20px; 
+      }
+
+      .content-block {
+        padding-bottom: 10px;
+        padding-top: 10px;
+      }
+
+      .footer {
+        clear: both;
+        margin-top: 10px;
+        text-align: center;
+        width: 100%; 
+      }
+        .footer td,
+        .footer p,
+        .footer span,
+        .footer a {
+          color: #999999;
+          font-size: 12px;
+          text-align: center; 
+      }
+
+      /* -------------------------------------
+          TYPOGRAPHY
+      ------------------------------------- */
+      h1,
+      h2,
+      h3,
+      h4 {
+        color: #000000;
+        font-family: sans-serif;
+        font-weight: bold;
+        line-height: 1.4;
+        margin: 0;
+        margin-bottom: 0; 
+      }
+
+      h1 {
+        font-size: 35px;
+        font-weight: 300;
+        text-align: center;
+        text-transform: capitalize; 
+      }
+
+      p,
+      ul,
+      ol {
+        font-family: sans-serif;
+        font-size: 14px;
+        font-weight: normal;
+        margin: 0;
+        margin-bottom: 15px; 
+      }
+        p li,
+        ul li,
+        ol li {
+          list-style-position: inside;
+          margin-left: 5px; 
+      }
+
+      a {
+        color: #3498db;
+        text-decoration: underline; 
+      }
+
+      /* -------------------------------------
+          BUTTONS
+      ------------------------------------- */
+      .btn {
+        box-sizing: border-box;
+        width: 100%;
+        
+      }
+        .btn > tbody > tr > td {
+          padding-bottom: 15px; }
+        .btn table {
+          width: auto; 
+      }
+        .btn table td {
+          background-color: #ffffff;
+          border-radius: 5px;
+          text-align: center; 
+      }
+        .btn a {
+          background-color: #ffffff;
+          border: solid 1px #3498db;
+          border-radius: 5px;
+          box-sizing: border-box;
+          color: #3498db;
+          cursor: pointer;
+          display: inline-block;
+          font-size: 14px;
+          font-weight: bold;
+          margin: 0;
+          padding: 12px 25px;
+          text-decoration: none;
+          text-transform: capitalize; 
+      }
+
+      .btn-primary table td {
+        background-color: #2d95fd; 
+      }
+
+      .btn-primary a {
+        background-color: #2d95fd;
+        border-color: #2d95fd;
+        color: #ffffff; 
+      }
+
+      /* -------------------------------------
+          OTHER STYLES THAT MIGHT BE USEFUL
+      ------------------------------------- */
+      .last {
+        margin-bottom: 0; 
+      }
+
+      .first {
+        margin-top: 0; 
+      }
+
+      .align-center {
+        text-align: center; 
+      }
+
+      .align-right {
+        text-align: right; 
+      }
+
+      .align-left {
+        text-align: left; 
+      }
+
+      .clear {
+        clear: both; 
+      }
+
+      .mt0 {
+        margin-top: 0; 
+      }
+
+      .mb0 {
+        margin-bottom: 0; 
+      }
+      
+      .mb4{
+        margin-bottom: 4rem;
+      }
+
+      .preheader {
+        color: transparent;
+        display: none;
+        height: 0;
+        max-height: 0;
+        max-width: 0;
+        opacity: 0;
+        overflow: hidden;
+        mso-hide: all;
+        visibility: hidden;
+        width: 0; 
+      }
+
+      .powered-by a {
+        text-decoration: none; 
+      }
+
+      hr {
+        border: 0;
+        border-bottom: 1px solid #f6f6f6;
+        margin: 20px 0; 
+      }
+
+      /* -------------------------------------
+          RESPONSIVE AND MOBILE FRIENDLY STYLES
+      ------------------------------------- */
+      @media only screen and (max-width: 620px) {
+        table[class=body] h1 {
+          font-size: 28px !important;
+          margin-bottom: 10px !important; 
+        }
+        table[class=body] p,
+        table[class=body] ul,
+        table[class=body] ol,
+        table[class=body] td,
+        table[class=body] span,
+        table[class=body] a {
+          font-size: 16px !important; 
+        }
+        table[class=body] .wrapper,
+        table[class=body] .article {
+          padding: 10px !important; 
+        }
+        table[class=body] .content {
+          padding: 0 !important; 
+        }
+        table[class=body] .container {
+          padding: 0 !important;
+          width: 100% !important; 
+        }
+        table[class=body] .main {
+          border-left-width: 0 !important;
+          border-radius: 0 !important;
+          border-right-width: 0 !important; 
+        }
+        table[class=body] .btn table {
+          width: 100% !important; 
+        }
+        table[class=body] .btn a {
+          width: 100% !important; 
+        }
+        table[class=body] .img-responsive {
+          height: auto !important;
+          max-width: 100% !important;
+          width: auto !important; 
+        }
+      }
+      
+      
+
+      /* -------------------------------------
+          PRESERVE THESE STYLES IN THE HEAD
+      ------------------------------------- */
+      @media all {
+        .ExternalClass {
+          width: 100%; 
+        }
+        .ExternalClass,
+        .ExternalClass p,
+        .ExternalClass span,
+        .ExternalClass font,
+        .ExternalClass td,
+        .ExternalClass div {
+          line-height: 100%; 
+        }
+        .apple-link a {
+          color: inherit !important;
+          font-family: inherit !important;
+          font-size: inherit !important;
+          font-weight: inherit !important;
+          line-height: inherit !important;
+          text-decoration: none !important; 
+        }
+        #MessageViewBody a {
+          color: inherit;
+          text-decoration: none;
+          font-size: inherit;
+          font-family: inherit;
+          font-weight: inherit;
+          line-height: inherit;
+        }
+        .btn-primary table td:hover {
+          background-color: #004dd0 !important; 
+        }
+        .btn-primary a:hover {
+          background-color: #004dd0 !important;
+          border-color: #004dd0 !important; 
+        } 
+      }
+      
+    
+      [data-icon="bigcapital"] path {
+        fill: #004dd0;
+      }
+
+      [data-icon='bigcapital'] .path-1,
+      [data-icon='bigcapital'] .path-13 {
+        fill: #2d95fd;
+      }
+    </style>
+  </head>
+  <body class="">
+    <span class="preheader">This is preheader text. Some clients will show this text as a preview.</span>
+    <table role="presentation" border="0" cellpadding="0" cellspacing="0" class="body">
+      <tr>
+        <td>&nbsp;</td>
+        <td class="container">
+          <div class="content">
+
+            <!-- START CENTERED WHITE CONTAINER -->
+            <table role="presentation" class="main">
+              <!-- START MAIN CONTENT AREA -->
+              <tr>
+                <td class="wrapper">
+                  <table role="presentation" border="0" cellpadding="0" cellspacing="0">
+                    <tr>
+                      <td>
+                        <p class="align-center">
+                          <svg data-icon="bigcapital" class="bigcapital" width="190" height="37" viewBox="0 0 309.09 42.89"><desc>bigcapital</desc><path d="M56,3.16,61.33,8.5,31.94,37.9l-5.35-5.35Z" class="path-1" fill-rule="evenodd"></path><path d="M29.53,6.94l5.35,5.34L5.49,41.67.14,36.33l15.8-15.8Z" class="path-2" fill-rule="evenodd"></path><path d="M94.36,38.87H79.62v-31H94c6.33,0,10.22,3.15,10.22,8V16a7.22,7.22,0,0,1-4.07,6.69c3.58,1.37,5.8,3.45,5.8,7.61v.09C106,36,101.35,38.87,94.36,38.87Zm3.1-21.81c0-2-1.59-3.19-4.47-3.19H86.26v6.55h6.29c3,0,4.91-1,4.91-3.28Zm1.72,12.39c0-2.08-1.54-3.37-5-3.37H86.26V32.9h8.1c3,0,4.82-1.06,4.82-3.36Z" class="path-3" fill-rule="evenodd"></path><path d="M110.56,12.54v-6h7.08v6Zm.18,26.33V15.15h6.72V38.87Z" class="path-4" fill-rule="evenodd"></path><path d="M134,46a22.55,22.55,0,0,1-10.49-2.47l2.3-5a15.52,15.52,0,0,0,8,2.17c4.61,0,6.78-2.21,6.78-6.46V33.08c-2,2.39-4.16,3.85-7.75,3.85-5.53,0-10.53-4-10.53-11.07v-.09c0-7.08,5.09-11.06,10.53-11.06a9.63,9.63,0,0,1,7.66,3.54v-3.1h6.72V33.52C147.2,42.46,142.78,46,134,46Zm6.6-20.27a5.79,5.79,0,0,0-11.56,0v.09a5.42,5.42,0,0,0,5.76,5.49,5.49,5.49,0,0,0,5.8-5.49Z" class="path-5" fill-rule="evenodd"></path><path d="M164,39.41a12.11,12.11,0,0,1-12.35-12.26v-.09a12.18,12.18,0,0,1,12.44-12.35c4.47,0,7.25,1.5,9.47,4l-4.12,4.43a6.93,6.93,0,0,0-5.4-2.61c-3.36,0-5.75,3-5.75,6.46v.09c0,3.63,2.34,6.55,6,6.55,2.26,0,3.8-1,5.44-2.53l3.94,4A12,12,0,0,1,164,39.41Z" class="path-6" fill-rule="evenodd"></path><path d="M191.51,38.87V36.31a9.15,9.15,0,0,1-7.17,3c-4.47,0-8.15-2.57-8.15-7.26V32c0-5.18,3.94-7.57,9.56-7.57a16.74,16.74,0,0,1,5.8,1V25c0-2.79-1.72-4.34-5.09-4.34a17.57,17.57,0,0,0-6.55,1.28l-1.68-5.13a21,21,0,0,1,9.21-1.9c7.34,0,10.57,3.8,10.57,10.22V38.87Zm.13-9.55a10.3,10.3,0,0,0-4.29-.89c-2.88,0-4.65,1.15-4.65,3.27v.09c0,1.82,1.5,2.88,3.67,2.88,3.15,0,5.27-1.73,5.27-4.16Z" class="path-7" fill-rule="evenodd"></path><path d="M217.49,39.32a9.1,9.1,0,0,1-7.39-3.54V46h-6.73V15.15h6.73v3.41a8.7,8.7,0,0,1,7.39-3.85c5.53,0,10.8,4.34,10.8,12.26v.09C228.29,35,223.11,39.32,217.49,39.32ZM221.56,27c0-3.94-2.66-6.55-5.8-6.55S210,23,210,27v.09c0,3.94,2.61,6.55,5.75,6.55s5.8-2.57,5.8-6.55Z" class="path-8" fill-rule="evenodd"></path><path d="M232.93,12.54v-6H240v6Zm.18,26.33V15.15h6.73V38.87Z" class="path-9" fill-rule="evenodd"></path><path d="M253.73,39.27c-4.11,0-6.9-1.63-6.9-7.12V20.91H244V15.15h2.83V9.09h6.73v6.06h5.57v5.76h-5.57V31c0,1.55.66,2.3,2.16,2.3A6.84,6.84,0,0,0,259,32.5v5.4A9.9,9.9,0,0,1,253.73,39.27Z" class="path-10" fill-rule="evenodd"></path><path d="M277.55,38.87V36.31a9.15,9.15,0,0,1-7.18,3c-4.46,0-8.14-2.57-8.14-7.26V32c0-5.18,3.94-7.57,9.56-7.57a16.74,16.74,0,0,1,5.8,1V25c0-2.79-1.73-4.34-5.09-4.34A17.57,17.57,0,0,0,266,21.92l-1.68-5.13a20.94,20.94,0,0,1,9.2-1.9c7.35,0,10.58,3.8,10.58,10.22V38.87Zm.13-9.55a10.31,10.31,0,0,0-4.3-.89c-2.87,0-4.64,1.15-4.64,3.27v.09c0,1.82,1.5,2.88,3.67,2.88,3.14,0,5.27-1.73,5.27-4.16Z" class="path-11" fill-rule="evenodd"></path><path d="M289.72,38.87V6.57h6.72v32.3Z" class="path-12" fill-rule="evenodd"></path><path d="M302.06,38.87V31.79h7.17v7.08Z" class="path-13" fill-rule="evenodd"></path></svg>
+                        </p>
+                        
+                        <hr />
+                        
+                        <p class="align-center">
+                          <h3>License Code</h3>
+                        </p>
+                        <p class="mgb-1x">
+                          <h1>{{ licenseCode }}</h1>
+                        </p>
+                        <p class="email-note">
+                          This is an automatically generated email please do not reply to
+                          this email. If you face any issues, please contact us at <a href="mailto:{{ successEmail }}">{{ successEmail }}</a> or call <u>{{ successPhoneNumber }}</u></p>
+                      </td>
+                    </tr>
+                  </table>
+                </td>
+              </tr>
+
+            <!-- END MAIN CONTENT AREA -->
+            </table>
+            <!-- END CENTERED WHITE CONTAINER -->
+
+            <!-- START FOOTER -->
+            <div class="footer">
+              <table role="presentation" border="0" cellpadding="0" cellspacing="0">
+                <tr>
+                  <td class="content-block powered-by">
+                    Powered by <a href="http://htmlemail.io">Bigcapital.com</a>.
+                  </td>
+                </tr>
+              </table>
+            </div>
+            <!-- END FOOTER -->
+
+          </div>
+        </td>
+        <td>&nbsp;</td>
+      </tr>
+    </table>
+  </body>
+</html>
diff --git a/packages/server/views/mail/ResetPassword.html b/packages/server/views/mail/ResetPassword.html
new file mode 100644
index 000000000..bf9da32ca
--- /dev/null
+++ b/packages/server/views/mail/ResetPassword.html
@@ -0,0 +1,426 @@
+<!doctype html>
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width" />
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+    <title>Bigcapital | Reset your password</title>
+    <style>
+      /* -------------------------------------
+          GLOBAL RESETS
+      ------------------------------------- */
+      
+      /*All the styling goes here*/
+      
+      img {
+        border: none;
+        -ms-interpolation-mode: bicubic;
+        max-width: 100%; 
+      }
+
+      body {
+        background-color: #f6f6f6;
+        font-family: sans-serif;
+        -webkit-font-smoothing: antialiased;
+        font-size: 14px;
+        line-height: 1.4;
+        margin: 0;
+        padding: 0;
+        -ms-text-size-adjust: 100%;
+        -webkit-text-size-adjust: 100%; 
+      }
+
+      table {
+        border-collapse: separate;
+        mso-table-lspace: 0pt;
+        mso-table-rspace: 0pt;
+        width: 100%; }
+        table td {
+          font-family: sans-serif;
+          font-size: 14px;
+          vertical-align: top; 
+      }
+
+      /* -------------------------------------
+          BODY & CONTAINER
+      ------------------------------------- */
+
+      .body {
+        background-color: #f6f6f6;
+        width: 100%; 
+      }
+
+      /* Set a max-width, and make it display as block so it will automatically stretch to that width, but will also shrink down on a phone or something */
+      .container {
+        display: block;
+        margin: 0 auto !important;
+        /* makes it centered */
+        max-width: 580px;
+        padding: 10px;
+        width: 580px; 
+      }
+
+      /* This should also be a block element, so that it will fill 100% of the .container */
+      .content {
+        box-sizing: border-box;
+        display: block;
+        margin: 0 auto;
+        max-width: 580px;
+        padding: 10px; 
+      }
+
+      /* -------------------------------------
+          HEADER, FOOTER, MAIN
+      ------------------------------------- */
+      .main {
+        background: #ffffff;
+        border-radius: 3px;
+        width: 100%; 
+      }
+
+      .wrapper {
+        box-sizing: border-box;
+        padding: 20px; 
+      }
+
+      .content-block {
+        padding-bottom: 10px;
+        padding-top: 10px;
+      }
+
+      .footer {
+        clear: both;
+        margin-top: 10px;
+        text-align: center;
+        width: 100%; 
+      }
+        .footer td,
+        .footer p,
+        .footer span,
+        .footer a {
+          color: #999999;
+          font-size: 12px;
+          text-align: center; 
+      }
+
+      /* -------------------------------------
+          TYPOGRAPHY
+      ------------------------------------- */
+      h1,
+      h2,
+      h3,
+      h4 {
+        color: #000000;
+        font-family: sans-serif;
+        font-weight: bold;
+        line-height: 1.4;
+        margin: 0;
+        margin-bottom: 0; 
+      }
+
+      h1 {
+        font-size: 35px;
+        font-weight: 300;
+        text-align: center;
+        text-transform: capitalize; 
+      }
+
+      p,
+      ul,
+      ol {
+        font-family: sans-serif;
+        font-size: 14px;
+        font-weight: normal;
+        margin: 0;
+        margin-bottom: 15px; 
+      }
+        p li,
+        ul li,
+        ol li {
+          list-style-position: inside;
+          margin-left: 5px; 
+      }
+
+      a {
+        color: #3498db;
+        text-decoration: underline; 
+      }
+
+      /* -------------------------------------
+          BUTTONS
+      ------------------------------------- */
+      .btn {
+        box-sizing: border-box;
+        width: 100%;
+        
+      }
+        .btn > tbody > tr > td {
+          padding-bottom: 15px; }
+        .btn table {
+          width: auto; 
+      }
+        .btn table td {
+          background-color: #ffffff;
+          border-radius: 5px;
+          text-align: center; 
+      }
+        .btn a {
+          background-color: #ffffff;
+          border: solid 1px #3498db;
+          border-radius: 5px;
+          box-sizing: border-box;
+          color: #3498db;
+          cursor: pointer;
+          display: inline-block;
+          font-size: 14px;
+          font-weight: bold;
+          margin: 0;
+          padding: 12px 25px;
+          text-decoration: none;
+          text-transform: capitalize; 
+      }
+
+      .btn-primary table td {
+        background-color: #2d95fd; 
+      }
+
+      .btn-primary a {
+        background-color: #1968F0;
+        border-color: #1968F0;
+        color: #ffffff; 
+      }
+
+      /* -------------------------------------
+          OTHER STYLES THAT MIGHT BE USEFUL
+      ------------------------------------- */
+      .last {
+        margin-bottom: 0; 
+      }
+
+      .first {
+        margin-top: 0; 
+      }
+
+      .align-center {
+        text-align: center; 
+      }
+
+      .align-right {
+        text-align: right; 
+      }
+
+      .align-left {
+        text-align: left; 
+      }
+
+      .clear {
+        clear: both; 
+      }
+
+      .mt0 {
+        margin-top: 0; 
+      }
+
+      .mb0 {
+        margin-bottom: 0; 
+      }
+      
+      .mb4{
+        margin-bottom: 4rem;
+      }
+
+      .preheader {
+        color: transparent;
+        display: none;
+        height: 0;
+        max-height: 0;
+        max-width: 0;
+        opacity: 0;
+        overflow: hidden;
+        mso-hide: all;
+        visibility: hidden;
+        width: 0; 
+      }
+
+      .powered-by a {
+        text-decoration: none; 
+      }
+
+      hr {
+        border: 0;
+        border-bottom: 1px solid #f6f6f6;
+        margin: 20px 0; 
+      }
+
+      /* -------------------------------------
+          RESPONSIVE AND MOBILE FRIENDLY STYLES
+      ------------------------------------- */
+      @media only screen and (max-width: 620px) {
+        table[class=body] h1 {
+          font-size: 28px !important;
+          margin-bottom: 10px !important; 
+        }
+        table[class=body] p,
+        table[class=body] ul,
+        table[class=body] ol,
+        table[class=body] td,
+        table[class=body] span,
+        table[class=body] a {
+          font-size: 16px !important; 
+        }
+        table[class=body] .wrapper,
+        table[class=body] .article {
+          padding: 10px !important; 
+        }
+        table[class=body] .content {
+          padding: 0 !important; 
+        }
+        table[class=body] .container {
+          padding: 0 !important;
+          width: 100% !important; 
+        }
+        table[class=body] .main {
+          border-left-width: 0 !important;
+          border-radius: 0 !important;
+          border-right-width: 0 !important; 
+        }
+        table[class=body] .btn table {
+          width: 100% !important; 
+        }
+        table[class=body] .btn a {
+          width: 100% !important; 
+        }
+        table[class=body] .img-responsive {
+          height: auto !important;
+          max-width: 100% !important;
+          width: auto !important; 
+        }
+      }
+      
+      
+
+      /* -------------------------------------
+          PRESERVE THESE STYLES IN THE HEAD
+      ------------------------------------- */
+      @media all {
+        .ExternalClass {
+          width: 100%; 
+        }
+        .ExternalClass,
+        .ExternalClass p,
+        .ExternalClass span,
+        .ExternalClass font,
+        .ExternalClass td,
+        .ExternalClass div {
+          line-height: 100%; 
+        }
+        .apple-link a {
+          color: inherit !important;
+          font-family: inherit !important;
+          font-size: inherit !important;
+          font-weight: inherit !important;
+          line-height: inherit !important;
+          text-decoration: none !important; 
+        }
+        #MessageViewBody a {
+          color: inherit;
+          text-decoration: none;
+          font-size: inherit;
+          font-family: inherit;
+          font-weight: inherit;
+          line-height: inherit;
+        }
+        .btn-primary table td:hover {
+          background-color: #004dd0 !important; 
+        }
+        .btn-primary a:hover {
+          background-color: #004dd0 !important;
+          border-color: #004dd0 !important; 
+        } 
+      }
+      
+    
+      [data-icon="bigcapital"] path {
+        fill: #004dd0;
+      }
+
+      [data-icon='bigcapital'] .path-1,
+      [data-icon='bigcapital'] .path-13 {
+        fill: #2d95fd;
+      }
+    </style>
+  </head>
+  <body class="">
+    <span class="preheader">This is preheader text. Some clients will show this text as a preview.</span>
+    <table role="presentation" border="0" cellpadding="0" cellspacing="0" class="body">
+      <tr>
+        <td>&nbsp;</td>
+        <td class="container">
+          <div class="content">
+
+            <!-- START CENTERED WHITE CONTAINER -->
+            <table role="presentation" class="main">
+              <!-- START MAIN CONTENT AREA -->
+              <tr>
+                <td class="wrapper">
+                  <table role="presentation" border="0" cellpadding="0" cellspacing="0">
+                    <tr>
+                      <td>
+                        <p class="align-center">
+                          <img src="cid:bigcapital_logo" />
+                        </p>
+                        <hr />
+                        
+                        <p class="align-center">
+                          <h3>Reset Your Password</h3>
+                        </p>
+                        <p class="mgb-1x">Hi <strong>{{ first_name }} {{ last_name }}<strong>,</p>
+                        <p class="mgb-2-5x">Click on the link blow to reset your password.</p>
+                        
+                        <table role="presentation" border="0" cellpadding="0" cellspacing="0" class="btn btn-primary">
+                          <tbody>
+                            <tr>
+                              <td align="left">
+                                <table role="presentation" border="0" cellpadding="0" cellspacing="0">
+                                  <tbody>
+                                    <tr>
+                                      <td> <a href="{{ resetPasswordUrl }}" target="_blank">Reset Your password</a> </td>
+                                    </tr>
+                                  </tbody>
+                                </table>
+                              </td>
+                            </tr>
+                          </tbody>
+                        </table>
+                        <p>If you did not make this request, please contact us or ignore this message.</p>
+                        <p class="email-note">
+                          This is an automatically generated email please do not reply to
+                          this email. If you face any issues, please contact us at {{ contact_us_email }}</p>
+                      </td>
+                    </tr>
+                  </table>
+                </td>
+              </tr>
+
+            <!-- END MAIN CONTENT AREA -->
+            </table>
+            <!-- END CENTERED WHITE CONTAINER -->
+
+            <!-- START FOOTER -->
+            <div class="footer">
+              <table role="presentation" border="0" cellpadding="0" cellspacing="0">
+                <tr>
+                  <td class="content-block powered-by">
+                    Powered by <a href="https://Bigcapital.ly">Bigcapital.ly</a>.
+                  </td>
+                </tr>
+              </table>
+            </div>
+            <!-- END FOOTER -->
+
+          </div>
+        </td>
+        <td>&nbsp;</td>
+      </tr>
+    </table>
+  </body>
+</html>
diff --git a/packages/server/views/mail/UserInvite.html b/packages/server/views/mail/UserInvite.html
new file mode 100644
index 000000000..60b2a75d4
--- /dev/null
+++ b/packages/server/views/mail/UserInvite.html
@@ -0,0 +1,421 @@
+<!doctype html>
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width" />
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+    <title>Bigcapital | Reset your password</title>
+    <style>
+      /* -------------------------------------
+          GLOBAL RESETS
+      ------------------------------------- */
+      
+      img {
+        border: none;
+        -ms-interpolation-mode: bicubic;
+        max-width: 100%; 
+      }
+
+      body {
+        background-color: #f6f6f6;
+        font-family: sans-serif;
+        -webkit-font-smoothing: antialiased;
+        font-size: 14px;
+        line-height: 1.4;
+        margin: 0;
+        padding: 0;
+        -ms-text-size-adjust: 100%;
+        -webkit-text-size-adjust: 100%; 
+      }
+
+      table {
+        border-collapse: separate;
+        mso-table-lspace: 0pt;
+        mso-table-rspace: 0pt;
+        width: 100%; }
+        table td {
+          font-family: sans-serif;
+          font-size: 14px;
+          vertical-align: top; 
+      }
+
+      /* -------------------------------------
+          BODY & CONTAINER
+      ------------------------------------- */
+
+      .body {
+        background-color: #f6f6f6;
+        width: 100%; 
+      }
+
+      /* Set a max-width, and make it display as block so it will automatically stretch to that width, but will also shrink down on a phone or something */
+      .container {
+        display: block;
+        margin: 0 auto !important;
+        /* makes it centered */
+        max-width: 580px;
+        padding: 10px;
+        width: 580px; 
+      }
+
+      /* This should also be a block element, so that it will fill 100% of the .container */
+      .content {
+        box-sizing: border-box;
+        display: block;
+        margin: 0 auto;
+        max-width: 580px;
+        padding: 10px; 
+      }
+
+      /* -------------------------------------
+          HEADER, FOOTER, MAIN
+      ------------------------------------- */
+      .main {
+        background: #ffffff;
+        border-radius: 3px;
+        width: 100%; 
+      }
+
+      .wrapper {
+        box-sizing: border-box;
+        padding: 20px; 
+      }
+
+      .content-block {
+        padding-bottom: 10px;
+        padding-top: 10px;
+      }
+
+      .footer {
+        clear: both;
+        margin-top: 10px;
+        text-align: center;
+        width: 100%; 
+      }
+        .footer td,
+        .footer p,
+        .footer span,
+        .footer a {
+          color: #999999;
+          font-size: 12px;
+          text-align: center; 
+      }
+
+      /* -------------------------------------
+          TYPOGRAPHY
+      ------------------------------------- */
+      h1,
+      h2,
+      h3,
+      h4 {
+        color: #000000;
+        font-family: sans-serif;
+        font-weight: bold;
+        line-height: 1.4;
+        margin: 0;
+        margin-bottom: 0; 
+      }
+
+      h1 {
+        font-size: 35px;
+        font-weight: 300;
+        text-align: center;
+        text-transform: capitalize; 
+      }
+
+      p,
+      ul,
+      ol {
+        font-family: sans-serif;
+        font-size: 14px;
+        font-weight: normal;
+        margin: 0;
+        margin-bottom: 15px; 
+      }
+        p li,
+        ul li,
+        ol li {
+          list-style-position: inside;
+          margin-left: 5px; 
+      }
+
+      a {
+        color: #3498db;
+        text-decoration: underline; 
+      }
+
+      /* -------------------------------------
+          BUTTONS
+      ------------------------------------- */
+      .btn {
+        box-sizing: border-box;
+        width: 100%;
+        
+      }
+        .btn > tbody > tr > td {
+          padding-bottom: 15px; }
+        .btn table {
+          width: auto; 
+      }
+      .btn table td {
+          background-color: #ffffff;
+          border-radius: 5px;
+          text-align: center; 
+      }
+        .btn a {
+          background-color: #ffffff;
+          border: solid 1px #3498db;
+          border-radius: 5px;
+          box-sizing: border-box;
+          color: #3498db;
+          cursor: pointer;
+          display: inline-block;
+          font-size: 14px;
+          font-weight: bold;
+          margin: 0;
+          padding: 12px 25px;
+          text-decoration: none;
+          text-transform: capitalize; 
+      }
+
+      .btn-primary table td {
+        background-color: #2d95fd; 
+      }
+
+      .btn-primary a {
+        background-color: #2d95fd;
+        border-color: #2d95fd;
+        color: #ffffff; 
+      }
+
+      /* -------------------------------------
+          OTHER STYLES THAT MIGHT BE USEFUL
+      ------------------------------------- */
+      .last {
+        margin-bottom: 0; 
+      }
+
+      .first {
+        margin-top: 0; 
+      }
+
+      .align-center {
+        text-align: center; 
+      }
+
+      .align-right {
+        text-align: right; 
+      }
+
+      .align-left {
+        text-align: left; 
+      }
+
+      .clear {
+        clear: both; 
+      }
+
+      .mt0 {
+        margin-top: 0; 
+      }
+
+      .mb0 {
+        margin-bottom: 0; 
+      }
+      
+      .mb4{
+        margin-bottom: 4rem;
+      }
+
+      .preheader {
+        color: transparent;
+        display: none;
+        height: 0;
+        max-height: 0;
+        max-width: 0;
+        opacity: 0;
+        overflow: hidden;
+        mso-hide: all;
+        visibility: hidden;
+        width: 0; 
+      }
+
+      .powered-by a {
+        text-decoration: none; 
+      }
+
+      hr {
+        border: 0;
+        border-bottom: 1px solid #f6f6f6;
+        margin: 20px 0; 
+      }
+
+      /* -------------------------------------
+          RESPONSIVE AND MOBILE FRIENDLY STYLES
+      ------------------------------------- */
+      @media only screen and (max-width: 620px) {
+        table[class=body] h1 {
+          font-size: 28px !important;
+          margin-bottom: 10px !important; 
+        }
+        table[class=body] p,
+        table[class=body] ul,
+        table[class=body] ol,
+        table[class=body] td,
+        table[class=body] span,
+        table[class=body] a {
+          font-size: 16px !important; 
+        }
+        table[class=body] .wrapper,
+        table[class=body] .article {
+          padding: 10px !important; 
+        }
+        table[class=body] .content {
+          padding: 0 !important; 
+        }
+        table[class=body] .container {
+          padding: 0 !important;
+          width: 100% !important; 
+        }
+        table[class=body] .main {
+          border-left-width: 0 !important;
+          border-radius: 0 !important;
+          border-right-width: 0 !important; 
+        }
+        table[class=body] .btn table {
+          width: 100% !important; 
+        }
+        table[class=body] .btn a {
+          width: 100% !important; 
+        }
+        table[class=body] .img-responsive {
+          height: auto !important;
+          max-width: 100% !important;
+          width: auto !important; 
+        }
+      }
+      
+      
+
+      /* -------------------------------------
+          PRESERVE THESE STYLES IN THE HEAD
+      ------------------------------------- */
+      @media all {
+        .ExternalClass {
+          width: 100%; 
+        }
+        .ExternalClass,
+        .ExternalClass p,
+        .ExternalClass span,
+        .ExternalClass font,
+        .ExternalClass td,
+        .ExternalClass div {
+          line-height: 100%; 
+        }
+        .apple-link a {
+          color: inherit !important;
+          font-family: inherit !important;
+          font-size: inherit !important;
+          font-weight: inherit !important;
+          line-height: inherit !important;
+          text-decoration: none !important; 
+        }
+        #MessageViewBody a {
+          color: inherit;
+          text-decoration: none;
+          font-size: inherit;
+          font-family: inherit;
+          font-weight: inherit;
+          line-height: inherit;
+        }
+        .btn-primary table td:hover {
+          background-color: #004dd0 !important; 
+        }
+        .btn-primary a:hover {
+          background-color: #004dd0 !important;
+          border-color: #004dd0 !important; 
+        } 
+      }
+      
+    
+      [data-icon="bigcapital"] path {
+        fill: #004dd0;
+      }
+
+      [data-icon='bigcapital'] .path-1,
+      [data-icon='bigcapital'] .path-13 {
+        fill: #2d95fd;
+      }
+    </style>
+  </head>
+  <body class="">
+    <span class="preheader">This is preheader text. Some clients will show this text as a preview.</span>
+    <table role="presentation" border="0" cellpadding="0" cellspacing="0" class="body">
+      <tr>
+        <td>&nbsp;</td>
+        <td class="container">
+          <div class="content">
+
+            <!-- START CENTERED WHITE CONTAINER -->
+            <table role="presentation" class="main">
+              <!-- START MAIN CONTENT AREA -->
+              <tr>
+                <td class="wrapper">
+                  <table role="presentation" border="0" cellpadding="0" cellspacing="0">
+                    <tr>
+                      <td>
+                        <p class="align-center">
+                          <img src="cid:bigcapital_logo" />
+                        </p>
+                        
+                        <hr />
+                        
+                        <p class="align-center">
+                          <h3>Join {{ organizationName }} on Bigcapital</h3>
+                        </p>
+                        <p class="mgb-1x">{{ fullName }} ({{ email }}) has invited you to join the Bigcapital workspace {{ organizationName }}. Join now to start collaborating!</p>
+                        <p class="mgb-2-5x">Accept invitation The link blow to reset your password.</p>
+                        
+                        <table role="presentation" border="0" cellpadding="0" cellspacing="0" class="btn btn-primary">
+                          <tbody>
+                            <tr>
+                              <td align="left">
+                                <table role="presentation" border="0" cellpadding="0" cellspacing="0">
+                                  <tbody>
+                                    <tr>
+                                      <td><a href="{{ acceptUrl }}" target="_blank">Accept Invitation</a> </td>
+                                    </tr>
+                                  </tbody>
+                                </table>
+                              </td>
+                            </tr>
+                          </tbody>
+                        </table>
+                      </td>
+                    </tr>
+                  </table>
+                </td>
+              </tr>
+
+            <!-- END MAIN CONTENT AREA -->
+            </table>
+            <!-- END CENTERED WHITE CONTAINER -->
+
+            <!-- START FOOTER -->
+            <div class="footer">
+              <table role="presentation" border="0" cellpadding="0" cellspacing="0">
+                <tr>
+                  <td class="content-block powered-by">
+                    Made by Bigcapital Technologies, Inc
+                  </td>
+                </tr>
+              </table>
+            </div>
+            <!-- END FOOTER -->
+
+          </div>
+        </td>
+        <td>&nbsp;</td>
+      </tr>
+    </table>
+  </body>
+</html>
diff --git a/packages/server/views/mail/Welcome.html b/packages/server/views/mail/Welcome.html
new file mode 100644
index 000000000..bdf483df9
--- /dev/null
+++ b/packages/server/views/mail/Welcome.html
@@ -0,0 +1,407 @@
+<!doctype html>
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width" />
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+    <title>Bigcapital | Reset your password</title>
+    <style>
+      /* -------------------------------------
+          GLOBAL RESETS
+      ------------------------------------- */
+      
+      img {
+        border: none;
+        -ms-interpolation-mode: bicubic;
+        max-width: 100%; 
+      }
+
+      body {
+        background-color: #f6f6f6;
+        font-family: sans-serif;
+        -webkit-font-smoothing: antialiased;
+        font-size: 14px;
+        line-height: 1.4;
+        margin: 0;
+        padding: 0;
+        -ms-text-size-adjust: 100%;
+        -webkit-text-size-adjust: 100%; 
+      }
+
+      table {
+        border-collapse: separate;
+        mso-table-lspace: 0pt;
+        mso-table-rspace: 0pt;
+        width: 100%; }
+        table td {
+          font-family: sans-serif;
+          font-size: 14px;
+          vertical-align: top; 
+      }
+
+      /* -------------------------------------
+          BODY & CONTAINER
+      ------------------------------------- */
+
+      .body {
+        background-color: #f6f6f6;
+        width: 100%; 
+      }
+
+      /* Set a max-width, and make it display as block so it will automatically stretch to that width, but will also shrink down on a phone or something */
+      .container {
+        display: block;
+        margin: 0 auto !important;
+        /* makes it centered */
+        max-width: 580px;
+        padding: 10px;
+        width: 580px; 
+      }
+
+      /* This should also be a block element, so that it will fill 100% of the .container */
+      .content {
+        box-sizing: border-box;
+        display: block;
+        margin: 0 auto;
+        max-width: 580px;
+        padding: 10px; 
+      }
+
+      /* -------------------------------------
+          HEADER, FOOTER, MAIN
+      ------------------------------------- */
+      .main {
+        background: #ffffff;
+        border-radius: 3px;
+        width: 100%; 
+      }
+
+      .wrapper {
+        box-sizing: border-box;
+        padding: 20px; 
+      }
+
+      .content-block {
+        padding-bottom: 10px;
+        padding-top: 10px;
+      }
+
+      .footer {
+        clear: both;
+        margin-top: 10px;
+        text-align: center;
+        width: 100%; 
+      }
+        .footer td,
+        .footer p,
+        .footer span,
+        .footer a {
+          color: #999999;
+          font-size: 12px;
+          text-align: center; 
+      }
+
+      /* -------------------------------------
+          TYPOGRAPHY
+      ------------------------------------- */
+      h1,
+      h2,
+      h3,
+      h4 {
+        color: #000000;
+        font-family: sans-serif;
+        font-weight: bold;
+        line-height: 1.4;
+        margin: 0;
+        margin-bottom: 0; 
+      }
+
+      h1 {
+        font-size: 35px;
+        font-weight: 300;
+        text-align: center;
+        text-transform: capitalize; 
+      }
+
+      p,
+      ul,
+      ol {
+        font-family: sans-serif;
+        font-size: 14px;
+        font-weight: normal;
+        margin: 0;
+        margin-bottom: 15px; 
+      }
+        p li,
+        ul li,
+        ol li {
+          list-style-position: inside;
+          margin-left: 5px; 
+      }
+
+      a {
+        color: #3498db;
+        text-decoration: underline; 
+      }
+
+      /* -------------------------------------
+          BUTTONS
+      ------------------------------------- */
+      .btn {
+        box-sizing: border-box;
+        width: 100%;
+        
+      }
+        .btn > tbody > tr > td {
+          padding-bottom: 15px; }
+        .btn table {
+          width: auto; 
+      }
+      .btn table td {
+          background-color: #ffffff;
+          border-radius: 5px;
+          text-align: center; 
+      }
+        .btn a {
+          background-color: #ffffff;
+          border: solid 1px #3498db;
+          border-radius: 5px;
+          box-sizing: border-box;
+          color: #3498db;
+          cursor: pointer;
+          display: inline-block;
+          font-size: 14px;
+          font-weight: bold;
+          margin: 0;
+          padding: 12px 25px;
+          text-decoration: none;
+          text-transform: capitalize; 
+      }
+
+      .btn-primary table td {
+        background-color: #2d95fd; 
+      }
+
+      .btn-primary a {
+        background-color: #2d95fd;
+        border-color: #2d95fd;
+        color: #ffffff; 
+      }
+
+      /* -------------------------------------
+          OTHER STYLES THAT MIGHT BE USEFUL
+      ------------------------------------- */
+      .last {
+        margin-bottom: 0; 
+      }
+
+      .first {
+        margin-top: 0; 
+      }
+
+      .align-center {
+        text-align: center; 
+      }
+
+      .align-right {
+        text-align: right; 
+      }
+
+      .align-left {
+        text-align: left; 
+      }
+
+      .clear {
+        clear: both; 
+      }
+
+      .mt0 {
+        margin-top: 0; 
+      }
+
+      .mb0 {
+        margin-bottom: 0; 
+      }
+      
+      .mb4{
+        margin-bottom: 4rem;
+      }
+
+      .preheader {
+        color: transparent;
+        display: none;
+        height: 0;
+        max-height: 0;
+        max-width: 0;
+        opacity: 0;
+        overflow: hidden;
+        mso-hide: all;
+        visibility: hidden;
+        width: 0; 
+      }
+
+      .powered-by a {
+        text-decoration: none; 
+      }
+
+      hr {
+        border: 0;
+        border-bottom: 1px solid #f6f6f6;
+        margin: 20px 0; 
+      }
+
+      /* -------------------------------------
+          RESPONSIVE AND MOBILE FRIENDLY STYLES
+      ------------------------------------- */
+      @media only screen and (max-width: 620px) {
+        table[class=body] h1 {
+          font-size: 28px !important;
+          margin-bottom: 10px !important; 
+        }
+        table[class=body] p,
+        table[class=body] ul,
+        table[class=body] ol,
+        table[class=body] td,
+        table[class=body] span,
+        table[class=body] a {
+          font-size: 16px !important; 
+        }
+        table[class=body] .wrapper,
+        table[class=body] .article {
+          padding: 10px !important; 
+        }
+        table[class=body] .content {
+          padding: 0 !important; 
+        }
+        table[class=body] .container {
+          padding: 0 !important;
+          width: 100% !important; 
+        }
+        table[class=body] .main {
+          border-left-width: 0 !important;
+          border-radius: 0 !important;
+          border-right-width: 0 !important; 
+        }
+        table[class=body] .btn table {
+          width: 100% !important; 
+        }
+        table[class=body] .btn a {
+          width: 100% !important; 
+        }
+        table[class=body] .img-responsive {
+          height: auto !important;
+          max-width: 100% !important;
+          width: auto !important; 
+        }
+      }
+      
+      
+
+      /* -------------------------------------
+          PRESERVE THESE STYLES IN THE HEAD
+      ------------------------------------- */
+      @media all {
+        .ExternalClass {
+          width: 100%; 
+        }
+        .ExternalClass,
+        .ExternalClass p,
+        .ExternalClass span,
+        .ExternalClass font,
+        .ExternalClass td,
+        .ExternalClass div {
+          line-height: 100%; 
+        }
+        .apple-link a {
+          color: inherit !important;
+          font-family: inherit !important;
+          font-size: inherit !important;
+          font-weight: inherit !important;
+          line-height: inherit !important;
+          text-decoration: none !important; 
+        }
+        #MessageViewBody a {
+          color: inherit;
+          text-decoration: none;
+          font-size: inherit;
+          font-family: inherit;
+          font-weight: inherit;
+          line-height: inherit;
+        }
+        .btn-primary table td:hover {
+          background-color: #004dd0 !important; 
+        }
+        .btn-primary a:hover {
+          background-color: #004dd0 !important;
+          border-color: #004dd0 !important; 
+        } 
+      }
+      [data-icon="bigcapital"] path {
+        fill: #004dd0;
+      }
+
+      [data-icon='bigcapital'] .path-1,
+      [data-icon='bigcapital'] .path-13 {
+        fill: #2d95fd;
+      }
+    </style>
+  </head>
+  <body class="">
+    <span class="preheader">This is preheader text. Some clients will show this text as a preview.</span>
+    <table role="presentation" border="0" cellpadding="0" cellspacing="0" class="body">
+      <tr>
+        <td>&nbsp;</td>
+        <td class="container">
+          <div class="content">
+
+            <!-- START CENTERED WHITE CONTAINER -->
+            <table role="presentation" class="main">
+              <!-- START MAIN CONTENT AREA -->
+              <tr>
+                <td class="wrapper">
+                  <table role="presentation" border="0" cellpadding="0" cellspacing="0">
+                    <tr>
+                      <td>
+                        <p class="align-center">
+                          <img src="cid:bigcapital_logo" />
+                        </p>
+                        <hr />
+                        
+                        <p class="align-center">
+                          <h3>Hi {{ firstName }}, Welcome to Bigcapital, </h3>
+                        </p>
+
+                        <p class="mgb-1x">
+                          Your organization Id: <strong>{{ organizationId }}</strong>
+                        </p>
+                        <p class="mgb-1x">We are available to help you get started and answer any questions you may have. You can also email <a href="mailto:{{ successEmail }}">{{ successEmail }}</a> or call <u>{{ successPhoneNumber }}</u> about your set-up questions.</p>
+
+                        <p class="mgb-2-5x">Thank you for trusting Bigcapital Software for your business needs. We look forward to serving you!</p>
+                      </td>
+                    </tr>
+                  </table>
+                </td>
+              </tr>
+
+            <!-- END MAIN CONTENT AREA -->
+            </table>
+            <!-- END CENTERED WHITE CONTAINER -->
+
+            <!-- START FOOTER -->
+            <div class="footer">
+              <table role="presentation" border="0" cellpadding="0" cellspacing="0">
+                <tr>
+                  <td class="content-block powered-by">
+                    Made by Bigcapital Technologies, Inc
+                  </td>
+                </tr>
+              </table>
+            </div>
+            <!-- END FOOTER -->
+
+          </div>
+        </td>
+        <td>&nbsp;</td>
+      </tr>
+    </table>
+  </body>
+</html>