@@ -1,2 +1,6 @@
 # thoughts
 micro blogging platform (server api + client side) fullstack
+
+MEAN fullstack
+backend: nodejs + express + mongodb
+frontend: javascript + angular + bootstrap

@@ -0,0 +1,6 @@
+module.exports = {
+
+    'secret': 'secretfortoken',
+    'database': 'mongodb://localhost/thoughts'
+
+};

@@ -2,6 +2,14 @@ //File: controllers/tvshows.js
 var mongoose = require('mongoose');
 var userModel  = mongoose.model('userModel');
 
+/* */
+var jwt    = require('jsonwebtoken'); // used to create, sign, and verify tokens
+var express         = require("express");
+var app             = express();
+var config = require('../config'); // get our config file
+app.set('superSecret', config.secret); // secret variable
+/* */
+
 //GET - Return all tvshows in the DB
 exports.findAllUsers = function(req, res) {
 	userModel.find(function(err, users) {
@@ -29,9 +37,11 @@ console.log(req.body);
 
 	var user = new userModel({
 		username: req.body.username,
+		password: req.body.password,
 	    description:   req.body.description,
 	    icon:   req.body.icon,
-	    mail:   req.body.mail
+	    mail:   req.body.mail,
+		admin: req.body.admin
 	});
 
 	user.save(function(err, user) {
@@ -68,3 +78,42 @@ console.log('DELETE /activities/' + req.params.id);
 		})
 	});
 };
+
+
+//POST - auth user
+exports.login = function(req, res) {
+	// find the user
+  userModel.findOne({
+    username: req.body.username
+  }, function(err, user) {
+
+    if (err) throw err;
+
+    if (!user) {
+      res.json({ success: false, message: 'Authentication failed. User not found.' });
+    } else if (user) {
+
+      // check if password matches
+      if (user.password != req.body.password) {
+        res.json({ success: false, message: 'Authentication failed. Wrong password.' });
+      } else {
+
+        // if user is found and password is right
+        // create a token
+        var token = jwt.sign(user, app.get('superSecret'), {
+          //expiresInMinutes: 1440 // expires in 24 hours
+		  expiresIn: '10m'
+        });
+
+        // return the information including token as JSON
+        res.json({
+          success: true,
+          message: 'Enjoy your token!',
+          token: token
+        });
+      }
+
+    }
+
+  });
+};

@@ -15,8 +15,10 @@ });*/
 
 var userSchema = new Schema({
     username: { type: String },
+    password: { type: String },
     description:   { type: String },
     icon:   { type: String },
-    mail:   { type: String }
+    mail:   { type: String },
+    admin: { type: Boolean }
 })
 module.exports = mongoose.model('userModel', userSchema);

@@ -114,6 +114,5 @@ "shasum": "1f88aba4ab0b1508e8312acc39345f36e992e2f2",
     "tarball": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.13.tgz"
   },
   "directories": {},
-  "_resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.13.tgz",
-  "readme": "ERROR: No README data found!"
+  "_resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.13.tgz"
 }

@@ -27,7 +27,7 @@ "cache"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/jshttp/fresh"
+    "url": "git+https://github.com/jshttp/fresh.git"
   },
   "devDependencies": {
     "istanbul": "0.3.9",
@@ -82,5 +82,6 @@ "shasum": "651f838e22424e7566de161d8358caa199f83d4f",
     "tarball": "https://registry.npmjs.org/fresh/-/fresh-0.3.0.tgz"
   },
   "directories": {},
-  "_resolved": "https://registry.npmjs.org/fresh/-/fresh-0.3.0.tgz"
+  "_resolved": "https://registry.npmjs.org/fresh/-/fresh-0.3.0.tgz",
+  "readme": "ERROR: No README data found!"
 }

@@ -0,0 +1,22 @@
+{
+  "evil": true,
+  "regexdash": true,
+  "browser": true,
+  "wsh": true,
+  "trailing": true,
+  "sub": true,
+  "unused": true,
+  "undef": true,
+  "laxcomma": true,
+  "node": true,
+  "browser": false,
+  "esnext": true,
+  "globals": {
+    "describe": true,
+    "it": true,
+    "require": true,
+    "atob": false,
+    "escape": true,
+    "before": true
+  }
+}

@@ -0,0 +1,2 @@
+node_modules
+.DS_Store

@@ -0,0 +1,6 @@
+language: node_js
+before_install: npm i -g npm@1.4.28
+node_js:
+  - "5"
+  - "4"
+  - "0.12"

@@ -0,0 +1,266 @@
+# Change Log
+
+
+All notable changes to this project will be documented in this file starting from version **v4.0.0**.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## 7.1.2 - 2016-07-12
+
+ - do not stringify the payload when signing async - closes #224 ([084f537d3dfbcef2bea411cc0a1515899cc8aa21](https://github.com/auth0/node-jsonwebtoken/commit/084f537d3dfbcef2bea411cc0a1515899cc8aa21)), closes [#224](https://github.com/auth0/node-jsonwebtoken/issues/224)
+
+## 7.1.1 - 2016-07-12
+
+ - do not mutate options in jwt.verify, closes #227 ([63263a28a268624dab0927b9ad86fffa44a10f84](https://github.com/auth0/node-jsonwebtoken/commit/63263a28a268624dab0927b9ad86fffa44a10f84)), closes [#227](https://github.com/auth0/node-jsonwebtoken/issues/227)
+ - refactor into multiple files ([e11d505207fa33501298300c9accbfb809d8748d](https://github.com/auth0/node-jsonwebtoken/commit/e11d505207fa33501298300c9accbfb809d8748d))
+
+## 7.1.0 - 2016-07-12
+
+ - Exp calculated based on iat. fix #217 ([757a16e0e35ad19f9e456820f55d5d9f3fc76aee](https://github.com/auth0/node-jsonwebtoken/commit/757a16e0e35ad19f9e456820f55d5d9f3fc76aee)), closes [#217](https://github.com/auth0/node-jsonwebtoken/issues/217)
+
+## 7.0.0 - 2016-05-19
+
+ - change jwt.sign to return errors on callback instead of throwing errors ([1e46c5a42aa3dab8478efa4081d8f8f5c5485d56](https://github.com/auth0/node-jsonwebtoken/commit/1e46c5a42aa3dab8478efa4081d8f8f5c5485d56))
+
+## 6.2.0 - 2016-04-29
+
+ - add support for `options.clockTolerance` to `jwt.verify` ([65ddea934f226bf06bc9d6a55be9587515cfc38d](https://github.com/auth0/node-jsonwebtoken/commit/65ddea934f226bf06bc9d6a55be9587515cfc38d))
+
+## 6.1.2 - 2016-04-29
+
+ - fix sign method for node.js 0.12. closes #193 ([9c38374142d3929be3c9314b5e9bc5d963c5955f](https://github.com/auth0/node-jsonwebtoken/commit/9c38374142d3929be3c9314b5e9bc5d963c5955f)), closes [#193](https://github.com/auth0/node-jsonwebtoken/issues/193)
+ - improve async test ([7b0981380ddc40a5f1208df520631785b5ffb85a](https://github.com/auth0/node-jsonwebtoken/commit/7b0981380ddc40a5f1208df520631785b5ffb85a))
+
+## 6.1.0 - 2016-04-27
+
+ - verify unsigned tokens ([ec880791c10ed5ef7c8df7bf28ebb95c810479ed](https://github.com/auth0/node-jsonwebtoken/commit/ec880791c10ed5ef7c8df7bf28ebb95c810479ed))
+
+## 6.0.1 - 2016-04-27
+
+This was an immediate change after publishing 6.0.0.
+
+ - throw error on invalid options when the payload is not an object ([304f1b33075f79ed66f784e27dc4f5307aa39e27](https://github.com/auth0/node-jsonwebtoken/commit/304f1b33075f79ed66f784e27dc4f5307aa39e27))
+
+## 6.0.0 - 2016-04-27
+
+ - Change .sign to standard async callback ([50873c7d45d2733244d5da8afef3d1872e657a60](https://github.com/auth0/node-jsonwebtoken/commit/50873c7d45d2733244d5da8afef3d1872e657a60))
+ - Improved the options for the `sign` method ([53c3987b3cc34e95eb396b26fc9b051276e2f6f9](https://github.com/auth0/node-jsonwebtoken/commit/53c3987b3cc34e95eb396b26fc9b051276e2f6f9))
+
+    -  throw error on invalid options like `expiresIn` when the payload is not an object ([304f1b33075f79ed66f784e27dc4f5307aa39e27](https://github.com/auth0/node-jsonwebtoken/commit/304f1b33075f79ed66f784e27dc4f5307aa39e27))
+    -  `expiresInMinutes` and `expiresInSeconds` are deprecated and no longer supported.
+    -  `notBeforeInMinutes` and `notBeforeInSeconds` are deprecated and no longer supported.
+    -  `options` are strongly validated.
+    -  `options.expiresIn`, `options.notBefore`, `options.audience`, `options.issuer`, `options.subject` and `options.jwtid` are mutually exclusive with `payload.exp`, `payload.nbf`, `payload.aud`, `payload.iss`
+    -  `options.algorithm` is properly validated.
+    -  `options.headers` is renamed to `options.header`.
+
+ - update CHANGELOG to reflect most of the changes. closes #136 ([b87a1a8d2e2533fbfab518765a54f00077918eb7](https://github.com/auth0/node-jsonwebtoken/commit/b87a1a8d2e2533fbfab518765a54f00077918eb7)), closes [#136](https://github.com/auth0/node-jsonwebtoken/issues/136)
+ - update readme ([53a88ecf4494e30e1d62a1cf3cc354650349f486](https://github.com/auth0/node-jsonwebtoken/commit/53a88ecf4494e30e1d62a1cf3cc354650349f486))
+
+## 5.7.0 - 2016-02-16
+
+
+ - add support for validating multiples issuers. closes #163 ([39d9309ae05648dbd72e5fd1993df064ad0e8fa5](https://github.com/auth0/node-jsonwebtoken/commit/39d9309ae05648dbd72e5fd1993df064ad0e8fa5)), closes [#163](https://github.com/auth0/node-jsonwebtoken/issues/163)
+
+
+## 5.6.1 - 2016-02-16
+
+
+ - 5.6.1 ([06d8209d499dbc9a8dd978ab6cbb9c6818fde203](https://github.com/auth0/node-jsonwebtoken/commit/06d8209d499dbc9a8dd978ab6cbb9c6818fde203))
+ - fix wrong error when setting expiration on non-object payload. closes #153 ([7f7d76edfd918d6afc7c7cead888caa42ccaceb4](https://github.com/auth0/node-jsonwebtoken/commit/7f7d76edfd918d6afc7c7cead888caa42ccaceb4)), closes [#153](https://github.com/auth0/node-jsonwebtoken/issues/153)
+
+
+
+## 5.6.0 - 2016-02-16
+
+
+ - added missing validations of sub and jti ([a1affe960d0fc52e9042bcbdedb65734f8855580](https://github.com/auth0/node-jsonwebtoken/commit/a1affe960d0fc52e9042bcbdedb65734f8855580))
+ - Fix tests in jwt.rs.tests.js which causes 4 to fail ([8aedf2b1f575b0d9575c1fc9f2ac7bc868f75ff1](https://github.com/auth0/node-jsonwebtoken/commit/8aedf2b1f575b0d9575c1fc9f2ac7bc868f75ff1))
+ - Update README.md ([349b7cd00229789b138928ca060d3ef015aedaf9](https://github.com/auth0/node-jsonwebtoken/commit/349b7cd00229789b138928ca060d3ef015aedaf9))
+
+
+
+## 5.5.4 - 2016-01-04
+
+
+ - minor ([46552e7c45025c76e3f647680d7539a66bfac612](https://github.com/auth0/node-jsonwebtoken/commit/46552e7c45025c76e3f647680d7539a66bfac612))
+
+
+
+## 5.5.3 - 2016-01-04
+
+
+ - add a console.warn on invalid options for string payloads ([71200f14deba0533d3261266348338fac2d14661](https://github.com/auth0/node-jsonwebtoken/commit/71200f14deba0533d3261266348338fac2d14661))
+ - minor ([65b1f580382dc58dd3da6f47a52713776fd7cdf2](https://github.com/auth0/node-jsonwebtoken/commit/65b1f580382dc58dd3da6f47a52713776fd7cdf2))
+
+
+
+## 5.5.2 - 2016-01-04
+
+
+ - fix signing method with sealed objects, do not modify the params object. closes #147 ([be9c09af83b09c9e72da8b2c6166fa51d92aeab6](https://github.com/auth0/node-jsonwebtoken/commit/be9c09af83b09c9e72da8b2c6166fa51d92aeab6)), closes [#147](https://github.com/auth0/node-jsonwebtoken/issues/147)
+
+
+
+## 5.5.1 - 2016-01-04
+
+
+ - fix nbf verification. fix #152 ([786d37b299c67771b5e71a2ca476666ab0f97d98](https://github.com/auth0/node-jsonwebtoken/commit/786d37b299c67771b5e71a2ca476666ab0f97d98)), closes [#152](https://github.com/auth0/node-jsonwebtoken/issues/152)
+
+
+
+## 5.5.0 - 2015-12-28
+
+
+ - improvements to nbf and jti claims ([46372e928f6d2e7398f9b88022ca617d2a3b0699](https://github.com/auth0/node-jsonwebtoken/commit/46372e928f6d2e7398f9b88022ca617d2a3b0699))
+ - Remove duplicate payload line (fix bug in IE strict mode) ([8163d698e0c5ad8c44817a5dcd42a15d7e9c6bc8](https://github.com/auth0/node-jsonwebtoken/commit/8163d698e0c5ad8c44817a5dcd42a15d7e9c6bc8))
+ - Remove duplicate require('ms') line ([7c00bcbcbf8f7503a1070b394a165eccd41de66f](https://github.com/auth0/node-jsonwebtoken/commit/7c00bcbcbf8f7503a1070b394a165eccd41de66f))
+ - Update README to reflect addition of async sign ([d661d4b6f68eb417834c99b36769444723041ccf](https://github.com/auth0/node-jsonwebtoken/commit/d661d4b6f68eb417834c99b36769444723041ccf))
+
+
+
+## 5.4.0 - 2015-10-02
+
+
+ - deprecate expireInMinutes and expireInSeconds - in favor of expiresIn ([39ecc6f8f310f8462e082f1d53de0b4222b29b6f](https://github.com/auth0/node-jsonwebtoken/commit/39ecc6f8f310f8462e082f1d53de0b4222b29b6f))
+
+
+## 5.3.0 - 2015-10-02
+
+
+ - 5.3.0 ([5d559ced3fbf10c1adae2e5792deda06ea89bcd3](https://github.com/auth0/node-jsonwebtoken/commit/5d559ced3fbf10c1adae2e5792deda06ea89bcd3))
+ - minor ([6e81ff87a3799b0e56db09cbae42a97e784716c4](https://github.com/auth0/node-jsonwebtoken/commit/6e81ff87a3799b0e56db09cbae42a97e784716c4))
+
+
+
+## 5.1.0 - 2015-10-02
+
+
+ - added async signing ([9414fbcb15a1f9cf4fe147d070e9424c547dabba](https://github.com/auth0/node-jsonwebtoken/commit/9414fbcb15a1f9cf4fe147d070e9424c547dabba))
+ - Update README.md ([40b2aaaa843442dfb8ee7b574f0a788177e7c904](https://github.com/auth0/node-jsonwebtoken/commit/40b2aaaa843442dfb8ee7b574f0a788177e7c904))
+
+
+
+## 5.0.5 - 2015-08-19
+
+
+ - add ms dep to package.json ([f13b3fb7f29dff787e7c91ebe2eb5adeeb05f251](https://github.com/auth0/node-jsonwebtoken/commit/f13b3fb7f29dff787e7c91ebe2eb5adeeb05f251))
+ - add note to explain, related to #96 #101 #6 ([dd8969e0e6ed0bcb9cae905d2b1a96476bd85da3](https://github.com/auth0/node-jsonwebtoken/commit/dd8969e0e6ed0bcb9cae905d2b1a96476bd85da3))
+ - add tests for options.headers ([7787dd74e705787c39a871ca29c75a2e0a3948ac](https://github.com/auth0/node-jsonwebtoken/commit/7787dd74e705787c39a871ca29c75a2e0a3948ac))
+ - add tests for verify expires ([d7c5793d98c300603440ab460c11665f661ad3a0](https://github.com/auth0/node-jsonwebtoken/commit/d7c5793d98c300603440ab460c11665f661ad3a0))
+ - add verify option maxAge (with tests) ([49d54e54f7e70b1c53a2e4ee67e116c907d75319](https://github.com/auth0/node-jsonwebtoken/commit/49d54e54f7e70b1c53a2e4ee67e116c907d75319))
+ - fix spelling error in error message ([8078b11b224fa05ac9003ca5aa2c85e9f0128cfb](https://github.com/auth0/node-jsonwebtoken/commit/8078b11b224fa05ac9003ca5aa2c85e9f0128cfb))
+ - Fix typo options.header is not a documented option + ([5feaa5b962ccbddeff054817a410f7b0c1e6ce7f](https://github.com/auth0/node-jsonwebtoken/commit/5feaa5b962ccbddeff054817a410f7b0c1e6ce7f))
+ - update JWT spec link. closes #112 ([f5fa50f797456a12240589161835c7ea30807195](https://github.com/auth0/node-jsonwebtoken/commit/f5fa50f797456a12240589161835c7ea30807195)), closes [#112](https://github.com/auth0/node-jsonwebtoken/issues/112)
+
+
+## 5.0.3 - 2015-07-15
+
+ - Added nbf support ([f26ba4e2fa197a20497632b63ffcd13ae93aacc4](https://github.com/auth0/node-jsonwebtoken/commit/f26ba4e2fa197a20497632b63ffcd13ae93aacc4))
+ - Added support for subject and jwt id ([ab76ec5bc554e2d1e25376ddb7cea711d86af651](https://github.com/auth0/node-jsonwebtoken/commit/ab76ec5bc554e2d1e25376ddb7cea711d86af651))
+ - Fix `this` referring to the global object instead of `module.exports` in `verify()` ([93f554312e37129027fcf4916f48cb8d1b53588c](https://github.com/auth0/node-jsonwebtoken/commit/93f554312e37129027fcf4916f48cb8d1b53588c))
+ - Fix typo, line 139 README, complete option for .decode. ([59c110aeb8c7c1847ef2ffd77702d13627c89e10](https://github.com/auth0/node-jsonwebtoken/commit/59c110aeb8c7c1847ef2ffd77702d13627c89e10))
+ - minor ([61ff1172272b582902313e958058ff22413494af](https://github.com/auth0/node-jsonwebtoken/commit/61ff1172272b582902313e958058ff22413494af))
+
+
+
+## 5.0.2 - 2015-06-15
+
+
+ - fix typo in docs . closes #86 ([3d3413221f36acef4dfd1cbed87f1f3565cd6f84](https://github.com/auth0/node-jsonwebtoken/commit/3d3413221f36acef4dfd1cbed87f1f3565cd6f84)), closes [#86](https://github.com/auth0/node-jsonwebtoken/issues/86)
+
+
+
+## 5.0.1 - 2015-05-15
+
+
+ - Add option to return header and payload when decoding. ([7254e011b59f892d1947e6c11819281adac7069d](https://github.com/auth0/node-jsonwebtoken/commit/7254e011b59f892d1947e6c11819281adac7069d))
+ - Avoid uncaught "SyntaxError: Unexpected token ͧ" error. ([0dc59cd6ee15d83a606acffa7909ee76176ae186](https://github.com/auth0/node-jsonwebtoken/commit/0dc59cd6ee15d83a606acffa7909ee76176ae186))
+ - Document complete option in README. ([ec32b20241a74d9681ea26e1a7024b4642468c00](https://github.com/auth0/node-jsonwebtoken/commit/ec32b20241a74d9681ea26e1a7024b4642468c00))
+ - Fix example in README, silence verbose logging. ([ba3174d10033c41e9c211a38f1cc67f74fbd7f69](https://github.com/auth0/node-jsonwebtoken/commit/ba3174d10033c41e9c211a38f1cc67f74fbd7f69))
+ - Fix link to auth0.com in README ([1b3c5ff72c9bc25e9271646e679f3080f2a042a0](https://github.com/auth0/node-jsonwebtoken/commit/1b3c5ff72c9bc25e9271646e679f3080f2a042a0))
+ - Immediate return if not decoded. ([851bda2b10168f3269c3da6e74d310742f31a193](https://github.com/auth0/node-jsonwebtoken/commit/851bda2b10168f3269c3da6e74d310742f31a193))
+ - Prevent throw on undefined/null secret ([0fdf78d4dbf609455f3277d6169a987aef0384d4](https://github.com/auth0/node-jsonwebtoken/commit/0fdf78d4dbf609455f3277d6169a987aef0384d4))
+ - Removed path from test ([d6240e24186732d368bffe21143becf44c38f0d6](https://github.com/auth0/node-jsonwebtoken/commit/d6240e24186732d368bffe21143becf44c38f0d6))
+ - Simplified checking for missing key ([f1cffd033bffc44f20558eda4a797c3fa2f4ee05](https://github.com/auth0/node-jsonwebtoken/commit/f1cffd033bffc44f20558eda4a797c3fa2f4ee05))
+ - Typo ([ffe68dbe0219bab535c1018448eb4c0b22f1f902](https://github.com/auth0/node-jsonwebtoken/commit/ffe68dbe0219bab535c1018448eb4c0b22f1f902))
+ - Update CHANGELOG.md ([927cce0dad1bc9aad75aeef53e276cf4cfc0d776](https://github.com/auth0/node-jsonwebtoken/commit/927cce0dad1bc9aad75aeef53e276cf4cfc0d776))
+ - Update CHANGELOG.md ([6879e0fdde222995c70a3a69a4af94993d9c667e](https://github.com/auth0/node-jsonwebtoken/commit/6879e0fdde222995c70a3a69a4af94993d9c667e))
+ - Update CHANGELOG.md ([c5596c10e8705727fa13e0394184a606083078bc](https://github.com/auth0/node-jsonwebtoken/commit/c5596c10e8705727fa13e0394184a606083078bc))
+ - Update CHANGELOG.md ([07541f0315f26d179e1cde92732b6124d6869b6f](https://github.com/auth0/node-jsonwebtoken/commit/07541f0315f26d179e1cde92732b6124d6869b6f))
+ - Update CHANGELOG.md ([e6465d48ddd1dc2c3297229b28c78fd5490a2ba9](https://github.com/auth0/node-jsonwebtoken/commit/e6465d48ddd1dc2c3297229b28c78fd5490a2ba9))
+
+## [5.0.0] - 2015-04-11
+
+### Changed
+
+ - [sign] Only set defautl `iat` if the user does not specify that argument.
+
+  https://github.com/auth0/node-jsonwebtoken/commit/e900282a8d2dff1d4dec815f7e6aa7782e867d91
+  https://github.com/auth0/node-jsonwebtoken/commit/35036b188b4ee6b42df553bbb93bc8a6b19eae9d
+  https://github.com/auth0/node-jsonwebtoken/commit/954bd7a312934f03036b6bb6f00edd41f29e54d9
+  https://github.com/auth0/node-jsonwebtoken/commit/24a370080e0b75f11d4717cd2b11b2949d95fc2e
+  https://github.com/auth0/node-jsonwebtoken/commit/a77df6d49d4ec688dfd0a1cc723586bffe753516
+
+### Security
+
+ - [verify] Update to jws@^3.0.0 and renaming `header.alg` mismatch exception to `invalid algorithm` and adding more mismatch tests.
+
+  As `jws@3.0.0` changed the verify method signature to be `jws.verify(signature, algorithm, secretOrKey)`, the token header must be decoded first in order to make sure that the `alg` field matches one of the allowed `options.algorithms`. After that, the now validated `header.alg` is passed to `jws.verify`
+
+ As the order of steps has changed, the error that was thrown when the JWT was invalid is no longer the `jws` one:
+ ```
+ { [Error: Invalid token: no header in signature 'a.b.c'] code: 'MISSING_HEADER', signature: 'a.b.c' }
+ ```
+
+ That old error (removed from jws) has been replaced by a `JsonWebTokenError` with message `invalid token`.
+
+ > Important: versions >= 4.2.2 this library are safe to use but we decided to deprecate everything `< 5.0.0` to prevent security warnings from library `node-jws` when doing `npm install`.
+
+  https://github.com/auth0/node-jsonwebtoken/commit/634b8ed0ff5267dc25da5c808634208af109824e
+  https://github.com/auth0/node-jsonwebtoken/commit/9f24ffd5791febb449d4d03ff58d7807da9b9b7e
+  https://github.com/auth0/node-jsonwebtoken/commit/19e6cc6a1f2fd90356f89b074223b9665f2aa8a2
+  https://github.com/auth0/node-jsonwebtoken/commit/1e4623420159c6410616f02a44ed240f176287a9
+  https://github.com/auth0/node-jsonwebtoken/commit/954bd7a312934f03036b6bb6f00edd41f29e54d9
+  https://github.com/auth0/node-jsonwebtoken/commit/24a370080e0b75f11d4717cd2b11b2949d95fc2e
+  https://github.com/auth0/node-jsonwebtoken/commit/a77df6d49d4ec688dfd0a1cc723586bffe753516
+
+## [4.2.2] - 2015-03-26
+### Fixed
+
+ - [asymmetric-keys] Fix verify for RSAPublicKey formated keys (`jfromaniello - awlayton`)
+  https://github.com/auth0/node-jsonwebtoken/commit/402794663b9521bf602fcc6f2e811e7d3912f9dc
+  https://github.com/auth0/node-jsonwebtoken/commit/8df6aabbc7e1114c8fb3917931078254eb52c222
+
+## [4.2.1] - 2015-03-17
+### Fixed
+
+ - [asymmetric-keys] Fixed issue when public key starts with BEING PUBLIC KEY (https://github.com/auth0/node-jsonwebtoken/issues/70) (`jfromaniello`)
+  https://github.com/auth0/node-jsonwebtoken/commit/7017e74db9b194448ff488b3e16468ada60c4ee5
+
+## [4.2.0] - 2015-03-16
+### Security
+
+ - [asymmetric-keys] Making sure a token signed with an asymmetric key will be verified using a asymmetric key.
+   When the verification part was expecting a token digitally signed with an asymmetric key (RS/ES family) of algorithms an attacker could send a token signed with a symmetric algorithm (HS* family).
+
+  The issue was caused because the same signature was used to verify both type of tokens (`verify` method parameter: `secretOrPublicKey`).
+
+  This change adds a new parameter to the verify called `algorithms`. This can be used to specify a list of supported algorithms, but the default value depends on the secret used: if the secretOrPublicKey contains the string `BEGIN CERTIFICATE` the default is `[ 'RS256','RS384','RS512','ES256','ES384','ES512' ]` otherwise is `[ 'HS256','HS384','HS512' ]`. (`jfromaniello`)
+  https://github.com/auth0/node-jsonwebtoken/commit/c2bf7b2cd7e8daf66298c2d168a008690bc4bdd3
+  https://github.com/auth0/node-jsonwebtoken/commit/1bb584bc382295eeb7ee8c4452a673a77a68b687
+
+## [4.1.0] - 2015-03-10
+### Changed
+- Assume the payload is JSON even when there is no `typ` property. [5290db1](https://github.com/auth0/node-jsonwebtoken/commit/5290db1bd74f74cd38c90b19e2355ef223a4d931)
+
+## [4.0.0] - 2015-03-06
+### Changed
+- The default encoding is now utf8 instead of binary. [92d33bd](https://github.com/auth0/node-jsonwebtoken/commit/92d33bd99a3416e9e5a8897d9ad8ff7d70a00bfd)
+- Add `encoding` as a new option to `sign`. [1fc385e](https://github.com/auth0/node-jsonwebtoken/commit/1fc385ee10bd0018cd1441552dce6c2e5a16375f)
+- Add `ignoreExpiration` to `verify`. [8d4da27](https://github.com/auth0/node-jsonwebtoken/commit/8d4da279e1b351ac71ace276285c9255186d549f)
+- Add `expiresInSeconds` to `sign`. [dd156cc](https://github.com/auth0/node-jsonwebtoken/commit/dd156cc30f17028744e60aec0502897e34609329)
+
+### Fixed
+- Fix wrong error message when the audience doesn't match. [44e3c8d](https://github.com/auth0/node-jsonwebtoken/commit/44e3c8d757e6b4e2a57a69a035f26b4abec3e327)
+- Fix wrong error message when the issuer doesn't match. [44e3c8d](https://github.com/auth0/node-jsonwebtoken/commit/44e3c8d757e6b4e2a57a69a035f26b4abec3e327)
+- Fix wrong `iat` and `exp` values when signing with `noTimestamp`. [331b7bc](https://github.com/auth0/node-jsonwebtoken/commit/331b7bc9cc335561f8806f2c4558e105cb53e0a6)

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+ 
+Copyright (c) 2015 Auth0, Inc. <support@auth0.com> (http://auth0.com)
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

@@ -0,0 +1,260 @@
+# jsonwebtoken [![Build Status](https://secure.travis-ci.org/auth0/node-jsonwebtoken.svg?branch=master)](http://travis-ci.org/auth0/node-jsonwebtoken)[![Dependency Status](https://david-dm.org/auth0/node-jsonwebtoken.svg)](https://david-dm.org/auth0/node-jsonwebtoken)
+
+
+An implementation of [JSON Web Tokens](https://tools.ietf.org/html/rfc7519).
+
+This was developed against `draft-ietf-oauth-json-web-token-08`. It makes use of [node-jws](https://github.com/brianloveswords/node-jws)
+
+# Install
+
+```bash
+$ npm install jsonwebtoken
+```
+
+# Usage
+
+### jwt.sign(payload, secretOrPrivateKey, options, [callback])
+
+(Asynchronous) If a callback is supplied, callback is called with the `err` or the JWT.
+
+(Synchronous) Returns the JsonWebToken as string
+
+`payload` could be an object literal, buffer or string. *Please note that* `exp` is only set if the payload is an object literal.
+
+`secretOrPrivateKey` is a string or buffer containing either the secret for HMAC algorithms, or the PEM
+encoded private key for RSA and ECDSA.
+
+`options`:
+
+* `algorithm` (default: `HS256`)
+* `expiresIn`: expressed in seconds or a string describing a time span [rauchg/ms](https://github.com/rauchg/ms.js). Eg: `60`, `"2 days"`, `"10h"`, `"7d"`
+* `notBefore`: expressed in seconds or a string describing a time span [rauchg/ms](https://github.com/rauchg/ms.js). Eg: `60`, `"2 days"`, `"10h"`, `"7d"`
+* `audience`
+* `issuer`
+* `jwtid`
+* `subject`
+* `noTimestamp`
+* `header`
+
+If `payload` is not a buffer or a string, it will be coerced into a string using `JSON.stringify`.
+
+There are no default values for `expiresIn`, `notBefore`, `audience`, `subject`, `issuer`. These claims can also be provided in the payload directly with `exp`, `nbf`, `aud` and `sub` respectively, but you can't include in both places.
+
+
+The header can be customized via the `option.header` object.
+
+Generated jwts will include an `iat` (issued at) claim by default unless `noTimestamp` is specified. If `iat` is inserted in the payload, it will be used instead of the real timestamp for calculating other things like `exp` given a timespan in `options.expiresIn`.
+
+Example
+
+```js
+// sign with default (HMAC SHA256)
+var jwt = require('jsonwebtoken');
+var token = jwt.sign({ foo: 'bar' }, 'shhhhh');
+//backdate a jwt 30 seconds
+var older_token = jwt.sign({ foo: 'bar', iat: Math.floor(Date.now() / 1000) - 30 }, 'shhhhh');
+
+// sign with RSA SHA256
+var cert = fs.readFileSync('private.key');  // get private key
+var token = jwt.sign({ foo: 'bar' }, cert, { algorithm: 'RS256'});
+
+// sign asynchronously
+jwt.sign({ foo: 'bar' }, cert, { algorithm: 'RS256' }, function(err, token) {
+  console.log(token);
+});
+```
+
+### jwt.verify(token, secretOrPublicKey, [options, callback])
+
+(Asynchronous) If a callback is supplied, function acts asynchronously. Callback passed the payload decoded if the signature (and optionally expiration, audience, issuer) are valid. If not, it will be passed the error.
+
+(Synchronous) If a callback is not supplied, function acts synchronously. Returns the payload decoded if the signature (and optionally expiration, audience, issuer) are valid. If not, it will throw the error.
+
+`token` is the JsonWebToken string
+
+`secretOrPublicKey` is a string or buffer containing either the secret for HMAC algorithms, or the PEM
+encoded public key for RSA and ECDSA.
+
+`options`
+
+* `algorithms`: List of strings with the names of the allowed algorithms. For instance, `["HS256", "HS384"]`.
+* `audience`: if you want to check audience (`aud`), provide a value here
+* `issuer` (optional): string or array of strings of valid values for the `iss` field.
+* `ignoreExpiration`: if `true` do not validate the expiration of the token.
+* `ignoreNotBefore`...
+* `subject`: if you want to check subject (`sub`), provide a value here
+* `clockTolerance`: number of second to tolerate when checking the `nbf` and `exp` claims, to deal with small clock differences among different servers
+
+
+```js
+// verify a token symmetric - synchronous
+var decoded = jwt.verify(token, 'shhhhh');
+console.log(decoded.foo) // bar
+
+// verify a token symmetric
+jwt.verify(token, 'shhhhh', function(err, decoded) {
+  console.log(decoded.foo) // bar
+});
+
+// invalid token - synchronous
+try {
+  var decoded = jwt.verify(token, 'wrong-secret');
+} catch(err) {
+  // err
+}
+
+// invalid token
+jwt.verify(token, 'wrong-secret', function(err, decoded) {
+  // err
+  // decoded undefined
+});
+
+// verify a token asymmetric
+var cert = fs.readFileSync('public.pem');  // get public key
+jwt.verify(token, cert, function(err, decoded) {
+  console.log(decoded.foo) // bar
+});
+
+// verify audience
+var cert = fs.readFileSync('public.pem');  // get public key
+jwt.verify(token, cert, { audience: 'urn:foo' }, function(err, decoded) {
+  // if audience mismatch, err == invalid audience
+});
+
+// verify issuer
+var cert = fs.readFileSync('public.pem');  // get public key
+jwt.verify(token, cert, { audience: 'urn:foo', issuer: 'urn:issuer' }, function(err, decoded) {
+  // if issuer mismatch, err == invalid issuer
+});
+
+// verify jwt id
+var cert = fs.readFileSync('public.pem');  // get public key
+jwt.verify(token, cert, { audience: 'urn:foo', issuer: 'urn:issuer', jwtid: 'jwtid' }, function(err, decoded) {
+  // if jwt id mismatch, err == invalid jwt id
+});
+
+// verify subject
+var cert = fs.readFileSync('public.pem');  // get public key
+jwt.verify(token, cert, { audience: 'urn:foo', issuer: 'urn:issuer', jwtid: 'jwtid', subject: 'subject' }, function(err, decoded) {
+  // if subject mismatch, err == invalid subject
+});
+
+// alg mismatch
+var cert = fs.readFileSync('public.pem'); // get public key
+jwt.verify(token, cert, { algorithms: ['RS256'] }, function (err, payload) {
+  // if token alg != RS256,  err == invalid signature
+});
+
+```
+
+### jwt.decode(token [, options])
+
+(Synchronous) Returns the decoded payload without verifying if the signature is valid.
+
+__Warning:__ This will __not__ verify whether the signature is valid. You should __not__ use this for untrusted messages. You most likely want to use `jwt.verify` instead.
+
+`token` is the JsonWebToken string
+
+`options`:
+
+* `json`: force JSON.parse on the payload even if the header doesn't contain `"typ":"JWT"`.
+* `complete`: return an object with the decoded payload and header.
+
+Example
+
+```js
+// get the decoded payload ignoring signature, no secretOrPrivateKey needed
+var decoded = jwt.decode(token);
+
+// get the decoded payload and header
+var decoded = jwt.decode(token, {complete: true});
+console.log(decoded.header);
+console.log(decoded.payload)
+```
+
+## Errors & Codes
+Possible thrown errors during verification.
+Error is the first argument of the verification callback.
+
+### TokenExpiredError
+
+Thrown error if the token is expired.
+
+Error object:
+
+* name: 'TokenExpiredError'
+* message: 'jwt expired'
+* expiredAt: [ExpDate]
+
+```js
+jwt.verify(token, 'shhhhh', function(err, decoded) {
+  if (err) {
+    /*
+      err = {
+        name: 'TokenExpiredError',
+        message: 'jwt expired',
+        expiredAt: 1408621000
+      }
+    */
+  }
+});
+```
+
+### JsonWebTokenError
+Error object:
+
+* name: 'JsonWebTokenError'
+* message:
+  * 'jwt malformed'
+  * 'jwt signature is required'
+  * 'invalid signature'
+  * 'jwt audience invalid. expected: [OPTIONS AUDIENCE]'
+  * 'jwt issuer invalid. expected: [OPTIONS ISSUER]'
+  * 'jwt id invalid. expected: [OPTIONS JWT ID]'
+  * 'jwt subject invalid. expected: [OPTIONS SUBJECT]'
+
+```js
+jwt.verify(token, 'shhhhh', function(err, decoded) {
+  if (err) {
+    /*
+      err = {
+        name: 'JsonWebTokenError',
+        message: 'jwt malformed'
+      }
+    */
+  }
+});
+```
+
+## Algorithms supported
+
+Array of supported algorithms. The following algorithms are currently supported.
+
+alg Parameter Value | Digital Signature or MAC Algorithm
+----------------|----------------------------
+HS256 | HMAC using SHA-256 hash algorithm
+HS384 | HMAC using SHA-384 hash algorithm
+HS512 | HMAC using SHA-512 hash algorithm
+RS256 | RSASSA using SHA-256 hash algorithm
+RS384 | RSASSA using SHA-384 hash algorithm
+RS512 | RSASSA using SHA-512 hash algorithm
+ES256 | ECDSA using P-256 curve and SHA-256 hash algorithm
+ES384 | ECDSA using P-384 curve and SHA-384 hash algorithm
+ES512 | ECDSA using P-521 curve and SHA-512 hash algorithm
+none | No digital signature or MAC value included
+
+# TODO
+
+* X.509 certificate chain is not checked
+
+## Issue Reporting
+
+If you have found a bug or if you have a feature request, please report them at this repository issues section. Please do not report security vulnerabilities on the public GitHub issue tracker. The [Responsible Disclosure Program](https://auth0.com/whitehat) details the procedure for disclosing security issues.
+
+## Author
+
+[Auth0](https://auth0.com)
+
+## License
+
+This project is licensed under the MIT license. See the [LICENSE](LICENSE) file for more info.

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+var changelog = require('conventional-changelog');
+var semver_regex = /\bv?(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)(?:-[\da-z\-]+(?:\.[\da-z\-]+)*)?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?\b/ig;
+
+const commitPartial = ` - {{header}}
+
+{{~!-- commit hash --}} {{#if @root.linkReferences}}([{{hash}}]({{#if @root.host}}{{@root.host}}/{{/if}}{{#if @root.owner}}{{@root.owner}}/{{/if}}{{@root.repository}}/{{@root.commit}}/{{hash}})){{else}}{{hash~}}{{/if}}
+
+{{~!-- commit references --}}{{#if references}}, closes{{~#each references}} {{#if @root.linkReferences}}[{{#if this.owner}}{{this.owner}}/{{/if}}{{this.repository}}#{{this.issue}}]({{#if @root.host}}{{@root.host}}/{{/if}}{{#if this.repository}}{{#if this.owner}}{{this.owner}}/{{/if}}{{this.repository}}{{else}}{{#if @root.owner}}{{@root.owner}}/{{/if}}{{@root.repository}}{{/if}}/{{@root.issue}}/{{this.issue}}){{else}}{{#if this.owner}}{{this.owner}}/{{/if}}{{this.repository}}#{{this.issue}}{{/if}}{{/each}}{{/if}}
+`;
+
+const headerPartial = `## {{version}}{{#if title}} "{{title}}"{{/if}}{{#if date}} - {{date}}{{/if}}
+`;
+
+changelog({
+  releaseCount: 19,
+  // preset: 'jshint'
+}, null, null, null, {
+  transform: function (commit) {
+    if (commit.header && semver_regex.exec(commit.header)) {
+      return null;
+    }
+    return commit;
+  },
+  commitPartial: commitPartial,
+  headerPartial: headerPartial
+}).pipe(process.stdout);

@@ -0,0 +1,30 @@
+var jws = require('jws');
+
+module.exports = function (jwt, options) {
+  options = options || {};
+  var decoded = jws.decode(jwt, options);
+  if (!decoded) { return null; }
+  var payload = decoded.payload;
+
+  //try parse the payload
+  if(typeof payload === 'string') {
+    try {
+      var obj = JSON.parse(payload);
+      if(typeof obj === 'object') {
+        payload = obj;
+      }
+    } catch (e) { }
+  }
+
+  //return header if `complete` option is enabled.  header includes claims
+  //such as `kid` and `alg` used to select the key within a JWKS needed to
+  //verify the signature
+  if (options.complete === true) {
+    return {
+      header: decoded.header,
+      payload: payload,
+      signature: decoded.signature
+    };
+  }
+  return payload;
+};

@@ -0,0 +1,8 @@
+module.exports = {
+  decode: require('./decode'),
+  verify: require('./verify'),
+  sign: require('./sign'),
+  JsonWebTokenError: require('./lib/JsonWebTokenError'),
+  NotBeforeError: require('./lib/NotBeforeError'),
+  TokenExpiredError: require('./lib/TokenExpiredError'),
+};

@@ -0,0 +1,12 @@
+var JsonWebTokenError = function (message, error) {
+  Error.call(this, message);
+  Error.captureStackTrace(this, this.constructor);
+  this.name = 'JsonWebTokenError';
+  this.message = message;
+  if (error) this.inner = error;
+};
+
+JsonWebTokenError.prototype = Object.create(Error.prototype);
+JsonWebTokenError.prototype.constructor = JsonWebTokenError;
+
+module.exports = JsonWebTokenError;

@@ -0,0 +1,13 @@
+var JsonWebTokenError = require('./JsonWebTokenError');
+
+var NotBeforeError = function (message, date) {
+  JsonWebTokenError.call(this, message);
+  this.name = 'NotBeforeError';
+  this.date = date;
+};
+
+NotBeforeError.prototype = Object.create(JsonWebTokenError.prototype);
+
+NotBeforeError.prototype.constructor = NotBeforeError;
+
+module.exports = NotBeforeError;

@@ -0,0 +1,13 @@
+var JsonWebTokenError = require('./JsonWebTokenError');
+
+var TokenExpiredError = function (message, expiredAt) {
+  JsonWebTokenError.call(this, message);
+  this.name = 'TokenExpiredError';
+  this.expiredAt = expiredAt;
+};
+
+TokenExpiredError.prototype = Object.create(JsonWebTokenError.prototype);
+
+TokenExpiredError.prototype.constructor = TokenExpiredError;
+
+module.exports = TokenExpiredError;

@@ -0,0 +1,18 @@
+var ms = require('ms');
+
+module.exports = function (time, iat) {
+  var timestamp = iat || Math.floor(Date.now() / 1000);
+
+  if (typeof time === 'string') {
+    var milliseconds = ms(time);
+    if (typeof milliseconds === 'undefined') {
+      return;
+    }
+    return Math.floor(timestamp + milliseconds / 1000);
+  } else if (typeof time === 'number') {
+    return timestamp + time;
+  } else {
+    return;
+  }
+
+};

@@ -0,0 +1,2 @@
+*.DS_Store
+node_modules

@@ -0,0 +1,6 @@
+.PHONY: test
+
+MOCHA = ./node_modules/mocha/bin/mocha
+
+test:
+	$(MOCHA) -R list

@@ -0,0 +1,95 @@
+# cb()
+
+A minimal node.js utility for handling common (but often overlooked) callback scenarios.
+
+##Features
+
+  * `.timeout()`: Simple callback timeouts
+  * `.error()`: Explicit error handling
+  * `.once()`: Once-and-only-once callback semantics
+  *  Guaranteed asynchronous callback execution (protects against code that breaks this assumption)
+
+## Installation
+
+    $ npm install cb
+
+## Usage
+
+### Basic Usage
+
+The most basic usage of `cb` consists of passing in your own function reference. In this example, `cb` will do nothing other
+than insure the once-and-only-once, asynchronous invocation of the callback.
+
+    doAsync(cb(function(err, res) {
+        console.log(res);
+    }));
+
+### Timeout Handling
+
+Timeouts are specified through the `.timeout()` method, and are specified in milliseconds.  If a timeout does occur, the error
+passed to the callback will be an instance of `cb.TimeoutError`.
+
+    doReallySlowAsync(cb(function(err, res) {
+        assert(err instanceof cb.TimeoutError);
+    }).timeout(50));
+
+*Note: once a timeout has occured, any tardy attempts to invoke the callback will be ignored.*
+
+### Explicit Error Handling
+
+In situations where it is convenient to separate the code that runs on success or failure, this can easily be accomplished
+with `.error()`.  If an 'errback' handler has been provided to `.error()`, then it is assumed that the error-first parameter
+to the success handler is no longer required.  To illustrate,
+
+    doAsync(cb(function(err, res) {
+        if (err) {
+            console.error(err);
+        } else {
+            console.log(res);
+        }
+    }));
+
+Can be rewritten as:
+
+    doAsync(cb(console.log).error(console.error));
+
+### Force Once-and-only-once Callback Execution
+
+Sometimes it's necessary to ensure that a callback is invoked once, and no more. Once-and-only-once execution semantics can be
+enforced by using `.once()`.
+
+    function runTwice(callback) {
+        process.nextTick(function() {
+           callback();
+           callback(); 
+        }); 
+    }
+
+    runTwice(cb(function() {
+        console.log('I will only run once');
+    }).once());
+
+*Note: technically, `.once()` simply enforces at-most-once semantics. However, when combined with `.timeout()`, once-and-only-once
+is achieved.*
+
+### Combining Features
+
+The `cb` API is fully chainable, and any arrangement of the features is valid.  For example:
+
+    doAsync(cb(console.log).error(console.error).timeout(50).once());
+
+## Running the Tests
+
+    $ make test
+
+## License 
+
+The MIT License (MIT)
+
+Copyright (c) 2012 Jeremy Martin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

@@ -0,0 +1,39 @@
+module.exports = function(callback) {
+
+	var cb = function() {
+		if (timedout || (once && count)) return;
+		count += 1;
+		tid && clearTimeout(tid);
+
+		var args = Array.prototype.slice.call(arguments);
+		process.nextTick(function() {
+			if (!errback) return callback.apply(this, args);
+			args[0] ? errback(args[0]) : callback.apply(this, args.slice(1));
+		});
+
+	}, count = 0, once = false, timedout = false, errback, tid;
+
+	cb.timeout = function(ms) {
+		tid && clearTimeout(tid);
+		tid = setTimeout(function() {
+			cb(new TimeoutError(ms));
+			timedout = true;
+		}, ms);
+		return cb;
+	};
+
+	cb.error = function(func) { errback = func; return cb; };
+
+	cb.once = function() { once = true; return cb; };
+
+	return cb;
+
+};
+
+var TimeoutError = module.exports.TimeoutError = function TimeoutError(ms) {
+	this.message = 'Specified timeout of ' + ms + 'ms was reached';
+	Error.captureStackTrace(this, this.constructor);
+};
+TimeoutError.prototype = new Error;
+TimeoutError.prototype.constructor = TimeoutError;
+TimeoutError.prototype.name = 'TimeoutError';

@@ -0,0 +1,46 @@
+{
+  "author": {
+    "name": "Jeremy Martin",
+    "email": "jmar777@gmail.com",
+    "url": "http://twitter.com/jmar777"
+  },
+  "name": "cb",
+  "description": "Super simple callback mechanism with support for timeouts and explicit error handling",
+  "version": "0.1.0",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jmar777/cb.git"
+  },
+  "main": "lib/cb.js",
+  "devDependencies": {
+    "mocha": ">=0.3.6"
+  },
+  "engines": {
+    "node": ">=0.6.0"
+  },
+  "_npmUser": {
+    "name": "jmar777",
+    "email": "jmar777@gmail.com"
+  },
+  "_id": "cb@0.1.0",
+  "dependencies": {},
+  "optionalDependencies": {},
+  "_engineSupported": true,
+  "_npmVersion": "1.1.0-2",
+  "_nodeVersion": "v0.6.8",
+  "_defaultsLoaded": true,
+  "dist": {
+    "shasum": "26f7e740f2808facc83cef7b20392e4d881b5203",
+    "tarball": "https://registry.npmjs.org/cb/-/cb-0.1.0.tgz"
+  },
+  "maintainers": [
+    {
+      "name": "jmar777",
+      "email": "jmar777@gmail.com"
+    }
+  ],
+  "directories": {},
+  "_shasum": "26f7e740f2808facc83cef7b20392e4d881b5203",
+  "_resolved": "https://registry.npmjs.org/cb/-/cb-0.1.0.tgz",
+  "_from": "cb@>=0.1.0 <0.2.0"
+}

@@ -0,0 +1,125 @@
+var assert = require('assert'),
+	cb = require('../');
+
+function invokeAsync(callback) {
+	setTimeout(function() {
+		callback(null, 'foo');
+	}, 100);
+}
+
+function invokeAsyncError(callback) {
+	setTimeout(function() {
+		callback(new Error());
+	}, 100);
+}
+
+function invokeAsyncTwice(callback) {
+	setTimeout(function() {
+		callback(null, 'foo');
+		callback(null, 'foo');
+	}, 100);
+}
+
+describe('cb(callback)', function() {
+
+	it('should invoke the provided callback', function(done) {
+		invokeAsync(cb(function(err, res) {
+			assert.strictEqual(res, 'foo');
+			done();
+		}));
+	});
+
+	it('shouldn\'t mess with errors', function(done) {
+		invokeAsyncError(cb(function(err, res) {
+			assert(err);
+			done();
+		}));
+	});
+
+	it('should allow multiple executions', function(done) {
+		var count = 0;
+		invokeAsyncTwice(cb(function(err, res) {
+			count++;
+			if (count === 2) done();
+		}));
+	});
+
+});
+
+describe('cb(callback).timeout(ms)', function() {
+	
+	it('should complete successfully within timeout period', function(done) {
+		invokeAsync(cb(function(err, res) {
+			assert.strictEqual(res, 'foo');
+			done();
+		}).timeout(200));
+	});
+
+	it('should complete with an error after timeout period', function(done) {
+		invokeAsync(cb(function(err, res) {
+			assert(err);
+			done();
+		}).timeout(50));
+	});
+
+	it('error resulting from a timeout should be instanceof cb.TimeoutError', function(done) {
+		invokeAsync(cb(function(err, res) {
+			assert(err instanceof cb.TimeoutError);
+			done();
+		}).timeout(50));
+	});
+
+});
+
+describe('cb(callback).error(errback)', function() {
+
+	it('should skip the err argument when invoking callback', function(done) {
+		invokeAsync(cb(function(res) {
+			assert.strictEqual(res, 'foo');
+			done();
+		}).error(assert.ifError));
+	});
+
+	it('should pass errors to provided errback', function(done) {
+		invokeAsyncError(cb(function(res) {
+			throw new Error('should not be invoked');
+		}).error(function(err) {
+			assert(err);
+			done();
+		}));
+	});
+
+});
+
+describe('cb(callback).error(errback).timeout(ms)', function() {
+
+	it('should skip the err argument when invoking callback', function(done) {
+		invokeAsync(cb(function(res) {
+			assert.strictEqual(res, 'foo');
+			done();
+		}).error(assert.ifError).timeout(200));
+	});
+
+	it('should pass timeout error to provided errback', function(done) {
+		invokeAsyncError(cb(function(res) {
+			throw new Error('should not be invoked');
+		}).error(function(err) {
+			assert(err);
+			done();
+		}).timeout(50));
+	});
+
+});
+
+describe('cb(callback).once()', function() {
+
+	it('should allow multiple executions', function(done) {
+		var count = 0;
+		invokeAsyncTwice(cb(function(err, res) {
+			count++;
+			assert.notEqual(count, 2);
+			setTimeout(done, 100);
+		}).once());
+	});
+
+});

@@ -0,0 +1,2 @@
+examples
+sandbox.js

@@ -0,0 +1,21 @@
+.c9
+.idea
+.project
+*.iml
+npm-debug.log
+dump.rdb
+node_modules
+results.tap
+results.xml
+npm-shrinkwrap.json
+config.json
+.DS_Store
+*/.DS_Store
+*/*/.DS_Store
+._*
+*/._*
+*/*/._*
+coverage.*
+lib-cov
+complexity.md
+sandbox.js

@@ -0,0 +1,9 @@
+language: node_js
+
+node_js:
+  - "0.10"
+  - "4.0"
+  - "4"
+  - "5"
+
+sudo: false

@@ -0,0 +1,1515 @@
+<!-- version -->
+# 6.10.1 API Reference
+<!-- versionstop -->
+
+<img src="https://raw.github.com/hapijs/joi/master/images/validation.png" align="right" />
+
+<!-- toc -->
+
+- [Joi](#joi)
+  - [`validate(value, schema, [options], [callback])`](#validatevalue-schema-options-callback)
+  - [`compile(schema)`](#compileschema)
+  - [`assert(value, schema, [message])`](#assertvalue-schema-message)
+  - [`attempt(value, schema, [message])`](#attemptvalue-schema-message)
+  - [`isRef(ref)`](#isrefref)
+  - [`any`](#any)
+    - [`any.allow(value)`](#anyallowvalue)
+    - [`any.valid(value)` - aliases: `only`, `equal`](#anyvalidvalue---aliases-only-equal)
+    - [`any.invalid(value)` - aliases: `disallow`, `not`](#anyinvalidvalue---aliases-disallow-not)
+    - [`any.required()`](#anyrequired)
+    - [`any.optional()`](#anyoptional)
+    - [`any.forbidden()`](#anyforbidden)
+    - [`any.strip()`](#anystrip)
+    - [`any.description(desc)`](#anydescriptiondesc)
+    - [`any.notes(notes)`](#anynotesnotes)
+    - [`any.tags(tags)`](#anytagstags)
+    - [`any.meta(meta)`](#anymetameta)
+    - [`any.example(value)`](#anyexamplevalue)
+    - [`any.unit(name)`](#anyunitname)
+    - [`any.options(options)`](#anyoptionsoptions)
+    - [`any.strict(isStrict)`](#anystrictisstrict)
+    - [`any.default([value, [description]])`](#anydefaultvalue-description)
+    - [`any.concat(schema)`](#anyconcatschema)
+    - [`any.when(ref, options)`](#anywhenref-options)
+    - [`any.label(name)`](#anylabelname)
+    - [`any.raw(isRaw)`](#anyrawisraw)
+    - [`any.empty(schema)`](#anyemptyschema)
+  - [`array`](#array)
+    - [`array.sparse(enabled)`](#arraysparseenabled)
+    - [`array.single(enabled)`](#arraysingleenabled)
+    - [`array.items(type)`](#arrayitemstype)
+    - [`array.ordered(type)`](#arrayorderedtype)
+    - [`array.min(limit)`](#arrayminlimit)
+    - [`array.max(limit)`](#arraymaxlimit)
+    - [`array.length(limit)`](#arraylengthlimit)
+    - [`array.unique()`](#arrayunique)
+  - [`boolean`](#boolean)
+  - [`binary`](#binary)
+    - [`binary.encoding(encoding)`](#binaryencodingencoding)
+    - [`binary.min(limit)`](#binaryminlimit)
+    - [`binary.max(limit)`](#binarymaxlimit)
+    - [`binary.length(limit)`](#binarylengthlimit)
+  - [`date`](#date)
+    - [`date.min(date)`](#datemindate)
+    - [`date.max(date)`](#datemaxdate)
+    - [`date.format(format)`](#dateformatformat)
+    - [`date.iso()`](#dateiso)
+  - [`func`](#func)
+  - [`number`](#number)
+    - [`number.min(limit)`](#numberminlimit)
+    - [`number.max(limit)`](#numbermaxlimit)
+    - [`number.greater(limit)`](#numbergreaterlimit)
+    - [`number.less(limit)`](#numberlesslimit)
+    - [`number.integer()`](#numberinteger)
+    - [`number.precision(limit)`](#numberprecisionlimit)
+    - [`number.multiple(base)`](#numbermultiplebase)
+    - [`number.positive()`](#numberpositive)
+    - [`number.negative()`](#numbernegative)
+  - [`object`](#object)
+    - [`object.keys([schema])`](#objectkeysschema)
+      - [`{} notation`](#-notation)
+      - [`Joi.object([schema]) notation`](#joiobjectschema-notation)
+      - [`Joi.object().keys([schema]) notation`](#joiobjectkeysschema-notation)
+    - [`object.min(limit)`](#objectminlimit)
+    - [`object.max(limit)`](#objectmaxlimit)
+    - [`object.length(limit)`](#objectlengthlimit)
+    - [`object.pattern(regex, schema)`](#objectpatternregex-schema)
+    - [`object.and(peers)`](#objectandpeers)
+    - [`object.nand(peers)`](#objectnandpeers)
+    - [`object.or(peers)`](#objectorpeers)
+    - [`object.xor(peers)`](#objectxorpeers)
+    - [`object.with(key, peers)`](#objectwithkey-peers)
+    - [`object.without(key, peers)`](#objectwithoutkey-peers)
+    - [`object.rename(from, to, [options])`](#objectrenamefrom-to-options)
+    - [`object.assert(ref, schema, [message])`](#objectassertref-schema-message)
+    - [`object.unknown([allow])`](#objectunknownallow)
+    - [`object.type(constructor, [name])`](#objecttypeconstructor-name)
+    - [`object.requiredKeys(children)`](#objectrequiredkeyschildren)
+    - [`object.optionalKeys(children)`](#objectoptionalkeyschildren)
+  - [`string`](#string)
+    - [`string.insensitive()`](#stringinsensitive)
+    - [`string.min(limit, [encoding])`](#stringminlimit-encoding)
+    - [`string.max(limit, [encoding])`](#stringmaxlimit-encoding)
+    - [`string.creditCard()`](#stringcreditcard)
+    - [`string.length(limit, [encoding])`](#stringlengthlimit-encoding)
+    - [`string.regex(pattern, [name])`](#stringregexpattern-name)
+    - [`string.replace(pattern, replacement)`](#stringreplacepattern-replacement)
+    - [`string.alphanum()`](#stringalphanum)
+    - [`string.token()`](#stringtoken)
+    - [`string.email([options])`](#stringemailoptions)
+    - [`string.ip([options])`](#stringipoptions)
+    - [`string.uri([options])`](#stringurioptions)
+    - [`string.guid()`](#stringguid)
+    - [`string.hex()`](#stringhex)
+    - [`string.hostname()`](#stringhostname)
+    - [`string.lowercase()`](#stringlowercase)
+    - [`string.uppercase()`](#stringuppercase)
+    - [`string.trim()`](#stringtrim)
+    - [`string.isoDate()`](#stringisodate)
+  - [`alternatives`](#alternatives)
+    - [`alternatives.try(schemas)`](#alternativestryschemas)
+    - [`alternatives.when(ref, options)`](#alternativeswhenref-options)
+  - [`ref(key, [options])`](#refkey-options)
+- [Errors](#errors)
+
+<!-- tocstop -->
+
+## Joi
+
+### `validate(value, schema, [options], [callback])`
+
+Validates a value using the given schema and options where:
+- `value` - the value being validated.
+- `schema` - the validation schema. Can be a **joi** type object or a plain object where every key is assigned a **joi** type object.
+- `options` - an optional object with the following optional keys:
+  - `abortEarly` - when `true`, stops validation on the first error, otherwise returns all the errors found. Defaults to `true`.
+  - `convert` - when `true`, attempts to cast values to the required types (e.g. a string to a number). Defaults to `true`.
+  - `allowUnknown` - when `true`, allows object to contain unknown keys which are ignored. Defaults to `false`.
+  - `skipFunctions` - when `true`, ignores unknown keys with a function value. Defaults to `false`.
+  - `stripUnknown` - when `true`, unknown keys are deleted (only when value is an object or an array). Defaults to `false`.
+  - `language` - overrides individual error messages, when `'label'` is set, it overrides the key name in the error message. Defaults to no override (`{}`).
+  - `presence` - sets the default presence requirements. Supported modes: `'optional'`, `'required'`, and `'forbidden'`.
+    Defaults to `'optional'`.
+  - `context` - provides an external data set to be used in [references](#refkey-options). Can only be set as an external option to
+    `validate()` and not using `any.options()`.
+  - `noDefaults` - when `true`, do not apply default values. Defaults to `false`.
+- `callback` - the optional synchronous callback method using the signature `function(err, value)` where:
+  - `err` - if validation failed, the [error](#errors) reason, otherwise `null`.
+  - `value` - the validated value with any type conversions and other modifiers applied (the input is left unchanged). `value` can be
+    incomplete if validation failed and `abortEarly` is `true`. If callback is not provided, then returns an object with [error](#errors)
+    and value properties.
+
+```javascript
+var schema = {
+    a: Joi.number()
+};
+
+var value = {
+    a: '123'
+};
+
+Joi.validate(value, schema, function (err, value) { });
+// err -> null
+// value.a -> 123 (number, not string)
+
+// or
+var result = Joi.validate(value, schema);
+// result.error -> null
+// result.value -> { "a" : 123 }
+```
+
+### `compile(schema)`
+
+Converts literal schema definition to **joi** schema object (or returns the same back if already a **joi** schema object) where:
+- `schema` - the schema definition to compile.
+
+```javascript
+var definition = ['key', 5, { a: true, b: [/^a/, 'boom'] }];
+var schema = Joi.compile(definition);
+
+// Same as:
+
+var schema = Joi.alternatives().try([
+    Joi.string().valid('key'),
+    Joi.number().valid(5),
+    Joi.object().keys({
+        a: Joi.boolean().valid(true),
+        b: Joi.alternatives().try([
+            Joi.string().regex(/^a/),
+            Joi.string().valid('boom')
+        ])
+    })
+]);
+```
+
+### `assert(value, schema, [message])`
+
+Validates a value against a schema and [throws](#errors) if validation fails where:
+- `value` - the value to validate.
+- `schema` - the schema object.
+- `message` - optional message string prefix added in front of the error message. may also be an Error object.
+
+```javascript
+Joi.assert('x', Joi.number());
+```
+
+### `attempt(value, schema, [message])`
+
+Validates a value against a schema, returns valid object, and [throws](#errors) if validation fails where:
+- `value` - the value to validate.
+- `schema` - the schema object.
+- `message` - optional message string prefix added in front of the error message. may also be an Error object.
+
+```javascript
+Joi.attempt('x', Joi.number()); // throws error
+var result = Joi.attempt('4', Joi.number()); // result -> 4
+```
+
+### `isRef(ref)`
+
+Checks whether or not the provided argument is a reference.
+It's especially useful if you want to post-process error messages.
+
+```js
+var ref = Joi.ref('a');
+Joi.isRef(ref); // returns true
+```
+
+### `any`
+
+Generates a schema object that matches any data type.
+
+```javascript
+var any = Joi.any();
+any.validate('a', function (err, value) { });
+```
+
+#### `any.allow(value)`
+
+Whitelists a value where:
+- `value` - the allowed value which can be of any type and will be matched against the validated value before applying any other rules.
+  `value` can be an array of values, or multiple values can be passed as individual arguments. `value` supports [references](#refkey-options).
+
+Note that this whitelist of allowed values is in *addition* to any other permitted values.
+To create an exclusive whitelist of values, see [`any.valid(value)`](#anyvalidvalue).
+
+```javascript
+var schema = {
+    a: Joi.any().allow('a'),
+    b: Joi.any().allow('b', 'B'),
+    c: Joi.any().allow(['c', 'C'])
+};
+```
+
+#### `any.valid(value)` - aliases: `only`, `equal`
+
+Adds the provided values into the allowed whitelist and marks them as the only valid values allowed where:
+- `value` - the allowed value which can be of any type and will be matched against the validated value before applying any other rules.
+  `value` can be an array of values, or multiple values can be passed as individual arguments. `value` supports [references](#refkey-options).
+
+```javascript
+var schema = {
+    a: Joi.any().valid('a'),
+    b: Joi.any().valid('b', 'B'),
+    c: Joi.any().valid(['c', 'C'])
+};
+```
+
+#### `any.invalid(value)` - aliases: `disallow`, `not`
+
+Blacklists a value where:
+- `value` - the forbidden value which can be of any type and will be matched against the validated value before applying any other rules.
+  `value` can be an array of values, or multiple values can be passed as individual arguments. `value` supports [references](#refkey-options).
+
+```javascript
+var schema = {
+    a: Joi.any().invalid('a'),
+    b: Joi.any().invalid('b', 'B'),
+    c: Joi.any().invalid(['c', 'C'])
+};
+```
+
+#### `any.required()`
+
+Marks a key as required which will not allow `undefined` as value. All keys are optional by default.
+
+```javascript
+var schema = Joi.any().required();
+```
+
+#### `any.optional()`
+
+Marks a key as optional which will allow `undefined` as values. Used to annotate the schema for readability as all keys are optional by default.
+
+```javascript
+var schema = Joi.any().optional();
+```
+
+#### `any.forbidden()`
+
+Marks a key as forbidden which will not allow any value except `undefined`. Used to explicitly forbid keys.
+
+```javascript
+var schema = {
+    a: Joi.any().forbidden()
+};
+```
+
+#### `any.strip()`
+
+Marks a key to be removed from a resulting object or array after validation. Used to sanitize output.
+
+```javascript
+var schema = {
+    username: Joi.string(),
+    password: Joi.string().strip()
+};
+
+schema.validate({ username: 'test', password: 'hunter2' }, function (err, value) {
+    // value = { username: 'test' }
+});
+
+var schema = Joi.array().items(Joi.string(), Joi.any().strip());
+
+schema.validate(['one', 'two', true, false, 1, 2], function (err, value) {
+    // value = ['one', 'two']
+});
+```
+
+#### `any.description(desc)`
+
+Annotates the key where:
+- `desc` - the description string.
+
+```javascript
+var schema = Joi.any().description('this key will match anything you give it');
+```
+
+#### `any.notes(notes)`
+
+Annotates the key where:
+- `notes` - the notes string or array of strings.
+
+```javascript
+var schema = Joi.any().notes(['this is special', 'this is important']);
+```
+
+#### `any.tags(tags)`
+
+Annotates the key where:
+- `tags` - the tag string or array of strings.
+
+```javascript
+var schema = Joi.any().tags(['api', 'user']);
+```
+
+#### `any.meta(meta)`
+
+Attaches metadata to the key where:
+- `meta` - the meta object to attach.
+
+```javascript
+var schema = Joi.any().meta({ index: true });
+```
+
+#### `any.example(value)`
+
+Annotates the key where:
+- `value` - an example value.
+
+If the example fails to pass validation, the function will throw.
+
+```javascript
+var schema = Joi.string().min(4).example('abcd');
+```
+
+#### `any.unit(name)`
+
+Annotates the key where:
+- `name` - the unit name of the value.
+
+```javascript
+var schema = Joi.number().unit('milliseconds');
+```
+
+#### `any.options(options)`
+
+Overrides the global `validate()` options for the current key and any sub-key where:
+- `options` - an object with the same optional keys as [`Joi.validate(value, schema, options, callback)`](#validatevalue-schema-options-callback).
+
+```javascript
+var schema = Joi.any().options({ convert: false });
+```
+
+#### `any.strict(isStrict)`
+
+Strict mode sets the `options.convert` options to `false` which prevent type casting for the current key and any child keys.
+- `isStrict` - whether strict mode is enabled or not. Defaults to true.
+
+```javascript
+var schema = Joi.any().strict();
+```
+
+#### `any.default([value, [description]])`
+
+Sets a default value if the original value is undefined where:
+- `value` - the value.
+  - `value` supports [references](#refkey-options).
+  - `value` may also be a function which returns the default value. If `value` is specified as a function that accepts a single parameter, that parameter will be a context object that can be used to derive the resulting value. **This clones the object however, which incurs some overhead so if you don't need access to the context define your method so that it does not accept any parameters**.
+  - without any `value`, `default` has no effect, except for `object` that will then create nested defaults (applying inner defaults of that object).
+
+Note that if `value` is an object, any changes to the object after `default()` is called will change the reference
+and any future assignment.
+
+Additionally, when specifying a method you must either have a `description` property on your method or the second parameter is required.
+
+```javascript
+var generateUsername = function (context) {
+
+  return context.firstname.toLowerCase() + '-' + context.lastname.toLowerCase();
+};
+generateUsername.description = 'generated username';
+
+var schema = {
+    username: Joi.string().default(generateUsername),
+    firstname: Joi.string(),
+    lastname: Joi.string(),
+    created: Joi.date().default(Date.now, 'time of creation'),
+    status: Joi.string().default('registered')
+};
+
+Joi.validate({
+    firstname: 'Jane',
+    lastname: 'Doe'
+}, schema, function (err, value) {
+
+    // value.status === 'registered'
+    // value.username === 'jane-doe'
+    // value.created will be the time of validation
+});
+```
+
+#### `any.concat(schema)`
+
+Returns a new type that is the result of adding the rules of one type to another where:
+- `schema` - a **joi** type to merge into the current schema. Can only be of the same type as the context type or `any`. If applied to an `any` type, the schema can be any other schema.
+
+```javascript
+var a = Joi.string().valid('a');
+var b = Joi.string().valid('b');
+var ab = a.concat(b);
+```
+
+#### `any.when(ref, options)`
+
+Converts the type into an [`alternatives`](#alternatives) type where the conditions are merged into the type definition where:
+- `ref` - the key name or [reference](#refkey-options).
+- `options` - an object with:
+    - `is` - the required condition **joi** type.
+    - `then` - the alternative schema type if the condition is true. Required if `otherwise` is missing.
+    - `otherwise` - the alternative schema type if the condition is false. Required if `then` is missing.
+
+```javascript
+var schema = {
+    a: Joi.any().valid('x').when('b', { is: 5, then: Joi.valid('y'), otherwise: Joi.valid('z') }),
+    b: Joi.any()
+};
+```
+
+Alternatively, if you want to specify a specific type such as `string`, `array`, etc, you can do so like this:
+
+```javascript
+var schema = {
+    a: Joi.valid('a', 'b', 'other'),
+    other: Joi.string()
+        .when('a', { is: 'other', then: Joi.required() }),
+};
+```
+
+#### `any.label(name)`
+
+Overrides the key name in error messages.
+- `name` - the name of the key.
+
+```javascript
+var schema = {
+    first_name: Joi.string().label('First Name')
+};
+```
+
+#### `any.raw(isRaw)`
+
+Outputs the original untouched value instead of the casted value.
+- `isRaw` - whether to enable raw mode or not. Defaults to true.
+
+```javascript
+var schema = {
+    timestamp: Joi.date().format('YYYYMMDD').raw()
+};
+```
+
+#### `any.empty(schema)`
+
+Considers anything that matches the schema to be empty (`undefined`).
+- `schema` - any object or joi schema to match. An undefined schema unsets that rule.
+
+```js
+var schema = Joi.string().empty('');
+schema.validate(''); // returns { error: null, value: undefined }
+schema = schema.empty();
+schema.validate(''); // returns { error: "value" is not allowed to be empty, value: '' }
+```
+
+### `array`
+
+Generates a schema object that matches an array data type. Note that undefined values inside arrays are not allowed by default but can be by using `sparse()`.
+
+Supports the same methods of the [`any()`](#any) type.
+
+```javascript
+var array = Joi.array().items(Joi.string().valid('a', 'b'));
+array.validate(['a', 'b', 'a'], function (err, value) { });
+```
+
+#### `array.sparse(enabled)`
+
+Allow this array to be sparse. `enabled` can be used with a falsy value to go back to the default behavior.
+
+```javascript
+var schema = Joi.array().sparse(); // undefined values are now allowed
+schema = schema.sparse(false); // undefined values are now denied
+```
+
+#### `array.single(enabled)`
+
+Allow single values to be checked against rules as if it were provided as an array.
+
+`enabled` can be used with a falsy value to go back to the default behavior.
+
+```javascript
+var schema = Joi.array().items(Joi.number()).single();
+schema.validate([4]); // returns `{ error: null, value: [ 4 ] }`
+schema.validate(4); // returns `{ error: null, value: [ 4 ] }`
+```
+
+#### `array.items(type)`
+
+List the types allowed for the array values where:
+- `type` - a **joi** schema object to validate each array item against. `type` can be an array of values, or multiple values can be passed as individual arguments.
+
+If a given type is `.required()` then there must be a matching item in the array.
+If a type is `.forbidden()` then it cannot appear in the array.
+Required items can be added multiple times to signify that multiple items must be found.
+Errors will contain the number of items that didn't match. Any unmatched item having a [label](#anylabelname) will be mentioned explicitly.
+
+```javascript
+var schema = Joi.array().items(Joi.string(), Joi.number()); // array may contain strings and numbers
+var schema = Joi.array().items(Joi.string().required(), Joi.string().required()); // array must contain at least two strings
+var schema = Joi.array().items(Joi.string().valid('not allowed').forbidden(), Joi.string()); // array may contain strings, but none of those strings can match 'not allowed'
+var schema = Joi.array().items(Joi.string().label('My string').required(), Joi.number().required()); // If this fails it can result in `[ValidationError: "value" does not contain [My string] and 1 other required value(s)]`
+```
+
+#### `array.ordered(type)`
+
+List the types in sequence order for the array values where:
+- `type` - a **joi** schema object to validate against each array item in sequence order. `type` can be an array of values, or multiple values can be passed as individual arguments.
+
+If a given type is `.required()` then there must be a matching item with the same index position in the array.
+Errors will contain the number of items that didn't match. Any unmatched item having a [label](#anylabelname) will be mentioned explicitly.
+
+```javascript
+var schema = Joi.array().ordered(Joi.string().required(), Joi.number().required()); // array must have first item as string and second item as number
+var schema = Joi.array().ordered(Joi.string().required()).items(Joi.number().required()); // array must have first item as string and 1 or more subsequent items as number
+var schema = Joi.array().ordered(Joi.string().required(), Joi.number()); // array must have first item as string and optionally second item as number
+```
+
+#### `array.min(limit)`
+
+Specifies the minimum number of items in the array where:
+- `limit` - the lowest number of array items allowed.
+
+```javascript
+var schema = Joi.array().min(2);
+```
+
+#### `array.max(limit)`
+
+Specifies the maximum number of items in the array where:
+- `limit` - the highest number of array items allowed.
+
+```javascript
+var schema = Joi.array().max(10);
+```
+
+#### `array.length(limit)`
+
+Specifies the exact number of items in the array where:
+- `limit` - the number of array items allowed.
+
+```javascript
+var schema = Joi.array().length(5);
+```
+
+#### `array.unique()`
+
+Requires the array values to be unique.
+
+Be aware that a deep equality is performed on elements of the array having a type of `object`, a performance penalty is to be expected for this kind of operation.
+
+```javascript
+var schema = Joi.array().unique();
+```
+
+### `boolean`
+
+Generates a schema object that matches a boolean data type (as well as the strings 'true', 'false', 'yes', 'no', 'on' or 'off'). Can also be called via `bool()`.
+
+Supports the same methods of the [`any()`](#any) type.
+
+```javascript
+var boolean = Joi.boolean();
+boolean.validate(true, function (err, value) { });
+```
+
+### `binary`
+
+Generates a schema object that matches a Buffer data type (as well as the strings which will be converted to Buffers).
+
+Supports the same methods of the [`any()`](#any) type.
+
+```javascript
+var schema = Joi.binary();
+```
+
+#### `binary.encoding(encoding)`
+
+Sets the string encoding format if a string input is converted to a buffer where:
+- `encoding` - the encoding scheme.
+
+```javascript
+var schema = Joi.binary().encoding('base64');
+```
+
+#### `binary.min(limit)`
+
+Specifies the minimum length of the buffer where:
+- `limit` - the lowest size of the buffer.
+
+```javascript
+var schema = Joi.binary().min(2);
+```
+
+#### `binary.max(limit)`
+
+Specifies the maximum length of the buffer where:
+- `limit` - the highest size of the buffer.
+
+```javascript
+var schema = Joi.binary().max(10);
+```
+
+#### `binary.length(limit)`
+
+Specifies the exact length of the buffer:
+- `limit` - the size of buffer allowed.
+
+```javascript
+var schema = Joi.binary().length(5);
+```
+
+### `date`
+
+Generates a schema object that matches a date type (as well as a JavaScript date string or number of milliseconds).
+
+Supports the same methods of the [`any()`](#any) type.
+
+```javascript
+var date = Joi.date();
+date.validate('12-21-2012', function (err, value) { });
+```
+
+#### `date.min(date)`
+
+Specifies the oldest date allowed where:
+- `date` - the oldest date allowed.
+
+```javascript
+var schema = Joi.date().min('1-1-1974');
+```
+
+Notes: `'now'` can be passed in lieu of `date` so as to always compare relatively to the current date, allowing to explicitly ensure a date is either in the past or in the future.
+
+```javascript
+var schema = Joi.date().min('now');
+```
+
+It can also be a reference to another field.
+
+```javascript
+var schema = Joi.object({
+  from: Joi.date().required(),
+  to: Joi.date().min(Joi.ref('from')).required()
+});
+```
+
+#### `date.max(date)`
+
+Specifies the latest date allowed where:
+- `date` - the latest date allowed.
+
+```javascript
+var schema = Joi.date().max('12-31-2020');
+```
+
+Notes: `'now'` can be passed in lieu of `date` so as to always compare relatively to the current date, allowing to explicitly ensure a date is either in the past or in the future.
+
+```javascript
+var schema = Joi.date().max('now');
+```
+
+It can also be a reference to another field.
+
+```javascript
+var schema = Joi.object({
+  from: Joi.date().max(Joi.ref('to')).required(),
+  to: Joi.date().required()
+});
+```
+
+#### `date.format(format)`
+
+Specifies the allowed date format:
+- `format` - string or array of strings that follow the `moment.js` [format](http://momentjs.com/docs/#/parsing/string-format/).
+
+```javascript
+var schema = Joi.date().format('YYYY/MM/DD');
+```
+
+#### `date.iso()`
+
+Requires the string value to be in valid ISO 8601 date format.
+
+```javascript
+var schema = Joi.date().iso();
+```
+
+### `func`
+
+Generates a schema object that matches a function type.
+
+Supports the same methods of the [`object()`](#object) type. Note that validating a function keys will cause the function
+to be cloned. While the function will retain its prototype and closure, it will lose its `length` property value (will be
+set to `0`).
+
+```javascript
+var func = Joi.func();
+func.validate(function () {}, function (err, value) { });
+```
+
+### `number`
+
+Generates a schema object that matches a number data type (as well as strings that can be converted to numbers).
+
+`Infinity` and `-Infinity` are invalid by default, you can change that behavior by calling `allow(Infinity, -Infinity)`.
+
+Supports the same methods of the [`any()`](#any) type.
+
+```javascript
+var number = Joi.number();
+number.validate(5, function (err, value) { });
+```
+
+#### `number.min(limit)`
+
+Specifies the minimum value where:
+- `limit` - the minimum value allowed.
+
+```javascript
+var schema = Joi.number().min(2);
+```
+
+It can also be a reference to another field.
+
+```javascript
+var schema = Joi.object({
+  min: Joi.number().required(),
+  max: Joi.number().min(Joi.ref('min')).required()
+});
+```
+
+#### `number.max(limit)`
+
+Specifies the maximum value where:
+- `limit` - the maximum value allowed.
+
+```javascript
+var schema = Joi.number().max(10);
+```
+
+It can also be a reference to another field.
+
+```javascript
+var schema = Joi.object({
+  min: Joi.number().max(Joi.ref('max')).required(),
+  max: Joi.number().required()
+});
+```
+
+#### `number.greater(limit)`
+
+Specifies that the value must be greater than `limit`.
+
+```javascript
+var schema = Joi.number().greater(5);
+```
+
+```javascript
+var schema = Joi.object({
+  min: Joi.number().required(),
+  max: Joi.number().greater(Joi.ref('min')).required()
+});
+```
+
+#### `number.less(limit)`
+
+Specifies that the value must be less than `limit`.
+
+```javascript
+var schema = Joi.number().less(10);
+```
+
+It can also be a reference to another field.
+
+```javascript
+var schema = Joi.object({
+  min: Joi.number().less(Joi.ref('max')).required(),
+  max: Joi.number().required()
+});
+```
+
+#### `number.integer()`
+
+Requires the number to be an integer (no floating point).
+
+```javascript
+var schema = Joi.number().integer();
+```
+
+#### `number.precision(limit)`
+
+Specifies the maximum number of decimal places where:
+- `limit` - the maximum number of decimal places allowed.
+
+```javascript
+var schema = Joi.number().precision(2);
+```
+
+#### `number.multiple(base)`
+
+Specifies that the value must be a multiple of `base`:
+
+```javascript
+var schema = Joi.number().multiple(3);
+```
+
+#### `number.positive()`
+
+Requires the number to be positive.
+
+```javascript
+var schema = Joi.number().positive();
+```
+
+#### `number.negative()`
+
+Requires the number to be negative.
+
+```javascript
+var schema = Joi.number().negative();
+```
+
+### `object`
+
+Generates a schema object that matches an object data type (as well as JSON strings that parsed into objects). Defaults
+to allowing any child key.
+
+Supports the same methods of the [`any()`](#any) type.
+
+```javascript
+var object = Joi.object().keys({
+    a: Joi.number().min(1).max(10).integer(),
+    b: 'some string'
+});
+
+object.validate({ a: 5 }, function (err, value) { });
+```
+
+#### `object.keys([schema])`
+
+Sets or extends the allowed object keys where:
+- `schema` - optional object where each key is assigned a **joi** type object. If `schema` is `{}` no keys allowed.
+  If `schema` is `null` or `undefined`, any key allowed. If `schema` is an object with keys, the keys are added to any
+  previously defined keys (but narrows the selection if all keys previously allowed). Defaults to 'undefined' which
+  allows any child key.
+
+```javascript
+var base = Joi.object().keys({
+    a: Joi.number(),
+    b: Joi.string()
+});
+// Validate keys a, b and c.
+var extended = base.keys({
+    c: Joi.boolean()
+});
+```
+
+Notes: We have three different ways to define a schema for performing a validation
+
+- Using the plain JS object notation:
+```javascript
+var schema = {
+    a: Joi.string(),
+    b: Joi.number()
+};
+```
+- Using the `Joi.object([schema])` notation
+```javascript
+var schema = Joi.object({
+    a: Joi.string(),
+    b: Joi.number()
+});
+```
+- Using the `Joi.object().keys([schema])` notation
+```javascript
+var schema = Joi.object().keys({
+    a: Joi.string(),
+    b: Joi.number()
+});
+```
+
+While all these three objects defined above will result in the same validation object, there are some differences in using one or another:
+
+##### `{} notation`
+
+When using the `{}` notation, you are just defining a plain JS object, which isn't a schema object.
+You can pass it to the validation method but you can't call `validate()` method of the object because it's just a plain JS object.
+
+Besides, passing the `{}` object to the `validate()` method each time, will perform an expensive schema compilation operation on every validation.
+
+##### `Joi.object([schema]) notation`
+
+Using `Joi.object([schema])` will return a schema object, so you can call the `validate()` method directly, e.g:
+
+```javascript
+var schema = Joi.object({
+    a: Joi.boolean()
+});
+
+schema.validate(true, function (err, value) {
+    console.log('err: ', err);
+});
+```
+
+When you use `Joi.object([schema])`, it gets compiled the first time, so you can pass it to the `validate()` method multiple times and no overhead is added.
+
+Another benefits of using `Joi.object([schema])` instead of a plain JS object is that you can set any options on the object like allowing unknown keys, e.g:
+
+```javascript
+var schema = Joi.object({
+    arg: Joi.string().valid('firstname', 'lastname', 'title', 'company', 'jobtitle'),
+    value: Joi.string(),
+}).pattern(/firstname|lastname/, Joi.string().min(2));
+```
+
+##### `Joi.object().keys([schema]) notation`
+
+This is basically the same as `Joi.object([schema])`, but using `Joi.object().keys([schema])` is more useful when you want to add more keys (e.g. call `keys()` multiple times). If you are only adding one set of keys, you can skip the `keys()` method and just use `object()` directly.
+
+Some people like to use `keys()` to make the code more explicit (this is style only).
+
+
+#### `object.min(limit)`
+
+Specifies the minimum number of keys in the object where:
+- `limit` - the lowest number of keys allowed.
+
+```javascript
+var schema = Joi.object().min(2);
+```
+
+#### `object.max(limit)`
+
+Specifies the maximum number of keys in the object where:
+- `limit` - the highest number of object keys allowed.
+
+```javascript
+var schema = Joi.object().max(10);
+```
+
+#### `object.length(limit)`
+
+Specifies the exact number of keys in the object where:
+- `limit` - the number of object keys allowed.
+
+```javascript
+var schema = Joi.object().length(5);
+```
+
+#### `object.pattern(regex, schema)`
+
+Specify validation rules for unknown keys matching a pattern where:
+- `regex` - a regular expression tested against the unknown key names.
+- `schema` - the schema object matching keys much validate against.
+
+```javascrip
+var schema = Joi.object({
+    a: Joi.string()
+}).pattern(/\w\d/, Joi.boolean());
+```
+
+#### `object.and(peers)`
+
+Defines an all-or-nothing relationship between keys where if one of the peers is present, all of them are required as
+well where:
+- `peers` - the key names of which if one present, all are required. `peers` can be a single string value, an
+  array of string values, or each peer provided as an argument.
+
+```javascript
+var schema = Joi.object().keys({
+    a: Joi.any(),
+    b: Joi.any()
+}).and('a', 'b');
+```
+
+#### `object.nand(peers)`
+
+Defines a relationship between keys where not all peers can be present at the
+same time where:
+- `peers` - the key names of which if one present, the others may not all be present. `peers` can be a single string value, an
+  array of string values, or each peer provided as an argument.
+
+```javascript
+var schema = Joi.object().keys({
+    a: Joi.any(),
+    b: Joi.any()
+}).nand('a', 'b');
+```
+
+#### `object.or(peers)`
+
+Defines a relationship between keys where one of the peers is required (and more than one is allowed) where:
+- `peers` - the key names of which at least one must appear. `peers` can be a single string value, an
+  array of string values, or each peer provided as an argument.
+
+```javascript
+var schema = Joi.object().keys({
+    a: Joi.any(),
+    b: Joi.any()
+}).or('a', 'b');
+```
+
+#### `object.xor(peers)`
+
+Defines an exclusive relationship between a set of keys where one of them is required but not at the same time where:
+- `peers` - the exclusive key names that must not appear together but where one of them is required. `peers` can be a single string value, an
+  array of string values, or each peer provided as an argument.
+
+```javascript
+var schema = Joi.object().keys({
+    a: Joi.any(),
+    b: Joi.any()
+}).xor('a', 'b');
+```
+
+#### `object.with(key, peers)`
+
+Requires the presence of other keys whenever the specified key is present where:
+- `key` - the reference key.
+- `peers` - the required peer key names that must appear together with `key`. `peers` can be a single string value or an array of string values.
+
+Note that unlike [`object.and()`](#objectandpeers), `with()` creates a dependency only between the `key` and each of the `peers`, not
+between the `peers` themselves.
+
+```javascript
+var schema = Joi.object().keys({
+    a: Joi.any(),
+    b: Joi.any()
+}).with('a', 'b');
+```
+
+#### `object.without(key, peers)`
+
+Forbids the presence of other keys whenever the specified is present where:
+- `key` - the reference key.
+- `peers` - the forbidden peer key names that must not appear together with `key`. `peers` can be a single string value or an array of string values.
+
+```javascript
+var schema = Joi.object().keys({
+    a: Joi.any(),
+    b: Joi.any()
+}).without('a', ['b']);
+```
+
+#### `object.rename(from, to, [options])`
+
+Renames a key to another name (deletes the renamed key) where:
+- `from` - the original key name.
+- `to` - the new key name.
+- `options` - an optional object with the following optional keys:
+    - `alias` - if `true`, does not delete the old key name, keeping both the new and old keys in place. Defaults to `false`.
+    - `multiple` - if `true`, allows renaming multiple keys to the same destination where the last rename wins. Defaults to `false`.
+    - `override` - if `true`, allows renaming a key over an existing key. Defaults to `false`.
+    - `ignoreUndefined` - if `true`, skip renaming of a key if it's undefined. Defaults to `false`.
+
+Keys are renamed before any other validation rules are applied.
+
+```javascript
+var object = Joi.object().keys({
+    a: Joi.number()
+}).rename('b', 'a');
+
+object.validate({ b: 5 }, function (err, value) { });
+```
+
+#### `object.assert(ref, schema, [message])`
+
+Verifies an assertion where:
+- `ref` - the key name or [reference](#refkey-options).
+- `schema` - the validation rules required to satisfy the assertion. If the `schema` includes references, they are resolved against
+  the object value, not the value of the `ref` target.
+- `message` - optional human-readable message used when the assertion fails. Defaults to 'failed to pass the assertion test'.
+
+```javascript
+var schema = Joi.object().keys({
+    a: {
+        b: Joi.string(),
+        c: Joi.number()
+    },
+    d: {
+        e: Joi.any()
+    }
+}).assert('d.e', Joi.ref('a.c'), 'equal to a.c');
+```
+
+#### `object.unknown([allow])`
+
+Overrides the handling of unknown keys for the scope of the current object only (does not apply to children) where:
+- `allow` - if `false`, unknown keys are not allowed, otherwise unknown keys are ignored.
+
+```javascript
+var schema = Joi.object({ a: Joi.any() }).unknown();
+```
+
+#### `object.type(constructor, [name])`
+
+Requires the object to be an instance of a given constructor where:
+- `constructor` - the constructor function that the object must be an instance of.
+- `name` - an alternate name to use in validation errors. This is useful when the constructor function does not have a name.
+
+```javascript
+var schema = Joi.object().type(RegExp);
+```
+
+#### `object.requiredKeys(children)`
+
+Sets the specified children to required.
+- `children` - can be a single string value, an array of string values, or each child provided as an argument.
+
+```javascript
+var schema = Joi.object().keys({ a: { b: Joi.number() }, c: { d: Joi.string() } });
+var requiredSchema = schema.requiredKeys('', 'a.b', 'c', 'c.d');
+```
+
+Note that in this example `''` means the current object, `a` is not required but `b` is, as well as `c` and `d`.
+
+#### `object.optionalKeys(children)`
+
+Sets the specified children to optional.
+- `children` - can be a single string value, an array of string values, or each child provided as an argument.
+
+```javascript
+var schema = Joi.object().keys({ a: { b: Joi.number().required() }, c: { d: Joi.string().required() } });
+var requiredSchema = schema.optionalKeys('a.b', 'c.d');
+```
+
+The behavior is exactly the same as `requiredKeys`.
+
+### `string`
+
+Generates a schema object that matches a string data type. Note that empty strings are not allowed by default and must be enabled with `allow('')`.
+
+Supports the same methods of the [`any()`](#any) type.
+
+```javascript
+var schema = Joi.string().min(1).max(10);
+schema.validate('12345', function (err, value) { });
+```
+
+#### `string.insensitive()`
+
+Allows the value to match any whitelist of blacklist item in a case insensitive comparison.
+
+```javascript
+var schema = Joi.string().valid('a').insensitive();
+```
+
+#### `string.min(limit, [encoding])`
+
+Specifies the minimum number string characters where:
+- `limit` - the minimum number of string characters required.
+- `encoding` - is specified, the string length is calculated in bytes using the provided encoding.
+
+```javascript
+var schema = Joi.string().min(2);
+```
+
+It can also be a reference to another field.
+
+```javascript
+var schema = Joi.object({
+  min: Joi.string().required(),
+  value: Joi.string().min(Joi.ref('min'), 'utf8').required()
+});
+```
+
+#### `string.max(limit, [encoding])`
+
+Specifies the maximum number of string characters where:
+- `limit` - the maximum number of string characters allowed.
+- `encoding` - is specified, the string length is calculated in bytes using the provided encoding.
+
+```javascript
+var schema = Joi.string().max(10);
+```
+
+It can also be a reference to another field.
+
+```javascript
+var schema = Joi.object({
+  max: Joi.string().required(),
+  value: Joi.string().max(Joi.ref('max'), 'utf8').required()
+});
+```
+
+#### `string.creditCard()`
+
+Requires the number to be a credit card number (Using [Lunh
+Algorithm](http://en.wikipedia.org/wiki/Luhn_algorithm)).
+
+```javascript
+var schema = Joi.string().creditCard();
+```
+
+#### `string.length(limit, [encoding])`
+
+Specifies the exact string length required where:
+- `limit` - the required string length.
+- `encoding` - is specified, the string length is calculated in bytes using the provided encoding.
+
+```javascript
+var schema = Joi.string().length(5);
+```
+
+It can also be a reference to another field.
+
+```javascript
+var schema = Joi.object({
+  length: Joi.string().required(),
+  value: Joi.string().length(Joi.ref('length'), 'utf8').required()
+});
+```
+
+#### `string.regex(pattern, [name])`
+
+Defines a regular expression rule where:
+- `pattern` - a regular expression object the string value must match against.
+- `name` - optional name for patterns (useful with multiple patterns). Defaults to 'required'.
+
+```javascript
+var schema = Joi.string().regex(/^[abc]+$/);
+```
+
+#### `string.replace(pattern, replacement)`
+
+Replace characters matching the given _pattern_ with the specified
+_replacement_ string where:
+- `pattern` - a regular expression object to match against, or a string of which _all_ occurrences will be replaced.
+- `replacement` - the string that will replace the pattern.
+
+
+```javascript
+var schema = Joi.string().replace(/b/gi, 'x');
+schema.validate('abBc', function (err, value) {
+  // here value will be 'axxc'
+});
+```
+
+When `pattern` is a _string_ all its occurrences will be replaced.
+
+#### `string.alphanum()`
+
+Requires the string value to only contain a-z, A-Z, and 0-9.
+
+```javascript
+var schema = Joi.string().alphanum();
+```
+
+#### `string.token()`
+
+Requires the string value to only contain a-z, A-Z, 0-9, and underscore _.
+
+```javascript
+var schema = Joi.string().token();
+```
+
+#### `string.email([options])`
+
+Requires the string value to be a valid email address.
+
+- `options` - optional settings:
+    - `errorLevel` - Numerical threshold at which an email address is considered invalid.
+    - `tldWhitelist` - Specifies a list of acceptable TLDs.
+    - `minDomainAtoms` - Number of atoms required for the domain. Be careful since some domains, such as `io`, directly allow email.
+
+```javascript
+var schema = Joi.string().email();
+```
+
+#### `string.ip([options])`
+
+Requires the string value to be a valid ip address.
+
+- `options` - optional settings:
+    - `version` - One or more IP address versions to validate against. Valid values: `ipv4`, `ipv6`, `ipvfuture`
+    - `cidr` - Used to determine if a CIDR is allowed or not. Valid values: `optional`, `required`, `forbidden`
+
+```javascript
+// Accept only ipv4 and ipv6 addresses with a CIDR
+var schema = Joi.string().ip({
+  version: [
+    'ipv4',
+    'ipv6'
+  ],
+  cidr: 'required'
+});
+```
+
+#### `string.uri([options])`
+
+Requires the string value to be a valid [RFC 3986](http://tools.ietf.org/html/rfc3986) URI.
+
+- `options` - optional settings:
+    - `scheme` - Specifies one or more acceptable Schemes, should only include the scheme name. Can be an Array or String (strings are automatically escaped for use in a Regular Expression).
+
+```javascript
+// Accept git or git http/https
+var schema = Joi.string().uri({
+  scheme: [
+    'git',
+    /git\+https?/
+  ]
+});
+```
+
+#### `string.guid()`
+
+Requires the string value to be a valid GUID.
+
+```javascript
+var schema = Joi.string().guid();
+```
+
+#### `string.hex()`
+
+Requires the string value to be a valid hexadecimal string.
+
+```javascript
+var schema = Joi.string().hex();
+```
+
+#### `string.hostname()`
+
+Requires the string value to be a valid hostname as per [RFC1123](http://tools.ietf.org/html/rfc1123).
+
+```javascript
+var schema = Joi.string().hostname();
+```
+
+#### `string.lowercase()`
+
+Requires the string value to be all lowercase. If the validation `convert` option is on (enabled by default), the string
+will be forced to lowercase.
+
+```javascript
+var schema = Joi.string().lowercase();
+```
+
+#### `string.uppercase()`
+
+Requires the string value to be all uppercase. If the validation `convert` option is on (enabled by default), the string
+will be forced to uppercase.
+
+```javascript
+var schema = Joi.string().uppercase();
+```
+
+#### `string.trim()`
+
+Requires the string value to contain no whitespace before or after. If the validation `convert` option is on (enabled by
+default), the string will be trimmed.
+
+```javascript
+var schema = Joi.string().trim();
+```
+
+#### `string.isoDate()`
+
+Requires the string value to be in valid ISO 8601 date format.
+
+```js
+var schema = Joi.string().isoDate();
+```
+
+### `alternatives`
+
+Generates a type that will match one of the provided alternative schemas via the [`try()`](#alternativestryschemas)
+method. If no schemas are added, the type will not match any value except for `undefined`.
+
+Supports the same methods of the [`any()`](#any) type.
+
+Alternatives can be expressed using the shorter `[]` notation.
+
+```javascript
+var alt = Joi.alternatives().try(Joi.number(), Joi.string());
+// Same as [Joi.number(), Joi.string()]
+```
+
+#### `alternatives.try(schemas)`
+
+Adds an alternative schema type for attempting to match against the validated value where:
+- `schema` - an array of alternative **joi** types. Also supports providing each type as a separate argument.
+
+```javascript
+var alt = Joi.alternatives().try(Joi.number(), Joi.string());
+alt.validate('a', function (err, value) { });
+```
+
+#### `alternatives.when(ref, options)`
+
+Adds a conditional alternative schema type based on another key (not the same as `any.when()`) value where:
+- `ref` - the key name or [reference](#refkey-options).
+- `options` - an object with:
+    - `is` - the required condition **joi** type.
+    - `then` - the alternative schema type to **try** if the condition is true. Required if `otherwise` is missing.
+    - `otherwise` - the alternative schema type to **try** if the condition is false. Required if `then` is missing.
+
+```javascript
+var schema = {
+    a: Joi.alternatives().when('b', { is: 5, then: Joi.string(), otherwise: Joi.number() }),
+    b: Joi.any()
+};
+```
+
+Note that `when()` only adds additional alternatives to try and does not impact the overall type. Setting
+a `required()` rule on a single alternative will not apply to the overall key. For example,
+this definition of `a`:
+
+```javascript
+var schema = {
+    a: Joi.alternatives().when('b', { is: true, then: Joi.required() }),
+    b: Joi.boolean()
+};
+```
+
+Does not turn `a` into a required key when `b` is `true`. Instead, it tells the validator to try and match the
+value to anything that's not `undefined`. However, since `Joi.alternatives()` by itself allows `undefined`, the rule
+does not accomplish turning `a` to a required value. This rule is the same as `Joi.alternatives([Joi.required()])`
+when `b` is `true` which will allow any value including `undefined`.
+
+To accomplish the desired result above use:
+
+```javascript
+var schema = {
+    a: Joi.when('b', { is: true, then: Joi.required() }),
+    b: Joi.boolean()
+};
+```
+
+### `ref(key, [options])`
+
+Generates a reference to the value of the named key. References are resolved at validation time and in order of dependency
+so that if one key validation depends on another, the dependent key is validated second after the reference is validated.
+References support the following arguments:
+- `key` - the reference target. References cannot point up the object tree, only to sibling keys, but they can point to
+  their siblings' children (e.g. 'a.b.c') using the `.` separator. If a `key` starts with `$` is signifies a context reference
+  which is looked up in the `context` option object.
+- `options` - optional settings:
+    - `separator` - overrides the default `.` hierarchy separator.
+    - `contextPrefix` - overrides the default `$` context prefix signifier.
+
+Note that references can only be used where explicitly supported such as in `valid()` or `invalid()` rules. If upwards
+(parents) references are needed, use [`object.assert()`](#objectassertref-schema-message).
+
+```javascript
+var schema = Joi.object().keys({
+    a: Joi.ref('b.c'),
+    b: {
+        c: Joi.any()
+    },
+    c: Joi.ref('$x')
+});
+
+Joi.validate({ a: 5, b: { c: 5 } }, schema, { context: { x: 5 } }, function (err, value) {});
+```
+
+## Errors
+
+Joi throws classical javascript `Error`s containing :
+- `name` - `ValidationError`.
+- `details` - an array of errors :
+    - `message` - string with a description of the error.
+    - `path` - dotted path to the key where the error happened.
+    - `type` - type of the error.
+    - `context` - object providing context of the error.
+- `annotate` - function that returns a string with an annotated version of the object pointing at the places where errors occured.
+- `_object` - the original object to validate.

@@ -0,0 +1,14 @@
+# How to contribute
+We welcome contributions from the community and are pleased to have them.  Please follow this guide when logging issues or making code changes.
+
+## Logging Issues
+All issues should be created using the [new issue form](https://github.com/hapijs/joi/issues/new).  Clearly describe the issue including steps to reproduce if there are any.  Also, make sure to indicate the earliest version that has the issue being reported.
+
+## Patching Code
+Code changes are welcome and should follow the guidelines below.
+
+* Fork the repository on GitHub.
+* Fix the issue ensuring that your code follows the [style guide](https://github.com/hapijs/contrib/blob/master/Style.md).
+* Add tests for your new code ensuring that you have 100% code coverage (we can help you reach 100% but will not merge without it).
+    * Run `npm test` to generate a report of test coverage
+* [Pull requests](http://help.github.com/send-pull-requests/) should be made to the [master branch](https://github.com/hapijs/joi/tree/master).

@@ -0,0 +1,28 @@
+Copyright (c) 2012-2014, Walmart and other contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * The names of any contributors may not be used to endorse or promote
+      products derived from this software without specific prior written
+      permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+                                  *   *   *
+
+The complete list of contributors can be found at: https://github.com/hapijs/joi/graphs/contributors

@@ -0,0 +1,90 @@
+![joi Logo](https://raw.github.com/hapijs/joi/master/images/joi.png)
+
+Object schema description language and validator for JavaScript objects.
+
+[![npm version](https://badge.fury.io/js/joi.svg)](http://badge.fury.io/js/joi)
+[![Build Status](https://secure.travis-ci.org/hapijs/joi.svg)](http://travis-ci.org/hapijs/joi)
+[![Dependencies Status](https://david-dm.org/hapijs/joi.svg)](https://david-dm.org/hapijs/joi)
+[![DevDependencies Status](https://david-dm.org/hapijs/joi/dev-status.svg)](https://david-dm.org/hapijs/joi#info=devDependencies)
+
+[![Join the chat at https://gitter.im/hapijs/joi](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/hapijs/joi?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+Lead Maintainer: [Nicolas Morel](https://github.com/marsup)
+
+# Example
+
+```javascript
+var Joi = require('joi');
+
+var schema = Joi.object().keys({
+    username: Joi.string().alphanum().min(3).max(30).required(),
+    password: Joi.string().regex(/^[a-zA-Z0-9]{3,30}$/),
+    access_token: [Joi.string(), Joi.number()],
+    birthyear: Joi.number().integer().min(1900).max(2013),
+    email: Joi.string().email()
+}).with('username', 'birthyear').without('password', 'access_token');
+
+Joi.validate({ username: 'abc', birthyear: 1994 }, schema, function (err, value) { });  // err === null -> valid
+```
+
+The above schema defines the following constraints:
+* `username`
+    * a required string
+    * must contain only alphanumeric characters
+    * at least 3 characters long but no more than 30
+    * must be accompanied by `birthyear`
+* `password`
+    * an optional string
+    * must satisfy the custom regex
+    * cannot appear together with `access_token`
+* `access_token`
+    * an optional, unconstrained string or number
+* `birthyear`
+    * an integer between 1900 and 2013
+* `email`
+    * a valid email address string
+
+# Usage
+
+Usage is a two steps process. First, a schema is constructed using the provided types and constraints:
+
+```javascript
+var schema = {
+    a: Joi.string()
+};
+```
+
+Note that **joi** schema objects are immutable which means every additional rule added (e.g. `.min(5)`) will return a
+new schema object.
+
+Then the value is validated against the schema:
+
+```javascript
+Joi.validate({ a: 'a string' }, schema, function (err, value) { });
+```
+
+If the value is valid, `null` is returned, otherwise an `Error` object.
+
+The schema can be a plain JavaScript object where every key is assigned a **joi** type, or it can be a **joi** type directly:
+
+```javascript
+var schema = Joi.string().min(10);
+```
+
+If the schema is a **joi** type, the `schema.validate(value, callback)` can be called directly on the type. When passing a non-type schema object,
+the module converts it internally to an object() type equivalent to:
+
+```javascript
+var schema = Joi.object().keys({
+    a: Joi.string()
+});
+```
+
+When validating a schema:
+
+* Keys are optional by default.
+* Strings are utf-8 encoded by default.
+* Rules are defined in an additive fashion and evaluated in order after whitelist and blacklist checks.
+
+# API
+See the [API Reference](API.md).

@@ -0,0 +1,43 @@
+// This is an example of a survey to obtain the reputation of Parisians
+// It contains examples of how to conditionally require keys based on values of other keys
+
+var Joi = require('../');
+
+// This is a valid value for integer rating 1 - 5
+var intRating = Joi.number().integer().min(1).max(5);
+
+var schema = Joi.object().keys({
+    // Do you know any French people? yes or no (required)
+    q1: Joi.boolean().required(),
+    // Do you know any Parisians? yes or no (required if answered yes in q1)
+    q2: Joi.boolean()
+        .when('q1', { is: true, then: Joi.required() }),
+    // How many french in paris do you know? 1-6, 6-10, 11-50 or 50+ (required if answered yes in q2)
+    q3: Joi.string()
+        .when('q2', { is: true, then: Joi.valid('1-5', '6-10', '11-50', '50+').required() }),
+    // Rate 20% of most friendly Parisians, from how many people you know answered in q3, individually on 1-5 rating
+    q4: Joi.array()
+        .when('q3', {is: '1-5', then: Joi.array().min(0).max(1).items(intRating).required() })
+        .when('q3', {is: '6-10', then: Joi.array().min(1).max(2).items(intRating).required() })
+        .when('q3', {is: '11-50', then: Joi.array().min(2).max(10).items(intRating).required() })
+        .when('q3', {is: '50+', then: Joi.array().min(10).items(intRating).required() }),
+    // Rate remaining 80% of Parisians, from how many people you know answered in q3, individually on 1-5 rating
+    q5: Joi.array()
+        .when('q3', {is: '1-5', then: Joi.array().min(1).max(4).items(intRating).required() })
+        .when('q3', {is: '6-10', then: Joi.array().min(4).max(8).items(intRating).required() })
+        .when('q3', {is: '11-50', then: Joi.array().min(8).max(40).items(intRating).required() })
+        .when('q3', {is: '50+', then: Joi.array().min(40).items(intRating).required().required() }),
+    // Rate the reputation of Parisians in general, 1-5 rating
+    q6: intRating.required()
+});
+
+var response = {
+	q1: true,
+	q2: true,
+	q3: '1-5',
+	q4: [5],
+	q5: [1],
+	q6: 2
+};
+
+Joi.assert(response, schema);

@@ -0,0 +1,22 @@
+var Joi = require('../');
+
+
+var schema = Joi.object().options({ abortEarly: false }).keys({
+    email: Joi.string().email().required().label('User Email'),
+    password: Joi.string().min(8).required(),
+    password_confirmation: Joi.any().valid(Joi.ref('password')).required().options({ language: { any: { allowOnly: 'must match password' }, label: 'Password Confirmation' } }).label('This label is not used because language.label takes precedence'),
+    first_name: Joi.string().required(),
+    last_name: Joi.string().required(),
+    company: Joi.string().optional()
+});
+
+
+var data = {
+    email: 'not_a_valid_email_to_show_custom_label',
+    password: 'abcd1234',
+    password_confirmation: 'abc1',
+    first_name: 'Joe',
+    last_name: 'Doe'
+};
+
+Joi.assert(data, schema);

@@ -0,0 +1,17 @@
+var Joi = require('../');
+
+
+var schema = {
+    type: Joi.string().required(),
+    subtype: Joi.alternatives()
+        .when('type', {is: 'video', then: Joi.valid('mp4', 'wav')})
+        .when('type', {is: 'audio', then: Joi.valid('mp3')})
+        .when('type', {is: 'image', then: Joi.valid('jpg', 'png')})
+        .when('type', {is: 'pdf'  , then: Joi.valid('document')})
+};
+
+
+Joi.assert({ type: 'video', subtype: 'mp4' }, schema); // Pass
+Joi.assert({ type: 'video', subtype: 'wav' }, schema); // Pass
+Joi.assert({ type: 'other', subtype: 'something' }, schema); // Fail
+Joi.assert({ type: 'audio', subtype: 'mp4' }, schema); // Fail

@@ -0,0 +1,21 @@
+var Toc = require('markdown-toc');
+var Fs = require('fs');
+var Package = require('./package.json');
+
+var filename = './API.md';
+
+var api = Fs.readFileSync(filename, 'utf8');
+var tocOptions = {
+    bullets: '-',
+    slugify: function (text) {
+
+        return text.toLowerCase()
+            .replace(/\s/g, '-')
+            .replace(/[^\w-]/g, '');
+    }
+};
+
+var output = Toc.insert(api, tocOptions)
+    .replace(/<!-- version -->(.|\n)*<!-- versionstop -->/, '<!-- version -->\n# ' + Package.version + ' API Reference\n<!-- versionstop -->');
+
+Fs.writeFileSync(filename, output);

@@ -0,0 +1,152 @@
+// Load modules
+
+var Hoek = require('hoek');
+var Any = require('./any');
+var Cast = require('./cast');
+var Ref = require('./ref');
+var Errors = require('./errors');
+
+
+// Declare internals
+
+var internals = {};
+
+
+internals.Alternatives = function () {
+
+    Any.call(this);
+    this._type = 'alternatives';
+    this._invalids.remove(null);
+
+    this._inner.matches = [];
+};
+
+Hoek.inherits(internals.Alternatives, Any);
+
+
+internals.Alternatives.prototype._base = function (value, state, options) {
+
+    var errors = [];
+    for (var i = 0, il = this._inner.matches.length; i < il; ++i) {
+        var item = this._inner.matches[i];
+        var schema = item.schema;
+        if (!schema) {
+            var failed = item.is._validate(item.ref(state.parent, options), null, options, state.parent).errors;
+            schema = failed ? item.otherwise : item.then;
+            if (!schema) {
+                continue;
+            }
+        }
+
+        var result = schema._validate(value, state, options);
+        if (!result.errors) {     // Found a valid match
+            return result;
+        }
+
+        errors = errors.concat(result.errors);
+    }
+
+    return { errors: errors.length ? errors : Errors.create('alternatives.base', null, state, options) };
+};
+
+
+internals.Alternatives.prototype.try = function (/* schemas */) {
+
+
+    var schemas = Hoek.flatten(Array.prototype.slice.call(arguments));
+    Hoek.assert(schemas.length, 'Cannot add other alternatives without at least one schema');
+
+    var obj = this.clone();
+
+    for (var i = 0, il = schemas.length; i < il; ++i) {
+        var cast = Cast.schema(schemas[i]);
+        if (cast._refs.length) {
+            obj._refs = obj._refs.concat(cast._refs);
+        }
+        obj._inner.matches.push({ schema: cast });
+    }
+
+    return obj;
+};
+
+
+internals.Alternatives.prototype.when = function (ref, options) {
+
+    Hoek.assert(Ref.isRef(ref) || typeof ref === 'string', 'Invalid reference:', ref);
+    Hoek.assert(options, 'Missing options');
+    Hoek.assert(typeof options === 'object', 'Invalid options');
+    Hoek.assert(options.hasOwnProperty('is'), 'Missing "is" directive');
+    Hoek.assert(options.then !== undefined || options.otherwise !== undefined, 'options must have at least one of "then" or "otherwise"');
+
+    var obj = this.clone();
+    var is = Cast.schema(options.is);
+
+    if (options.is === null || !options.is.isJoi) {
+
+        // Only apply required if this wasn't already a schema, we'll suppose people know what they're doing
+        is = is.required();
+    }
+
+    var item = {
+        ref: Cast.ref(ref),
+        is: is,
+        then: options.then !== undefined ? Cast.schema(options.then) : undefined,
+        otherwise: options.otherwise !== undefined ? Cast.schema(options.otherwise) : undefined
+    };
+
+    Ref.push(obj._refs, item.ref);
+    obj._refs = obj._refs.concat(item.is._refs);
+
+    if (item.then && item.then._refs) {
+        obj._refs = obj._refs.concat(item.then._refs);
+    }
+
+    if (item.otherwise && item.otherwise._refs) {
+        obj._refs = obj._refs.concat(item.otherwise._refs);
+    }
+
+    obj._inner.matches.push(item);
+
+    return obj;
+};
+
+
+internals.Alternatives.prototype.describe = function () {
+
+    var description = Any.prototype.describe.call(this);
+    var alternatives = [];
+    for (var i = 0, il = this._inner.matches.length; i < il; ++i) {
+        var item = this._inner.matches[i];
+        if (item.schema) {
+
+            // try()
+
+            alternatives.push(item.schema.describe());
+        }
+        else {
+
+            // when()
+
+            var when = {
+                ref: item.ref.toString(),
+                is: item.is.describe()
+            };
+
+            if (item.then) {
+                when.then = item.then.describe();
+            }
+
+            if (item.otherwise) {
+                when.otherwise = item.otherwise.describe();
+            }
+
+            alternatives.push(when);
+        }
+    }
+
+    description.alternatives = alternatives;
+    return description;
+};
+
+
+module.exports = new internals.Alternatives();

@@ -0,0 +1,899 @@
+// Load modules
+
+var Hoek = require('hoek');
+var Ref = require('./ref');
+var Errors = require('./errors');
+var Alternatives = null;                // Delay-loaded to prevent circular dependencies
+var Cast = null;
+
+
+// Declare internals
+
+var internals = {};
+
+
+internals.defaults = {
+    abortEarly: true,
+    convert: true,
+    allowUnknown: false,
+    skipFunctions: false,
+    stripUnknown: false,
+    language: {},
+    presence: 'optional',
+    raw: false,
+    strip: false,
+    noDefaults: false
+
+    // context: null
+};
+
+
+internals.checkOptions = function (options) {
+
+    var optionType = {
+        abortEarly: 'boolean',
+        convert: 'boolean',
+        allowUnknown: 'boolean',
+        skipFunctions: 'boolean',
+        stripUnknown: 'boolean',
+        language: 'object',
+        presence: ['string', 'required', 'optional', 'forbidden', 'ignore'],
+        raw: 'boolean',
+        context: 'object',
+        strip: 'boolean',
+        noDefaults: 'boolean'
+    };
+
+    var keys = Object.keys(options);
+    for (var k = 0, kl = keys.length; k < kl; ++k) {
+        var key = keys[k];
+        var opt = optionType[key];
+        var type = opt;
+        var values = null;
+
+        if (Array.isArray(opt)) {
+            type = opt[0];
+            values = opt.slice(1);
+        }
+
+        Hoek.assert(type, 'unknown key ' + key);
+        Hoek.assert(typeof options[key] === type, key + ' should be of type ' + type);
+        if (values) {
+            Hoek.assert(values.indexOf(options[key]) >= 0, key + ' should be one of ' + values.join(', '));
+        }
+    }
+};
+
+
+module.exports = internals.Any = function () {
+
+    Cast = Cast || require('./cast');
+
+    this.isJoi = true;
+    this._type = 'any';
+    this._settings = null;
+    this._valids = new internals.Set();
+    this._invalids = new internals.Set();
+    this._tests = [];
+    this._refs = [];
+    this._flags = { /*
+        presence: 'optional',                   // optional, required, forbidden, ignore
+        allowOnly: false,
+        allowUnknown: undefined,
+        default: undefined,
+        forbidden: false,
+        encoding: undefined,
+        insensitive: false,
+        trim: false,
+        case: undefined,                        // upper, lower
+        empty: undefined,
+        func: false
+    */ };
+
+    this._description = null;
+    this._unit = null;
+    this._notes = [];
+    this._tags = [];
+    this._examples = [];
+    this._meta = [];
+
+    this._inner = {};                           // Hash of arrays of immutable objects
+};
+
+
+internals.Any.prototype.isImmutable = true;     // Prevents Hoek from deep cloning schema objects
+
+
+internals.Any.prototype.clone = function () {
+
+    var obj = Object.create(Object.getPrototypeOf(this));
+
+    obj.isJoi = true;
+    obj._type = this._type;
+    obj._settings = internals.concatSettings(this._settings);
+    obj._valids = Hoek.clone(this._valids);
+    obj._invalids = Hoek.clone(this._invalids);
+    obj._tests = this._tests.slice();
+    obj._refs = this._refs.slice();
+    obj._flags = Hoek.clone(this._flags);
+
+    obj._description = this._description;
+    obj._unit = this._unit;
+    obj._notes = this._notes.slice();
+    obj._tags = this._tags.slice();
+    obj._examples = this._examples.slice();
+    obj._meta = this._meta.slice();
+
+    obj._inner = {};
+    var inners = Object.keys(this._inner);
+    for (var i = 0, il = inners.length; i < il; ++i) {
+        var key = inners[i];
+        obj._inner[key] = this._inner[key] ? this._inner[key].slice() : null;
+    }
+
+    return obj;
+};
+
+
+internals.Any.prototype.concat = function (schema) {
+
+    Hoek.assert(schema && schema.isJoi, 'Invalid schema object');
+    Hoek.assert(this._type === 'any' || schema._type === 'any' || schema._type === this._type, 'Cannot merge type', this._type, 'with another type:', schema._type);
+
+    var obj = this.clone();
+
+    if (this._type === 'any' && schema._type !== 'any') {
+
+        // Reset values as if we were "this"
+        var tmpObj = schema.clone();
+        var keysToRestore = ['_settings', '_valids', '_invalids', '_tests', '_refs', '_flags', '_description', '_unit',
+            '_notes', '_tags', '_examples', '_meta', '_inner'];
+
+        for (var j = 0, jl = keysToRestore.length; j < jl; ++j) {
+            tmpObj[keysToRestore[j]] = obj[keysToRestore[j]];
+        }
+
+        obj = tmpObj;
+    }
+
+    obj._settings = obj._settings ? internals.concatSettings(obj._settings, schema._settings) : schema._settings;
+    obj._valids.merge(schema._valids, schema._invalids);
+    obj._invalids.merge(schema._invalids, schema._valids);
+    obj._tests = obj._tests.concat(schema._tests);
+    obj._refs = obj._refs.concat(schema._refs);
+    Hoek.merge(obj._flags, schema._flags);
+
+    obj._description = schema._description || obj._description;
+    obj._unit = schema._unit || obj._unit;
+    obj._notes = obj._notes.concat(schema._notes);
+    obj._tags = obj._tags.concat(schema._tags);
+    obj._examples = obj._examples.concat(schema._examples);
+    obj._meta = obj._meta.concat(schema._meta);
+
+    var inners = Object.keys(schema._inner);
+    var isObject = obj._type === 'object';
+    for (var i = 0, il = inners.length; i < il; ++i) {
+        var key = inners[i];
+        var source = schema._inner[key];
+        if (source) {
+            var target = obj._inner[key];
+            if (target) {
+                if (isObject && key === 'children') {
+                    var keys = {};
+
+                    for (var k = 0, kl = target.length; k < kl; ++k) {
+                        keys[target[k].key] = k;
+                    }
+
+                    for (k = 0, kl = source.length; k < kl; ++k) {
+                        var sourceKey = source[k].key;
+                        if (keys[sourceKey] >= 0) {
+                            target[keys[sourceKey]] = {
+                                key: sourceKey,
+                                schema: target[keys[sourceKey]].schema.concat(source[k].schema)
+                            };
+                        }
+                        else {
+                            target.push(source[k]);
+                        }
+                    }
+                }
+                else {
+                    obj._inner[key] = obj._inner[key].concat(source);
+                }
+            }
+            else {
+                obj._inner[key] = source.slice();
+            }
+        }
+    }
+
+    return obj;
+};
+
+
+internals.Any.prototype._test = function (name, arg, func) {
+
+    Hoek.assert(!this._flags.allowOnly, 'Cannot define rules when valid values specified');
+
+    var obj = this.clone();
+    obj._tests.push({ func: func, name: name, arg: arg });
+    return obj;
+};
+
+
+internals.Any.prototype.options = function (options) {
+
+    Hoek.assert(!options.context, 'Cannot override context');
+    internals.checkOptions(options);
+
+    var obj = this.clone();
+    obj._settings = internals.concatSettings(obj._settings, options);
+    return obj;
+};
+
+
+internals.Any.prototype.strict = function (isStrict) {
+
+    var obj = this.clone();
+    obj._settings = obj._settings || {};
+    obj._settings.convert = isStrict === undefined ? false : !isStrict;
+    return obj;
+};
+
+
+internals.Any.prototype.raw = function (isRaw) {
+
+    var obj = this.clone();
+    obj._settings = obj._settings || {};
+    obj._settings.raw = isRaw === undefined ? true : isRaw;
+    return obj;
+};
+
+
+internals.Any.prototype._allow = function () {
+
+    var values = Hoek.flatten(Array.prototype.slice.call(arguments));
+    for (var i = 0, il = values.length; i < il; ++i) {
+        var value = values[i];
+
+        Hoek.assert(value !== undefined, 'Cannot call allow/valid/invalid with undefined');
+        this._invalids.remove(value);
+        this._valids.add(value, this._refs);
+    }
+};
+
+
+internals.Any.prototype.allow = function () {
+
+    var obj = this.clone();
+    obj._allow.apply(obj, arguments);
+    return obj;
+};
+
+
+internals.Any.prototype.valid = internals.Any.prototype.only = internals.Any.prototype.equal = function () {
+
+    Hoek.assert(!this._tests.length, 'Cannot set valid values when rules specified');
+
+    var obj = this.allow.apply(this, arguments);
+    obj._flags.allowOnly = true;
+    return obj;
+};
+
+
+internals.Any.prototype.invalid = internals.Any.prototype.disallow = internals.Any.prototype.not = function (value) {
+
+    var obj = this.clone();
+    var values = Hoek.flatten(Array.prototype.slice.call(arguments));
+    for (var i = 0, il = values.length; i < il; ++i) {
+        value = values[i];
+
+        Hoek.assert(value !== undefined, 'Cannot call allow/valid/invalid with undefined');
+        obj._valids.remove(value);
+        obj._invalids.add(value, this._refs);
+    }
+
+    return obj;
+};
+
+
+internals.Any.prototype.required = internals.Any.prototype.exist = function () {
+
+    var obj = this.clone();
+    obj._flags.presence = 'required';
+    return obj;
+};
+
+
+internals.Any.prototype.optional = function () {
+
+    var obj = this.clone();
+    obj._flags.presence = 'optional';
+    return obj;
+};
+
+
+internals.Any.prototype.forbidden = function () {
+
+    var obj = this.clone();
+    obj._flags.presence = 'forbidden';
+    return obj;
+};
+
+
+internals.Any.prototype.strip = function () {
+
+    var obj = this.clone();
+    obj._flags.strip = true;
+    return obj;
+};
+
+
+internals.Any.prototype.applyFunctionToChildren = function (children, fn, args, root) {
+
+    children = [].concat(children);
+
+    if (children.length !== 1 || children[0] !== '') {
+        root = root ? (root + '.') : '';
+
+        var extraChildren = (children[0] === '' ? children.slice(1) : children).map(function (child) {
+
+            return root + child;
+        });
+
+        throw new Error('unknown key(s) ' + extraChildren.join(', '));
+    }
+
+    return this[fn].apply(this, args);
+};
+
+
+internals.Any.prototype.default = function (value, description) {
+
+    if (typeof value === 'function' &&
+        !Ref.isRef(value)) {
+
+        if (!value.description &&
+            description) {
+
+            value.description = description;
+        }
+
+        if (!this._flags.func) {
+            Hoek.assert(typeof value.description === 'string' && value.description.length > 0, 'description must be provided when default value is a function');
+        }
+    }
+
+    var obj = this.clone();
+    obj._flags.default = value;
+    Ref.push(obj._refs, value);
+    return obj;
+};
+
+
+internals.Any.prototype.empty = function (schema) {
+
+    var obj;
+    if (schema === undefined) {
+        obj = this.clone();
+        obj._flags.empty = undefined;
+    }
+    else {
+        schema = Cast.schema(schema);
+
+        obj = this.clone();
+        obj._flags.empty = schema;
+    }
+
+    return obj;
+};
+
+
+internals.Any.prototype.when = function (ref, options) {
+
+    Hoek.assert(options && typeof options === 'object', 'Invalid options');
+    Hoek.assert(options.then !== undefined || options.otherwise !== undefined, 'options must have at least one of "then" or "otherwise"');
+
+    var then = options.then ? this.concat(Cast.schema(options.then)) : this;
+    var otherwise = options.otherwise ? this.concat(Cast.schema(options.otherwise)) : this;
+
+    Alternatives = Alternatives || require('./alternatives');
+    var obj = Alternatives.when(ref, { is: options.is, then: then, otherwise: otherwise });
+    obj._flags.presence = 'ignore';
+    return obj;
+};
+
+
+internals.Any.prototype.description = function (desc) {
+
+    Hoek.assert(desc && typeof desc === 'string', 'Description must be a non-empty string');
+
+    var obj = this.clone();
+    obj._description = desc;
+    return obj;
+};
+
+
+internals.Any.prototype.notes = function (notes) {
+
+    Hoek.assert(notes && (typeof notes === 'string' || Array.isArray(notes)), 'Notes must be a non-empty string or array');
+
+    var obj = this.clone();
+    obj._notes = obj._notes.concat(notes);
+    return obj;
+};
+
+
+internals.Any.prototype.tags = function (tags) {
+
+    Hoek.assert(tags && (typeof tags === 'string' || Array.isArray(tags)), 'Tags must be a non-empty string or array');
+
+    var obj = this.clone();
+    obj._tags = obj._tags.concat(tags);
+    return obj;
+};
+
+internals.Any.prototype.meta = function (meta) {
+
+    Hoek.assert(meta !== undefined, 'Meta cannot be undefined');
+
+    var obj = this.clone();
+    obj._meta = obj._meta.concat(meta);
+    return obj;
+};
+
+
+internals.Any.prototype.example = function (value) {
+
+    Hoek.assert(arguments.length, 'Missing example');
+    var result = this._validate(value, null, internals.defaults);
+    Hoek.assert(!result.errors, 'Bad example:', result.errors && Errors.process(result.errors, value));
+
+    var obj = this.clone();
+    obj._examples = obj._examples.concat(value);
+    return obj;
+};
+
+
+internals.Any.prototype.unit = function (name) {
+
+    Hoek.assert(name && typeof name === 'string', 'Unit name must be a non-empty string');
+
+    var obj = this.clone();
+    obj._unit = name;
+    return obj;
+};
+
+
+internals._try = function (fn, arg) {
+
+    var err;
+    var result;
+
+    try {
+        result = fn.call(null, arg);
+    } catch (e) {
+        err = e;
+    }
+
+    return {
+        value: result,
+        error: err
+    };
+};
+
+
+internals.Any.prototype._validate = function (value, state, options, reference) {
+
+    var self = this;
+    var originalValue = value;
+
+    // Setup state and settings
+
+    state = state || { key: '', path: '', parent: null, reference: reference };
+
+    if (this._settings) {
+        options = internals.concatSettings(options, this._settings);
+    }
+
+    var errors = [];
+    var finish = function () {
+
+        var finalValue;
+
+        if (!self._flags.strip) {
+            if (value !== undefined) {
+                finalValue = options.raw ? originalValue : value;
+            }
+            else if (options.noDefaults) {
+                finalValue = originalValue;
+            }
+            else if (Ref.isRef(self._flags.default)) {
+                finalValue = self._flags.default(state.parent, options);
+            }
+            else if (typeof self._flags.default === 'function' &&
+                    !(self._flags.func && !self._flags.default.description)) {
+
+                var arg;
+
+                if (state.parent !== null &&
+                    self._flags.default.length > 0) {
+
+                    arg = Hoek.clone(state.parent);
+                }
+
+                var defaultValue = internals._try(self._flags.default, arg);
+                finalValue = defaultValue.value;
+                if (defaultValue.error) {
+                    errors.push(Errors.create('any.default', defaultValue.error, state, options));
+                }
+            }
+            else {
+                finalValue = Hoek.clone(self._flags.default);
+            }
+        }
+
+        return {
+            value: finalValue,
+            errors: errors.length ? errors : null
+        };
+    };
+
+    // Check presence requirements
+
+    var presence = this._flags.presence || options.presence;
+    if (presence === 'optional') {
+        if (value === undefined) {
+            var isDeepDefault = this._flags.hasOwnProperty('default') && this._flags.default === undefined;
+            if (isDeepDefault && this._type === 'object') {
+                value = {};
+            }
+            else {
+                return finish();
+            }
+        }
+    }
+    else if (presence === 'required' &&
+            value === undefined) {
+
+        errors.push(Errors.create('any.required', null, state, options));
+        return finish();
+    }
+    else if (presence === 'forbidden') {
+        if (value === undefined) {
+            return finish();
+        }
+
+        errors.push(Errors.create('any.unknown', null, state, options));
+        return finish();
+    }
+
+    if (this._flags.empty && !this._flags.empty._validate(value, null, internals.defaults).errors) {
+        value = undefined;
+        return finish();
+    }
+
+    // Check allowed and denied values using the original value
+
+    if (this._valids.has(value, state, options, this._flags.insensitive)) {
+        return finish();
+    }
+
+    if (this._invalids.has(value, state, options, this._flags.insensitive)) {
+        errors.push(Errors.create(value === '' ? 'any.empty' : 'any.invalid', null, state, options));
+        if (options.abortEarly ||
+            value === undefined) {          // No reason to keep validating missing value
+
+            return finish();
+        }
+    }
+
+    // Convert value and validate type
+
+    if (this._base) {
+        var base = this._base.call(this, value, state, options);
+        if (base.errors) {
+            value = base.value;
+            errors = errors.concat(base.errors);
+            return finish();                            // Base error always aborts early
+        }
+
+        if (base.value !== value) {
+            value = base.value;
+
+            // Check allowed and denied values using the converted value
+
+            if (this._valids.has(value, state, options, this._flags.insensitive)) {
+                return finish();
+            }
+
+            if (this._invalids.has(value, state, options, this._flags.insensitive)) {
+                errors.push(Errors.create('any.invalid', null, state, options));
+                if (options.abortEarly) {
+                    return finish();
+                }
+            }
+        }
+    }
+
+    // Required values did not match
+
+    if (this._flags.allowOnly) {
+        errors.push(Errors.create('any.allowOnly', { valids: this._valids.values({ stripUndefined: true }) }, state, options));
+        if (options.abortEarly) {
+            return finish();
+        }
+    }
+
+    // Helper.validate tests
+
+    for (var i = 0, il = this._tests.length; i < il; ++i) {
+        var test = this._tests[i];
+        var err = test.func.call(this, value, state, options);
+        if (err) {
+            errors.push(err);
+            if (options.abortEarly) {
+                return finish();
+            }
+        }
+    }
+
+    return finish();
+};
+
+
+internals.Any.prototype._validateWithOptions = function (value, options, callback) {
+
+    if (options) {
+        internals.checkOptions(options);
+    }
+
+    var settings = internals.concatSettings(internals.defaults, options);
+    var result = this._validate(value, null, settings);
+    var errors = Errors.process(result.errors, value);
+
+    if (callback) {
+        return callback(errors, result.value);
+    }
+
+    return { error: errors, value: result.value };
+};
+
+
+internals.Any.prototype.validate = function (value, callback) {
+
+    var result = this._validate(value, null, internals.defaults);
+    var errors = Errors.process(result.errors, value);
+
+    if (callback) {
+        return callback(errors, result.value);
+    }
+
+    return { error: errors, value: result.value };
+};
+
+
+internals.Any.prototype.describe = function () {
+
+    var description = {
+        type: this._type
+    };
+
+    var flags = Object.keys(this._flags);
+    if (flags.length) {
+        if (this._flags.empty) {
+            description.flags = {};
+            for (var f = 0, fl = flags.length; f < fl; ++f) {
+                var flag = flags[f];
+                description.flags[flag] = flag === 'empty' ? this._flags[flag].describe() : this._flags[flag];
+            }
+        }
+        else {
+            description.flags = this._flags;
+        }
+    }
+
+    if (this._description) {
+        description.description = this._description;
+    }
+
+    if (this._notes.length) {
+        description.notes = this._notes;
+    }
+
+    if (this._tags.length) {
+        description.tags = this._tags;
+    }
+
+    if (this._meta.length) {
+        description.meta = this._meta;
+    }
+
+    if (this._examples.length) {
+        description.examples = this._examples;
+    }
+
+    if (this._unit) {
+        description.unit = this._unit;
+    }
+
+    var valids = this._valids.values();
+    if (valids.length) {
+        description.valids = valids;
+    }
+
+    var invalids = this._invalids.values();
+    if (invalids.length) {
+        description.invalids = invalids;
+    }
+
+    description.rules = [];
+
+    for (var i = 0, il = this._tests.length; i < il; ++i) {
+        var validator = this._tests[i];
+        var item = { name: validator.name };
+        if (validator.arg !== void 0) {
+            item.arg = validator.arg;
+        }
+        description.rules.push(item);
+    }
+
+    if (!description.rules.length) {
+        delete description.rules;
+    }
+
+    var label = Hoek.reach(this._settings, 'language.label');
+    if (label) {
+        description.label = label;
+    }
+
+    return description;
+};
+
+internals.Any.prototype.label = function (name) {
+
+    Hoek.assert(name && typeof name === 'string', 'Label name must be a non-empty string');
+
+    var obj = this.clone();
+    var options = { language: { label: name } };
+
+    // If language.label is set, it should override this label
+    obj._settings = internals.concatSettings(options, obj._settings);
+    return obj;
+};
+
+
+// Set
+
+internals.Set = function () {
+
+    this._set = [];
+};
+
+
+internals.Set.prototype.add = function (value, refs) {
+
+    Hoek.assert(value === null || value === undefined || value instanceof Date || Buffer.isBuffer(value) || Ref.isRef(value) || (typeof value !== 'function' && typeof value !== 'object'), 'Value cannot be an object or function');
+
+    if (typeof value !== 'function' &&
+        this.has(value, null, null, false)) {
+
+        return;
+    }
+
+    Ref.push(refs, value);
+    this._set.push(value);
+};
+
+
+internals.Set.prototype.merge = function (add, remove) {
+
+    for (var i = 0, il = add._set.length; i < il; ++i) {
+        this.add(add._set[i]);
+    }
+
+    for (i = 0, il = remove._set.length; i < il; ++i) {
+        this.remove(remove._set[i]);
+    }
+};
+
+
+internals.Set.prototype.remove = function (value) {
+
+    this._set = this._set.filter(function (item) {
+
+        return value !== item;
+    });
+};
+
+
+internals.Set.prototype.has = function (value, state, options, insensitive) {
+
+    for (var i = 0, il = this._set.length; i < il; ++i) {
+        var items = this._set[i];
+
+        if (Ref.isRef(items)) {
+            items = items(state.reference || state.parent, options);
+        }
+
+        if (!Array.isArray(items)) {
+            items = [items];
+        }
+
+        for (var j = 0, jl = items.length; j < jl; ++j) {
+            var item = items[j];
+            if (typeof value !== typeof item) {
+                continue;
+            }
+
+            if (value === item ||
+                (value instanceof Date && item instanceof Date && value.getTime() === item.getTime()) ||
+                (insensitive && typeof value === 'string' && value.toLowerCase() === item.toLowerCase()) ||
+                (Buffer.isBuffer(value) && Buffer.isBuffer(item) && value.length === item.length && value.toString('binary') === item.toString('binary'))) {
+
+                return true;
+            }
+        }
+    }
+
+    return false;
+};
+
+
+internals.Set.prototype.values = function (options) {
+
+    if (options && options.stripUndefined) {
+        var values = [];
+
+        for (var i = 0, il = this._set.length; i < il; ++i) {
+            var item = this._set[i];
+            if (item !== undefined) {
+                values.push(item);
+            }
+        }
+
+        return values;
+    }
+
+    return this._set.slice();
+};
+
+
+internals.concatSettings = function (target, source) {
+
+    // Used to avoid cloning context
+
+    if (!target &&
+        !source) {
+
+        return null;
+    }
+
+    var key, obj = {};
+
+    if (target) {
+        var tKeys = Object.keys(target);
+        for (var i = 0, il = tKeys.length; i < il; ++i) {
+            key = tKeys[i];
+            obj[key] = target[key];
+        }
+    }
+
+    if (source) {
+        var sKeys = Object.keys(source);
+        for (var j = 0, jl = sKeys.length; j < jl; ++j) {
+            key = sKeys[j];
+            if (key !== 'language' ||
+                !obj.hasOwnProperty(key)) {
+
+                obj[key] = source[key];
+            }
+            else {
+                obj[key] = Hoek.applyToDefaults(obj[key], source[key]);
+            }
+        }
+    }
+
+    return obj;
+};

@@ -0,0 +1,517 @@
+// Load modules
+
+var Any = require('./any');
+var Cast = require('./cast');
+var Errors = require('./errors');
+var Hoek = require('hoek');
+
+
+// Declare internals
+
+var internals = {};
+
+
+internals.fastSplice = function (arr, i) {
+
+    var il = arr.length;
+    var pos = i;
+
+    while (pos < il) {
+        arr[pos++] = arr[pos];
+    }
+
+    --arr.length;
+};
+
+
+internals.Array = function () {
+
+    Any.call(this);
+    this._type = 'array';
+    this._inner.items = [];
+    this._inner.ordereds = [];
+    this._inner.inclusions = [];
+    this._inner.exclusions = [];
+    this._inner.requireds = [];
+    this._flags.sparse = false;
+};
+
+Hoek.inherits(internals.Array, Any);
+
+
+internals.Array.prototype._base = function (value, state, options) {
+
+    var result = {
+        value: value
+    };
+
+    if (typeof value === 'string' &&
+        options.convert) {
+
+        try {
+            var converted = JSON.parse(value);
+            if (Array.isArray(converted)) {
+                result.value = converted;
+            }
+        }
+        catch (e) { }
+    }
+
+    var isArray = Array.isArray(result.value);
+    var wasArray = isArray;
+    if (options.convert && this._flags.single && !isArray) {
+        result.value = [result.value];
+        isArray = true;
+    }
+
+    if (!isArray) {
+        result.errors = Errors.create('array.base', null, state, options);
+        return result;
+    }
+
+    if (this._inner.inclusions.length ||
+        this._inner.exclusions.length ||
+        !this._flags.sparse) {
+
+        // Clone the array so that we don't modify the original
+        if (wasArray) {
+            result.value = result.value.slice(0);
+        }
+
+        result.errors = internals.checkItems.call(this, result.value, wasArray, state, options);
+
+        if (result.errors && wasArray && options.convert && this._flags.single) {
+
+            // Attempt a 2nd pass by putting the array inside one.
+            var previousErrors = result.errors;
+
+            result.value = [result.value];
+            result.errors = internals.checkItems.call(this, result.value, wasArray, state, options);
+
+            if (result.errors) {
+
+                // Restore previous errors and value since this didn't validate either.
+                result.errors = previousErrors;
+                result.value = result.value[0];
+            }
+        }
+    }
+
+    return result;
+};
+
+
+internals.checkItems = function (items, wasArray, state, options) {
+
+    var errors = [];
+    var errored;
+
+    var requireds = this._inner.requireds.slice();
+    var ordereds = this._inner.ordereds.slice();
+    var inclusions = this._inner.inclusions.concat(requireds);
+
+    for (var v = 0, vl = items.length; v < vl; ++v) {
+        errored = false;
+        var item = items[v];
+        var isValid = false;
+        var localState = { key: v, path: (state.path ? state.path + '.' : '') + v, parent: items, reference: state.reference };
+        var res;
+
+        // Sparse
+
+        if (!this._flags.sparse && item === undefined) {
+            errors.push(Errors.create('array.sparse', null, { key: state.key, path: localState.path }, options));
+
+            if (options.abortEarly) {
+                return errors;
+            }
+
+            continue;
+        }
+
+        // Exclusions
+
+        for (var i = 0, il = this._inner.exclusions.length; i < il; ++i) {
+            res = this._inner.exclusions[i]._validate(item, localState, {});                // Not passing options to use defaults
+
+            if (!res.errors) {
+                errors.push(Errors.create(wasArray ? 'array.excludes' : 'array.excludesSingle', { pos: v, value: item }, { key: state.key, path: localState.path }, options));
+                errored = true;
+
+                if (options.abortEarly) {
+                    return errors;
+                }
+
+                break;
+            }
+        }
+
+        if (errored) {
+            continue;
+        }
+
+        // Ordered
+        if (this._inner.ordereds.length) {
+            if (ordereds.length > 0) {
+                var ordered = ordereds.shift();
+                res = ordered._validate(item, localState, options);
+                if (!res.errors) {
+                    if (ordered._flags.strip) {
+                        internals.fastSplice(items, v);
+                        --v;
+                        --vl;
+                    }
+                    else {
+                        items[v] = res.value;
+                    }
+                }
+                else {
+                    errors.push(Errors.create('array.ordered', { pos: v, reason: res.errors, value: item }, { key: state.key, path: localState.path }, options));
+                    if (options.abortEarly) {
+                        return errors;
+                    }
+                }
+                continue;
+            }
+            else if (!this._inner.items.length) {
+                errors.push(Errors.create('array.orderedLength', { pos: v, limit: this._inner.ordereds.length }, { key: state.key, path: localState.path }, options));
+                if (options.abortEarly) {
+                    return errors;
+                }
+                continue;
+            }
+        }
+
+        // Requireds
+
+        var requiredChecks = [];
+        for (i = 0, il = requireds.length; i < il; ++i) {
+            res = requiredChecks[i] = requireds[i]._validate(item, localState, options);
+            if (!res.errors) {
+                items[v] = res.value;
+                isValid = true;
+                internals.fastSplice(requireds, i);
+                --i;
+                --il;
+                break;
+            }
+        }
+
+        if (isValid) {
+            continue;
+        }
+
+        // Inclusions
+
+        for (i = 0, il = inclusions.length; i < il; ++i) {
+            var inclusion = inclusions[i];
+
+            // Avoid re-running requireds that already didn't match in the previous loop
+            var previousCheck = requireds.indexOf(inclusion);
+            if (previousCheck !== -1) {
+                res = requiredChecks[previousCheck];
+            }
+            else {
+                res = inclusion._validate(item, localState, options);
+
+                if (!res.errors) {
+                    if (inclusion._flags.strip) {
+                        internals.fastSplice(items, v);
+                        --v;
+                        --vl;
+                    }
+                    else {
+                        items[v] = res.value;
+                    }
+                    isValid = true;
+                    break;
+                }
+            }
+
+            // Return the actual error if only one inclusion defined
+            if (il === 1) {
+                if (options.stripUnknown) {
+                    internals.fastSplice(items, v);
+                    --v;
+                    --vl;
+                    isValid = true;
+                    break;
+                }
+
+                errors.push(Errors.create(wasArray ? 'array.includesOne' : 'array.includesOneSingle', { pos: v, reason: res.errors, value: item }, { key: state.key, path: localState.path }, options));
+                errored = true;
+
+                if (options.abortEarly) {
+                    return errors;
+                }
+
+                break;
+            }
+        }
+
+        if (errored) {
+            continue;
+        }
+
+        if (this._inner.inclusions.length && !isValid) {
+            if (options.stripUnknown) {
+                internals.fastSplice(items, v);
+                --v;
+                --vl;
+                continue;
+            }
+
+            errors.push(Errors.create(wasArray ? 'array.includes' : 'array.includesSingle', { pos: v, value: item }, { key: state.key, path: localState.path }, options));
+
+            if (options.abortEarly) {
+                return errors;
+            }
+        }
+    }
+
+    if (requireds.length) {
+        internals.fillMissedErrors(errors, requireds, state, options);
+    }
+
+    if (ordereds.length) {
+        internals.fillOrderedErrors(errors, ordereds, state, options);
+    }
+
+    return errors.length ? errors : null;
+};
+
+internals.fillMissedErrors = function (errors, requireds, state, options) {
+
+    var knownMisses = [];
+    var unknownMisses = 0;
+    for (var i = 0, il = requireds.length; i < il; ++i) {
+        var label = Hoek.reach(requireds[i], '_settings.language.label');
+        if (label) {
+            knownMisses.push(label);
+        }
+        else {
+            ++unknownMisses;
+        }
+    }
+
+    if (knownMisses.length) {
+        if (unknownMisses) {
+            errors.push(Errors.create('array.includesRequiredBoth', { knownMisses: knownMisses, unknownMisses: unknownMisses }, { key: state.key, path: state.patk }, options));
+        }
+        else {
+            errors.push(Errors.create('array.includesRequiredKnowns', { knownMisses: knownMisses }, { key: state.key, path: state.path }, options));
+        }
+    }
+    else {
+        errors.push(Errors.create('array.includesRequiredUnknowns', { unknownMisses: unknownMisses }, { key: state.key, path: state.path }, options));
+    }
+};
+
+internals.fillOrderedErrors = function (errors, ordereds, state, options) {
+
+    var requiredOrdereds = [];
+
+    for (var i = 0, il = ordereds.length; i < il; ++i) {
+        var presence = Hoek.reach(ordereds[i], '_flags.presence');
+        if (presence === 'required') {
+            requiredOrdereds.push(ordereds[i]);
+        }
+    }
+
+    if (requiredOrdereds.length) {
+        internals.fillMissedErrors(errors, requiredOrdereds, state, options);
+    }
+};
+
+internals.Array.prototype.describe = function () {
+
+    var description = Any.prototype.describe.call(this);
+
+    if (this._inner.ordereds.length) {
+        description.orderedItems = [];
+
+        for (var o = 0, ol = this._inner.ordereds.length; o < ol; ++o) {
+            description.orderedItems.push(this._inner.ordereds[o].describe());
+        }
+    }
+
+    if (this._inner.items.length) {
+        description.items = [];
+
+        for (var i = 0, il = this._inner.items.length; i < il; ++i) {
+            description.items.push(this._inner.items[i].describe());
+        }
+    }
+
+    return description;
+};
+
+
+internals.Array.prototype.items = function () {
+
+    var obj = this.clone();
+
+    Hoek.flatten(Array.prototype.slice.call(arguments)).forEach(function (type, index) {
+
+        try {
+            type = Cast.schema(type);
+        }
+        catch (castErr) {
+            if (castErr.hasOwnProperty('path')) {
+                castErr.path = index + '.' + castErr.path;
+            }
+            else {
+                castErr.path = index;
+            }
+            castErr.message += '(' + castErr.path + ')';
+            throw castErr;
+        }
+
+        obj._inner.items.push(type);
+
+        if (type._flags.presence === 'required') {
+            obj._inner.requireds.push(type);
+        }
+        else if (type._flags.presence === 'forbidden') {
+            obj._inner.exclusions.push(type.optional());
+        }
+        else {
+            obj._inner.inclusions.push(type);
+        }
+    });
+
+    return obj;
+};
+
+
+internals.Array.prototype.ordered = function () {
+
+    var obj = this.clone();
+
+    Hoek.flatten(Array.prototype.slice.call(arguments)).forEach(function (type, index) {
+
+        try {
+            type = Cast.schema(type);
+        }
+        catch (castErr) {
+            if (castErr.hasOwnProperty('path')) {
+                castErr.path = index + '.' + castErr.path;
+            }
+            else {
+                castErr.path = index;
+            }
+            castErr.message += '(' + castErr.path + ')';
+            throw castErr;
+        }
+        obj._inner.ordereds.push(type);
+    });
+
+    return obj;
+};
+
+
+internals.Array.prototype.min = function (limit) {
+
+    Hoek.assert(Hoek.isInteger(limit) && limit >= 0, 'limit must be a positive integer');
+
+    return this._test('min', limit, function (value, state, options) {
+
+        if (value.length >= limit) {
+            return null;
+        }
+
+        return Errors.create('array.min', { limit: limit, value: value }, state, options);
+    });
+};
+
+
+internals.Array.prototype.max = function (limit) {
+
+    Hoek.assert(Hoek.isInteger(limit) && limit >= 0, 'limit must be a positive integer');
+
+    return this._test('max', limit, function (value, state, options) {
+
+        if (value.length <= limit) {
+            return null;
+        }
+
+        return Errors.create('array.max', { limit: limit, value: value }, state, options);
+    });
+};
+
+
+internals.Array.prototype.length = function (limit) {
+
+    Hoek.assert(Hoek.isInteger(limit) && limit >= 0, 'limit must be a positive integer');
+
+    return this._test('length', limit, function (value, state, options) {
+
+        if (value.length === limit) {
+            return null;
+        }
+
+        return Errors.create('array.length', { limit: limit, value: value }, state, options);
+    });
+};
+
+
+internals.Array.prototype.unique = function () {
+
+    return this._test('unique', undefined, function (value, state, options) {
+
+        var found = {
+            string: {},
+            number: {},
+            undefined: {},
+            boolean: {},
+            object: [],
+            function: []
+        };
+
+        for (var i = 0, il = value.length; i < il; ++i) {
+            var item = value[i];
+            var type = typeof item;
+            var records = found[type];
+
+            // All available types are supported, so it's not possible to reach 100% coverage without ignoring this line.
+            // I still want to keep the test for future js versions with new types (eg. Symbol).
+            if (/* $lab:coverage:off$ */ records /* $lab:coverage:on$ */) {
+                if (Array.isArray(records)) {
+                    for (var r = 0, rl = records.length; r < rl; ++r) {
+                        if (Hoek.deepEqual(records[r], item)) {
+                            return Errors.create('array.unique', { pos: i, value: item }, state, options);
+                        }
+                    }
+
+                    records.push(item);
+                }
+                else {
+                    if (records[item]) {
+                        return Errors.create('array.unique', { pos: i, value: item }, state, options);
+                    }
+
+                    records[item] = true;
+                }
+            }
+        }
+    });
+};
+
+
+internals.Array.prototype.sparse = function (enabled) {
+
+    var obj = this.clone();
+    obj._flags.sparse = enabled === undefined ? true : !!enabled;
+    return obj;
+};
+
+
+internals.Array.prototype.single = function (enabled) {
+
+    var obj = this.clone();
+    obj._flags.single = enabled === undefined ? true : !!enabled;
+    return obj;
+};
+
+
+module.exports = new internals.Array();

@@ -0,0 +1,98 @@
+// Load modules
+
+var Any = require('./any');
+var Errors = require('./errors');
+var Hoek = require('hoek');
+
+
+// Declare internals
+
+var internals = {};
+
+
+internals.Binary = function () {
+
+    Any.call(this);
+    this._type = 'binary';
+};
+
+Hoek.inherits(internals.Binary, Any);
+
+
+internals.Binary.prototype._base = function (value, state, options) {
+
+    var result = {
+        value: value
+    };
+
+    if (typeof value === 'string' &&
+        options.convert) {
+
+        try {
+            var converted = new Buffer(value, this._flags.encoding);
+            result.value = converted;
+        }
+        catch (e) { }
+    }
+
+    result.errors = Buffer.isBuffer(result.value) ? null : Errors.create('binary.base', null, state, options);
+    return result;
+};
+
+
+internals.Binary.prototype.encoding = function (encoding) {
+
+    Hoek.assert(Buffer.isEncoding(encoding), 'Invalid encoding:', encoding);
+
+    var obj = this.clone();
+    obj._flags.encoding = encoding;
+    return obj;
+};
+
+
+internals.Binary.prototype.min = function (limit) {
+
+    Hoek.assert(Hoek.isInteger(limit) && limit >= 0, 'limit must be a positive integer');
+
+    return this._test('min', limit, function (value, state, options) {
+
+        if (value.length >= limit) {
+            return null;
+        }
+
+        return Errors.create('binary.min', { limit: limit, value: value }, state, options);
+    });
+};
+
+
+internals.Binary.prototype.max = function (limit) {
+
+    Hoek.assert(Hoek.isInteger(limit) && limit >= 0, 'limit must be a positive integer');
+
+    return this._test('max', limit, function (value, state, options) {
+
+        if (value.length <= limit) {
+            return null;
+        }
+
+        return Errors.create('binary.max', { limit: limit, value: value }, state, options);
+    });
+};
+
+
+internals.Binary.prototype.length = function (limit) {
+
+    Hoek.assert(Hoek.isInteger(limit) && limit >= 0, 'limit must be a positive integer');
+
+    return this._test('length', limit, function (value, state, options) {
+
+        if (value.length === limit) {
+            return null;
+        }
+
+        return Errors.create('binary.length', { limit: limit, value: value }, state, options);
+    });
+};
+
+
+module.exports = new internals.Binary();

@@ -0,0 +1,41 @@
+// Load modules
+
+var Any = require('./any');
+var Errors = require('./errors');
+var Hoek = require('hoek');
+
+
+// Declare internals
+
+var internals = {};
+
+
+internals.Boolean = function () {
+
+    Any.call(this);
+    this._type = 'boolean';
+};
+
+Hoek.inherits(internals.Boolean, Any);
+
+
+internals.Boolean.prototype._base = function (value, state, options) {
+
+    var result = {
+        value: value
+    };
+
+    if (typeof value === 'string' &&
+        options.convert) {
+
+        var lower = value.toLowerCase();
+        result.value = (lower === 'true' || lower === 'yes' || lower === 'on' ? true
+                                                                              : (lower === 'false' || lower === 'no' || lower === 'off' ? false : value));
+    }
+
+    result.errors = (typeof result.value === 'boolean') ? null : Errors.create('boolean.base', null, state, options);
+    return result;
+};
+
+
+module.exports = new internals.Boolean();

@@ -0,0 +1,75 @@
+// Load modules
+
+var Hoek = require('hoek');
+var Ref = require('./ref');
+
+// Type modules are delay-loaded to prevent circular dependencies
+
+
+// Declare internals
+
+var internals = {
+    any: null,
+    date: require('./date'),
+    string: require('./string'),
+    number: require('./number'),
+    boolean: require('./boolean'),
+    alt: null,
+    object: null
+};
+
+
+exports.schema = function (config) {
+
+    internals.any = internals.any || new (require('./any'))();
+    internals.alt = internals.alt || require('./alternatives');
+    internals.object = internals.object || require('./object');
+
+    if (config &&
+        typeof config === 'object') {
+
+        if (config.isJoi) {
+            return config;
+        }
+
+        if (Array.isArray(config)) {
+            return internals.alt.try(config);
+        }
+
+        if (config instanceof RegExp) {
+            return internals.string.regex(config);
+        }
+
+        if (config instanceof Date) {
+            return internals.date.valid(config);
+        }
+
+        return internals.object.keys(config);
+    }
+
+    if (typeof config === 'string') {
+        return internals.string.valid(config);
+    }
+
+    if (typeof config === 'number') {
+        return internals.number.valid(config);
+    }
+
+    if (typeof config === 'boolean') {
+        return internals.boolean.valid(config);
+    }
+
+    if (Ref.isRef(config)) {
+        return internals.any.valid(config);
+    }
+
+    Hoek.assert(config === null, 'Invalid schema content:', config);
+
+    return internals.any.valid(null);
+};
+
+
+exports.ref = function (id) {
+
+    return Ref.isRef(id) ? id : Ref.create(id);
+};

@@ -0,0 +1,168 @@
+// Load modules
+
+var Any = require('./any');
+var Errors = require('./errors');
+var Ref = require('./ref');
+var Hoek = require('hoek');
+var Moment = require('moment');
+
+
+// Declare internals
+
+var internals = {};
+
+internals.isoDate = /^(?:\d{4}(?!\d{2}\b))(?:(-?)(?:(?:0[1-9]|1[0-2])(?:\1(?:[12]\d|0[1-9]|3[01]))?|W(?:[0-4]\d|5[0-2])(?:-?[1-7])?|(?:00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[1-6])))(?![T]$|[T][\d]+Z$)(?:[T\s](?:(?:(?:[01]\d|2[0-3])(?:(:?)[0-5]\d)?|24\:?00)(?:[.,]\d+(?!:))?)(?:\2[0-5]\d(?:[.,]\d+)?)?(?:[Z]|(?:[+-])(?:[01]\d|2[0-3])(?::?[0-5]\d)?)?)?)?$/;
+internals.invalidDate = new Date('');
+internals.isIsoDate = (function () {
+
+    var isoString = internals.isoDate.toString();
+
+    return function (date) {
+
+        return date && (date.toString() === isoString);
+    };
+})();
+
+internals.Date = function () {
+
+    Any.call(this);
+    this._type = 'date';
+};
+
+Hoek.inherits(internals.Date, Any);
+
+
+internals.Date.prototype._base = function (value, state, options) {
+
+    var result = {
+        value: (options.convert && internals.toDate(value, this._flags.format)) || value
+    };
+
+    if (result.value instanceof Date && !isNaN(result.value.getTime())) {
+        result.errors = null;
+    }
+    else {
+        result.errors = Errors.create(internals.isIsoDate(this._flags.format) ? 'date.isoDate' : 'date.base', null, state, options);
+    }
+
+    return result;
+};
+
+
+internals.toDate = function (value, format) {
+
+    if (value instanceof Date) {
+        return value;
+    }
+
+    if (typeof value === 'string' ||
+        Hoek.isInteger(value)) {
+
+        if (typeof value === 'string' &&
+            /^[+-]?\d+$/.test(value)) {
+
+            value = parseInt(value, 10);
+        }
+
+        var date;
+        if (format) {
+            if (internals.isIsoDate(format)) {
+                date = format.test(value) ? new Date(value) : internals.invalidDate;
+            }
+            else {
+                date = Moment(value, format, true);
+                date = date.isValid() ? date.toDate() : internals.invalidDate;
+            }
+        }
+        else {
+            date = new Date(value);
+        }
+
+        if (!isNaN(date.getTime())) {
+            return date;
+        }
+    }
+
+    return null;
+};
+
+
+internals.compare = function (type, compare) {
+
+    return function (date) {
+
+        var isNow = date === 'now';
+        var isRef = Ref.isRef(date);
+
+        if (!isNow && !isRef) {
+            date = internals.toDate(date);
+        }
+
+        Hoek.assert(date, 'Invalid date format');
+
+        return this._test(type, date, function (value, state, options) {
+
+            var compareTo;
+            if (isNow) {
+                compareTo = Date.now();
+            }
+            else if (isRef) {
+                compareTo = internals.toDate(date(state.parent, options));
+
+                if (!compareTo) {
+                    return Errors.create('date.ref', { ref: date.key }, state, options);
+                }
+
+                compareTo = compareTo.getTime();
+            }
+            else {
+                compareTo = date.getTime();
+            }
+
+            if (compare(value.getTime(), compareTo)) {
+                return null;
+            }
+
+            return Errors.create('date.' + type, { limit: new Date(compareTo) }, state, options);
+        });
+    };
+};
+
+
+internals.Date.prototype.min = internals.compare('min', function (value, date) {
+
+    return value >= date;
+});
+
+
+internals.Date.prototype.max = internals.compare('max', function (value, date) {
+
+    return value <= date;
+});
+
+
+internals.Date.prototype.format = function (format) {
+
+    Hoek.assert(typeof format === 'string' || (Array.isArray(format) && format.every(function (f) {
+
+        return typeof f === 'string';
+    })), 'Invalid format.');
+
+    var obj = this.clone();
+    obj._flags.format = format;
+    return obj;
+};
+
+internals.Date.prototype.iso = function () {
+
+    var obj = this.clone();
+    obj._flags.format = internals.isoDate;
+    return obj;
+};
+
+internals.Date.prototype._isIsoDate = function (value) {
+
+    return internals.isoDate.test(value);
+};
+
+module.exports = new internals.Date();

@@ -0,0 +1,297 @@
+// Load modules
+
+var Hoek = require('hoek');
+var Language = require('./language');
+
+
+// Declare internals
+
+var internals = {};
+
+internals.stringify = function (value, wrapArrays) {
+
+    var type = typeof value;
+
+    if (value === null) {
+        return 'null';
+    }
+
+    if (type === 'string') {
+        return value;
+    }
+
+    if (value instanceof internals.Err || type === 'function') {
+        return value.toString();
+    }
+
+    if (type === 'object') {
+        if (Array.isArray(value)) {
+            var partial = '';
+
+            for (var i = 0, il = value.length; i < il; ++i) {
+                partial += (partial.length ? ', ' : '') + internals.stringify(value[i], wrapArrays);
+            }
+
+            return wrapArrays ? '[' + partial + ']' : partial;
+        }
+
+        return value.toString();
+    }
+
+    return JSON.stringify(value);
+};
+
+internals.Err = function (type, context, state, options) {
+
+    this.type = type;
+    this.context = context || {};
+    this.context.key = state.key;
+    this.path = state.path;
+    this.options = options;
+};
+
+
+internals.Err.prototype.toString = function () {
+
+    var self = this;
+
+    var localized = this.options.language;
+
+    if (localized.label) {
+        this.context.key = localized.label;
+    }
+    else if (this.context.key === '' || this.context.key === null) {
+        this.context.key = localized.root || Language.errors.root;
+    }
+
+    var format = Hoek.reach(localized, this.type) || Hoek.reach(Language.errors, this.type);
+    var hasKey = /\{\{\!?key\}\}/.test(format);
+    var skipKey = format.length > 2 && format[0] === '!' && format[1] === '!';
+
+    if (skipKey) {
+        format = format.slice(2);
+    }
+
+    if (!hasKey && !skipKey) {
+        format = (Hoek.reach(localized, 'key') || Hoek.reach(Language.errors, 'key')) + format;
+    }
+
+    var wrapArrays = Hoek.reach(localized, 'messages.wrapArrays');
+    if (typeof wrapArrays !== 'boolean') {
+        wrapArrays = Language.errors.messages.wrapArrays;
+    }
+
+    var message = format.replace(/\{\{(\!?)([^}]+)\}\}/g, function ($0, isSecure, name) {
+
+        var value = Hoek.reach(self.context, name);
+        var normalized = internals.stringify(value, wrapArrays);
+        return (isSecure ? Hoek.escapeHtml(normalized) : normalized);
+    });
+
+    return message;
+};
+
+
+exports.create = function (type, context, state, options) {
+
+    return new internals.Err(type, context, state, options);
+};
+
+
+exports.process = function (errors, object) {
+
+    if (!errors || !errors.length) {
+        return null;
+    }
+
+    // Construct error
+
+    var message = '';
+    var details = [];
+
+    var processErrors = function (localErrors, parent) {
+
+        for (var i = 0, il = localErrors.length; i < il; ++i) {
+            var item = localErrors[i];
+
+            var detail = {
+                message: item.toString(),
+                path: internals.getPath(item),
+                type: item.type,
+                context: item.context
+            };
+
+            if (!parent) {
+                message += (message ? '. ' : '') + detail.message;
+            }
+
+            // Do not push intermediate errors, we're only interested in leafs
+            if (item.context.reason && item.context.reason.length) {
+                processErrors(item.context.reason, item.path);
+            }
+            else {
+                details.push(detail);
+            }
+        }
+    };
+
+    processErrors(errors);
+
+    var error = new Error(message);
+    error.name = 'ValidationError';
+    error.details = details;
+    error._object = object;
+    error.annotate = internals.annotate;
+    return error;
+};
+
+
+internals.getPath = function (item) {
+
+    var recursePath = function (it) {
+
+        var reachedItem = Hoek.reach(it, 'context.reason.0');
+        if (reachedItem && reachedItem.context) {
+            return recursePath(reachedItem);
+        }
+
+        return it.path;
+    };
+
+    return recursePath(item) || item.context.key;
+};
+
+
+// Inspired by json-stringify-safe
+internals.safeStringify = function (obj, spaces) {
+
+    return JSON.stringify(obj, internals.serializer(), spaces);
+};
+
+internals.serializer = function () {
+
+    var cycleReplacer = function (key, value) {
+
+        if (stack[0] === value) {
+            return '[Circular ~]';
+        }
+
+        return '[Circular ~.' + keys.slice(0, stack.indexOf(value)).join('.') + ']';
+    };
+
+    var keys = [], stack = [];
+
+    return function (key, value) {
+
+        if (stack.length > 0) {
+            var thisPos = stack.indexOf(this);
+            if (~thisPos) {
+                stack.length = thisPos + 1;
+                keys.length = thisPos + 1;
+                keys[thisPos] = key;
+            }
+            else {
+                stack.push(this);
+                keys.push(key);
+            }
+
+            if (~stack.indexOf(value)) {
+                value = cycleReplacer.call(this, key, value);
+            }
+        }
+        else {
+            stack.push(value);
+        }
+
+        if (Array.isArray(value) && value.placeholders) {
+            var placeholders = value.placeholders;
+            var arrWithPlaceholders = [];
+            for (var i = 0, il = value.length; i < il; ++i) {
+                if (placeholders[i]) {
+                    arrWithPlaceholders.push(placeholders[i]);
+                }
+                arrWithPlaceholders.push(value[i]);
+            }
+
+            value = arrWithPlaceholders;
+        }
+
+        return value;
+    };
+};
+
+
+internals.annotate = function () {
+
+    var obj = Hoek.clone(this._object || {});
+
+    var lookup = {};
+    var el = this.details.length;
+    for (var e = el - 1; e >= 0; --e) {        // Reverse order to process deepest child first
+        var pos = el - e;
+        var error = this.details[e];
+        var path = error.path.split('.');
+        var ref = obj;
+        for (var i = 0, il = path.length; i < il && ref; ++i) {
+            var seg = path[i];
+            if (i + 1 < il) {
+                ref = ref[seg];
+            }
+            else {
+                var value = ref[seg];
+                if (Array.isArray(ref)) {
+                    var arrayLabel = '_$idx$_' + (e + 1) + '_$end$_';
+                    if (!ref.placeholders) {
+                        ref.placeholders = {};
+                    }
+
+                    if (ref.placeholders[seg]) {
+                        ref.placeholders[seg] = ref.placeholders[seg].replace('_$end$_', ', ' + (e + 1) + '_$end$_');
+                    }
+                    else {
+                        ref.placeholders[seg] = arrayLabel;
+                    }
+                } else {
+                    if (value !== undefined) {
+                        delete ref[seg];
+                        var objectLabel = seg + '_$key$_' + pos + '_$end$_';
+                        ref[objectLabel] = value;
+                        lookup[error.path] = objectLabel;
+                    }
+                    else if (lookup[error.path]) {
+                        var replacement = lookup[error.path];
+                        var appended = replacement.replace('_$end$_', ', ' + pos + '_$end$_');
+                        ref[appended] = ref[replacement];
+                        lookup[error.path] = appended;
+                        delete ref[replacement];
+                    }
+                    else {
+                        ref['_$miss$_' + seg + '|' + pos + '_$end$_'] = '__missing__';
+                    }
+                }
+            }
+        }
+    }
+
+    var message = internals.safeStringify(obj, 2)
+        .replace(/_\$key\$_([, \d]+)_\$end\$_\"/g, function ($0, $1) {
+
+            return '" \u001b[31m[' + $1 + ']\u001b[0m';
+        }).replace(/\"_\$miss\$_([^\|]+)\|(\d+)_\$end\$_\"\: \"__missing__\"/g, function ($0, $1, $2) {
+
+            return '\u001b[41m"' + $1 + '"\u001b[0m\u001b[31m [' + $2 + ']: -- missing --\u001b[0m';
+        }).replace(/\s*\"_\$idx\$_([, \d]+)_\$end\$_\",?\n(.*)/g, function ($0, $1, $2) {
+
+            return '\n' + $2 + ' \u001b[31m[' + $1 + ']\u001b[0m';
+        });
+
+    message += '\n\u001b[31m';
+
+    for (e = 0; e < el; ++e) {
+        message += '\n[' + (e + 1) + '] ' + this.details[e].message;
+    }
+
+    message += '\u001b[0m';
+
+    return message;
+};

@@ -0,0 +1,152 @@
+// Load modules
+
+var Any = require('./any');
+var Cast = require('./cast');
+var Ref = require('./ref');
+
+
+// Declare internals
+
+var internals = {
+    alternatives: require('./alternatives'),
+    array: require('./array'),
+    boolean: require('./boolean'),
+    binary: require('./binary'),
+    date: require('./date'),
+    number: require('./number'),
+    object: require('./object'),
+    string: require('./string')
+};
+
+
+internals.root = function () {
+
+    var any = new Any();
+
+    var root = any.clone();
+    root.any = function () {
+
+        return any;
+    };
+
+    root.alternatives = root.alt = function () {
+
+        return arguments.length ? internals.alternatives.try.apply(internals.alternatives, arguments) : internals.alternatives;
+    };
+
+    root.array = function () {
+
+        return internals.array;
+    };
+
+    root.boolean = root.bool = function () {
+
+        return internals.boolean;
+    };
+
+    root.binary = function () {
+
+        return internals.binary;
+    };
+
+    root.date = function () {
+
+        return internals.date;
+    };
+
+    root.func = function () {
+
+        return internals.object._func();
+    };
+
+    root.number = function () {
+
+        return internals.number;
+    };
+
+    root.object = function () {
+
+        return arguments.length ? internals.object.keys.apply(internals.object, arguments) : internals.object;
+    };
+
+    root.string = function () {
+
+        return internals.string;
+    };
+
+    root.ref = function () {
+
+        return Ref.create.apply(null, arguments);
+    };
+
+    root.isRef = function (ref) {
+
+        return Ref.isRef(ref);
+    };
+
+    root.validate = function (value /*, [schema], [options], callback */) {
+
+        var last = arguments[arguments.length - 1];
+        var callback = typeof last === 'function' ? last : null;
+
+        var count = arguments.length - (callback ? 1 : 0);
+        if (count === 1) {
+            return any.validate(value, callback);
+        }
+
+        var options = count === 3 ? arguments[2] : {};
+        var schema = root.compile(arguments[1]);
+
+        return schema._validateWithOptions(value, options, callback);
+    };
+
+    root.describe = function () {
+
+        var schema = arguments.length ? root.compile(arguments[0]) : any;
+        return schema.describe();
+    };
+
+    root.compile = function (schema) {
+
+        try {
+            return Cast.schema(schema);
+        }
+        catch (err) {
+            if (err.hasOwnProperty('path')) {
+                err.message += '(' + err.path + ')';
+            }
+            throw err;
+        }
+    };
+
+    root.assert = function (value, schema, message) {
+
+        root.attempt(value, schema, message);
+    };
+
+    root.attempt = function (value, schema, message) {
+
+        var result = root.validate(value, schema);
+        var error = result.error;
+        if (error) {
+            if (!message) {
+                error.message = error.annotate();
+                throw error;
+            }
+
+            if (!(message instanceof Error)) {
+                error.message = message + ' ' + error.annotate();
+                throw error;
+            }
+
+            throw message;
+        }
+
+        return result.value;
+    };
+
+    return root;
+};
+
+
+module.exports = internals.root();

@@ -0,0 +1,125 @@
+// Load modules
+
+
+// Declare internals
+
+var internals = {};
+
+
+exports.errors = {
+    root: 'value',
+    key: '"{{!key}}" ',
+    messages: {
+        wrapArrays: true
+    },
+    any: {
+        unknown: 'is not allowed',
+        invalid: 'contains an invalid value',
+        empty: 'is not allowed to be empty',
+        required: 'is required',
+        allowOnly: 'must be one of {{valids}}',
+        default: 'threw an error when running default method'
+    },
+    alternatives: {
+        base: 'not matching any of the allowed alternatives'
+    },
+    array: {
+        base: 'must be an array',
+        includes: 'at position {{pos}} does not match any of the allowed types',
+        includesSingle: 'single value of "{{!key}}" does not match any of the allowed types',
+        includesOne: 'at position {{pos}} fails because {{reason}}',
+        includesOneSingle: 'single value of "{{!key}}" fails because {{reason}}',
+        includesRequiredUnknowns: 'does not contain {{unknownMisses}} required value(s)',
+        includesRequiredKnowns: 'does not contain {{knownMisses}}',
+        includesRequiredBoth: 'does not contain {{knownMisses}} and {{unknownMisses}} other required value(s)',
+        excludes: 'at position {{pos}} contains an excluded value',
+        excludesSingle: 'single value of "{{!key}}" contains an excluded value',
+        min: 'must contain at least {{limit}} items',
+        max: 'must contain less than or equal to {{limit}} items',
+        length: 'must contain {{limit}} items',
+        ordered: 'at position {{pos}} fails because {{reason}}',
+        orderedLength: 'at position {{pos}} fails because array must contain at most {{limit}} items',
+        sparse: 'must not be a sparse array',
+        unique: 'position {{pos}} contains a duplicate value'
+    },
+    boolean: {
+        base: 'must be a boolean'
+    },
+    binary: {
+        base: 'must be a buffer or a string',
+        min: 'must be at least {{limit}} bytes',
+        max: 'must be less than or equal to {{limit}} bytes',
+        length: 'must be {{limit}} bytes'
+    },
+    date: {
+        base: 'must be a number of milliseconds or valid date string',
+        min: 'must be larger than or equal to "{{limit}}"',
+        max: 'must be less than or equal to "{{limit}}"',
+        isoDate: 'must be a valid ISO 8601 date',
+        ref: 'references "{{ref}}" which is not a date'
+    },
+    function: {
+        base: 'must be a Function'
+    },
+    object: {
+        base: 'must be an object',
+        child: 'child "{{!key}}" fails because {{reason}}',
+        min: 'must have at least {{limit}} children',
+        max: 'must have less than or equal to {{limit}} children',
+        length: 'must have {{limit}} children',
+        allowUnknown: 'is not allowed',
+        with: 'missing required peer "{{peer}}"',
+        without: 'conflict with forbidden peer "{{peer}}"',
+        missing: 'must contain at least one of {{peers}}',
+        xor: 'contains a conflict between exclusive peers {{peers}}',
+        or: 'must contain at least one of {{peers}}',
+        and: 'contains {{present}} without its required peers {{missing}}',
+        nand: '!!"{{main}}" must not exist simultaneously with {{peers}}',
+        assert: '!!"{{ref}}" validation failed because "{{ref}}" failed to {{message}}',
+        rename: {
+            multiple: 'cannot rename child "{{from}}" because multiple renames are disabled and another key was already renamed to "{{to}}"',
+            override: 'cannot rename child "{{from}}" because override is disabled and target "{{to}}" exists'
+        },
+        type: 'must be an instance of "{{type}}"'
+    },
+    number: {
+        base: 'must be a number',
+        min: 'must be larger than or equal to {{limit}}',
+        max: 'must be less than or equal to {{limit}}',
+        less: 'must be less than {{limit}}',
+        greater: 'must be greater than {{limit}}',
+        float: 'must be a float or double',
+        integer: 'must be an integer',
+        negative: 'must be a negative number',
+        positive: 'must be a positive number',
+        precision: 'must have no more than {{limit}} decimal places',
+        ref: 'references "{{ref}}" which is not a number',
+        multiple: 'must be a multiple of {{multiple}}'
+    },
+    string: {
+        base: 'must be a string',
+        min: 'length must be at least {{limit}} characters long',
+        max: 'length must be less than or equal to {{limit}} characters long',
+        length: 'length must be {{limit}} characters long',
+        alphanum: 'must only contain alpha-numeric characters',
+        token: 'must only contain alpha-numeric and underscore characters',
+        regex: {
+            base: 'with value "{{!value}}" fails to match the required pattern: {{pattern}}',
+            name: 'with value "{{!value}}" fails to match the {{name}} pattern'
+        },
+        email: 'must be a valid email',
+        uri: 'must be a valid uri',
+        uriCustomScheme: 'must be a valid uri with a scheme matching the {{scheme}} pattern',
+        isoDate: 'must be a valid ISO 8601 date',
+        guid: 'must be a valid GUID',
+        hex: 'must only contain hexadecimal characters',
+        hostname: 'must be a valid hostname',
+        lowercase: 'must only contain lowercase characters',
+        uppercase: 'must only contain uppercase characters',
+        trim: 'must not have leading or trailing whitespace',
+        creditCard: 'must be a credit card',
+        ref: 'references "{{ref}}" which is not a number',
+        ip: 'must be a valid ip address with a {{cidr}} CIDR',
+        ipVersion: 'must be a valid ip address of one of the following versions {{version}} with a {{cidr}} CIDR'
+    }
+};

@@ -0,0 +1,184 @@
+// Load modules
+
+var Any = require('./any');
+var Ref = require('./ref');
+var Errors = require('./errors');
+var Hoek = require('hoek');
+
+
+// Declare internals
+
+var internals = {};
+
+
+internals.Number = function () {
+
+    Any.call(this);
+    this._type = 'number';
+    this._invalids.add(Infinity);
+    this._invalids.add(-Infinity);
+};
+
+Hoek.inherits(internals.Number, Any);
+
+internals.compare = function (type, compare) {
+
+    return function (limit) {
+
+        var isRef = Ref.isRef(limit);
+        var isNumber = typeof limit === 'number' && !isNaN(limit);
+
+        Hoek.assert(isNumber || isRef, 'limit must be a number or reference');
+
+        return this._test(type, limit, function (value, state, options) {
+
+            var compareTo;
+            if (isRef) {
+                compareTo = limit(state.parent, options);
+
+                if (!(typeof compareTo === 'number' && !isNaN(compareTo))) {
+                    return Errors.create('number.ref', { ref: limit.key }, state, options);
+                }
+            }
+            else {
+                compareTo = limit;
+            }
+
+            if (compare(value, compareTo)) {
+                return null;
+            }
+
+            return Errors.create('number.' + type, { limit: compareTo, value: value }, state, options);
+        });
+    };
+};
+
+
+internals.Number.prototype._base = function (value, state, options) {
+
+    var result = {
+        errors: null,
+        value: value
+    };
+
+    if (typeof value === 'string' &&
+        options.convert) {
+
+        var number = parseFloat(value);
+        result.value = (isNaN(number) || !isFinite(value)) ? NaN : number;
+    }
+
+    var isNumber = typeof result.value === 'number' && !isNaN(result.value);
+
+    if (options.convert && 'precision' in this._flags && isNumber) {
+
+        // This is conceptually equivalent to using toFixed but it should be much faster
+        var precision = Math.pow(10, this._flags.precision);
+        result.value = Math.round(result.value * precision) / precision;
+    }
+
+    result.errors = isNumber ? null : Errors.create('number.base', null, state, options);
+    return result;
+};
+
+
+internals.Number.prototype.min = internals.compare('min', function (value, limit) {
+
+    return value >= limit;
+});
+
+
+internals.Number.prototype.max = internals.compare('max', function (value, limit) {
+
+    return value <= limit;
+});
+
+
+internals.Number.prototype.greater = internals.compare('greater', function (value, limit) {
+
+    return value > limit;
+});
+
+
+internals.Number.prototype.less = internals.compare('less', function (value, limit) {
+
+    return value < limit;
+});
+
+
+internals.Number.prototype.multiple = function (base) {
+
+    Hoek.assert(Hoek.isInteger(base), 'multiple must be an integer');
+    Hoek.assert(base > 0, 'multiple must be greater than 0');
+
+    return this._test('multiple', base, function (value, state, options) {
+
+        if (value % base === 0) {
+            return null;
+        }
+
+        return Errors.create('number.multiple', { multiple: base, value: value }, state, options);
+    });
+};
+
+
+internals.Number.prototype.integer = function () {
+
+    return this._test('integer', undefined, function (value, state, options) {
+
+        return Hoek.isInteger(value) ? null : Errors.create('number.integer', { value: value }, state, options);
+    });
+};
+
+
+internals.Number.prototype.negative = function () {
+
+    return this._test('negative', undefined, function (value, state, options) {
+
+        if (value < 0) {
+            return null;
+        }
+
+        return Errors.create('number.negative', { value: value }, state, options);
+    });
+};
+
+
+internals.Number.prototype.positive = function () {
+
+    return this._test('positive', undefined, function (value, state, options) {
+
+        if (value > 0) {
+            return null;
+        }
+
+        return Errors.create('number.positive', { value: value }, state, options);
+    });
+};
+
+
+internals.precisionRx = /(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
+
+
+internals.Number.prototype.precision = function (limit) {
+
+    Hoek.assert(Hoek.isInteger(limit), 'limit must be an integer');
+    Hoek.assert(!('precision' in this._flags), 'precision already set');
+
+    var obj = this._test('precision', limit, function (value, state, options){
+
+        var places = value.toString().match(internals.precisionRx);
+        var decimals = Math.max((places[1] ? places[1].length : 0) - (places[2] ? parseInt(places[2], 10) : 0), 0);
+        if (decimals <= limit) {
+            return null;
+        }
+
+        return Errors.create('number.precision', { limit: limit, value: value }, state, options);
+    });
+
+    obj._flags.precision = limit;
+    return obj;
+};
+
+
+module.exports = new internals.Number();

@@ -0,0 +1,754 @@
+// Load modules
+
+var Hoek = require('hoek');
+var Topo = require('topo');
+var Any = require('./any');
+var Cast = require('./cast');
+var Errors = require('./errors');
+
+
+// Declare internals
+
+var internals = {};
+
+
+internals.Object = function () {
+
+    Any.call(this);
+    this._type = 'object';
+    this._inner.children = null;
+    this._inner.renames = [];
+    this._inner.dependencies = [];
+    this._inner.patterns = [];
+};
+
+Hoek.inherits(internals.Object, Any);
+
+
+internals.Object.prototype._base = function (value, state, options) {
+
+    var item, key, localState, result;
+    var target = value;
+    var errors = [];
+    var finish = function () {
+
+        return {
+            value: target,
+            errors: errors.length ? errors : null
+        };
+    };
+
+    if (typeof value === 'string' &&
+        options.convert) {
+
+        try {
+            value = JSON.parse(value);
+        }
+        catch (parseErr) { }
+    }
+
+    var type = this._flags.func ? 'function' : 'object';
+    if (!value ||
+        typeof value !== type ||
+        Array.isArray(value)) {
+
+        errors.push(Errors.create(type + '.base', null, state, options));
+        return finish();
+    }
+
+    // Skip if there are no other rules to test
+
+    if (!this._inner.renames.length &&
+        !this._inner.dependencies.length &&
+        !this._inner.children &&                    // null allows any keys
+        !this._inner.patterns.length) {
+
+        target = value;
+        return finish();
+    }
+
+    // Ensure target is a local copy (parsed) or shallow copy
+
+    if (target === value) {
+        if (type === 'object') {
+            target = Object.create(Object.getPrototypeOf(value));
+        }
+        else {
+            target = function () {
+
+                return value.apply(this, arguments);
+            };
+
+            target.prototype = Hoek.clone(value.prototype);
+        }
+
+        var valueKeys = Object.keys(value);
+        for (var t = 0, tl = valueKeys.length; t < tl; ++t) {
+            target[valueKeys[t]] = value[valueKeys[t]];
+        }
+    }
+    else {
+        target = value;
+    }
+
+    // Rename keys
+
+    var renamed = {};
+    for (var r = 0, rl = this._inner.renames.length; r < rl; ++r) {
+        item = this._inner.renames[r];
+
+        if (item.options.ignoreUndefined && target[item.from] === undefined) {
+            continue;
+        }
+
+        if (!item.options.multiple &&
+            renamed[item.to]) {
+
+            errors.push(Errors.create('object.rename.multiple', { from: item.from, to: item.to }, state, options));
+            if (options.abortEarly) {
+                return finish();
+            }
+        }
+
+        if (Object.prototype.hasOwnProperty.call(target, item.to) &&
+            !item.options.override &&
+            !renamed[item.to]) {
+
+            errors.push(Errors.create('object.rename.override', { from: item.from, to: item.to }, state, options));
+            if (options.abortEarly) {
+                return finish();
+            }
+        }
+
+        if (target[item.from] === undefined) {
+            delete target[item.to];
+        }
+        else {
+            target[item.to] = target[item.from];
+        }
+
+        renamed[item.to] = true;
+
+        if (!item.options.alias) {
+            delete target[item.from];
+        }
+    }
+
+    // Validate schema
+
+    if (!this._inner.children &&            // null allows any keys
+        !this._inner.patterns.length &&
+        !this._inner.dependencies.length) {
+
+        return finish();
+    }
+
+    var unprocessed = Hoek.mapToObject(Object.keys(target));
+
+    if (this._inner.children) {
+        for (var i = 0, il = this._inner.children.length; i < il; ++i) {
+            var child = this._inner.children[i];
+            key = child.key;
+            item = target[key];
+
+            delete unprocessed[key];
+
+            localState = { key: key, path: (state.path || '') + (state.path && key ? '.' : '') + key, parent: target, reference: state.reference };
+            result = child.schema._validate(item, localState, options);
+            if (result.errors) {
+                errors.push(Errors.create('object.child', { key: key, reason: result.errors }, localState, options));
+
+                if (options.abortEarly) {
+                    return finish();
+                }
+            }
+
+            if (child.schema._flags.strip || (result.value === undefined && result.value !== item)) {
+                delete target[key];
+            }
+            else if (result.value !== undefined) {
+                target[key] = result.value;
+            }
+        }
+    }
+
+    // Unknown keys
+
+    var unprocessedKeys = Object.keys(unprocessed);
+    if (unprocessedKeys.length &&
+        this._inner.patterns.length) {
+
+        for (i = 0, il = unprocessedKeys.length; i < il; ++i) {
+            key = unprocessedKeys[i];
+
+            for (var p = 0, pl = this._inner.patterns.length; p < pl; ++p) {
+                var pattern = this._inner.patterns[p];
+
+                if (pattern.regex.test(key)) {
+                    delete unprocessed[key];
+
+                    item = target[key];
+                    localState = { key: key, path: (state.path ? state.path + '.' : '') + key, parent: target, reference: state.reference };
+                    result = pattern.rule._validate(item, localState, options);
+                    if (result.errors) {
+                        errors.push(Errors.create('object.child', { key: key, reason: result.errors }, localState, options));
+
+                        if (options.abortEarly) {
+                            return finish();
+                        }
+                    }
+
+                    if (result.value !== undefined) {
+                        target[key] = result.value;
+                    }
+                }
+            }
+        }
+
+        unprocessedKeys = Object.keys(unprocessed);
+    }
+
+    if ((this._inner.children || this._inner.patterns.length) && unprocessedKeys.length) {
+        if (options.stripUnknown ||
+            options.skipFunctions) {
+
+            for (var k = 0, kl = unprocessedKeys.length; k < kl; ++k) {
+                key = unprocessedKeys[k];
+
+                if (options.stripUnknown) {
+                    delete target[key];
+                    delete unprocessed[key];
+                }
+                else if (typeof target[key] === 'function') {
+                    delete unprocessed[key];
+                }
+            }
+
+            unprocessedKeys = Object.keys(unprocessed);
+        }
+
+        if (unprocessedKeys.length &&
+            (this._flags.allowUnknown !== undefined ? !this._flags.allowUnknown : !options.allowUnknown)) {
+
+            for (var e = 0, el = unprocessedKeys.length; e < el; ++e) {
+                errors.push(Errors.create('object.allowUnknown', null, { key: unprocessedKeys[e], path: state.path + (state.path ? '.' : '') + unprocessedKeys[e] }, options));
+            }
+        }
+    }
+
+    // Validate dependencies
+
+    for (var d = 0, dl = this._inner.dependencies.length; d < dl; ++d) {
+        var dep = this._inner.dependencies[d];
+        var err = internals[dep.type](dep.key !== null && value[dep.key], dep.peers, target, { key: dep.key, path: (state.path || '') + (dep.key ? '.' + dep.key : '') }, options);
+        if (err) {
+            errors.push(err);
+            if (options.abortEarly) {
+                return finish();
+            }
+        }
+    }
+
+    return finish();
+};
+
+
+internals.Object.prototype._func = function () {
+
+    var obj = this.clone();
+    obj._flags.func = true;
+    return obj;
+};
+
+
+internals.Object.prototype.keys = function (schema) {
+
+    Hoek.assert(schema === null || schema === undefined || typeof schema === 'object', 'Object schema must be a valid object');
+    Hoek.assert(!schema || !schema.isJoi, 'Object schema cannot be a joi schema');
+
+    var obj = this.clone();
+
+    if (!schema) {
+        obj._inner.children = null;
+        return obj;
+    }
+
+    var children = Object.keys(schema);
+
+    if (!children.length) {
+        obj._inner.children = [];
+        return obj;
+    }
+
+    var topo = new Topo();
+    var child;
+    if (obj._inner.children) {
+        for (var i = 0, il = obj._inner.children.length; i < il; ++i) {
+            child = obj._inner.children[i];
+
+            // Only add the key if we are not going to replace it later
+            if (children.indexOf(child.key) === -1) {
+                topo.add(child, { after: child._refs, group: child.key });
+            }
+        }
+    }
+
+    for (var c = 0, cl = children.length; c < cl; ++c) {
+        var key = children[c];
+        child = schema[key];
+        try {
+            var cast = Cast.schema(child);
+            topo.add({ key: key, schema: cast }, { after: cast._refs, group: key });
+        }
+        catch (castErr) {
+            if (castErr.hasOwnProperty('path')) {
+                castErr.path = key + '.' + castErr.path;
+            }
+            else {
+                castErr.path = key;
+            }
+            throw castErr;
+        }
+    }
+
+    obj._inner.children = topo.nodes;
+
+    return obj;
+};
+
+
+internals.Object.prototype.unknown = function (allow) {
+
+    var obj = this.clone();
+    obj._flags.allowUnknown = (allow !== false);
+    return obj;
+};
+
+
+internals.Object.prototype.length = function (limit) {
+
+    Hoek.assert(Hoek.isInteger(limit) && limit >= 0, 'limit must be a positive integer');
+
+    return this._test('length', limit, function (value, state, options) {
+
+        if (Object.keys(value).length === limit) {
+            return null;
+        }
+
+        return Errors.create('object.length', { limit: limit }, state, options);
+    });
+};
+
+
+internals.Object.prototype.min = function (limit) {
+
+    Hoek.assert(Hoek.isInteger(limit) && limit >= 0, 'limit must be a positive integer');
+
+    return this._test('min', limit, function (value, state, options) {
+
+        if (Object.keys(value).length >= limit) {
+            return null;
+        }
+
+        return Errors.create('object.min', { limit: limit }, state, options);
+    });
+};
+
+
+internals.Object.prototype.max = function (limit) {
+
+    Hoek.assert(Hoek.isInteger(limit) && limit >= 0, 'limit must be a positive integer');
+
+    return this._test('max', limit, function (value, state, options) {
+
+        if (Object.keys(value).length <= limit) {
+            return null;
+        }
+
+        return Errors.create('object.max', { limit: limit }, state, options);
+    });
+};
+
+
+internals.Object.prototype.pattern = function (pattern, schema) {
+
+    Hoek.assert(pattern instanceof RegExp, 'Invalid regular expression');
+    Hoek.assert(schema !== undefined, 'Invalid rule');
+
+    pattern = new RegExp(pattern.source, pattern.ignoreCase ? 'i' : undefined);         // Future version should break this and forbid unsupported regex flags
+
+    try {
+        schema = Cast.schema(schema);
+    }
+    catch (castErr) {
+        if (castErr.hasOwnProperty('path')) {
+            castErr.message += '(' + castErr.path + ')';
+        }
+
+        throw castErr;
+    }
+
+
+    var obj = this.clone();
+    obj._inner.patterns.push({ regex: pattern, rule: schema });
+    return obj;
+};
+
+
+internals.Object.prototype.with = function (key, peers) {
+
+    return this._dependency('with', key, peers);
+};
+
+
+internals.Object.prototype.without = function (key, peers) {
+
+    return this._dependency('without', key, peers);
+};
+
+
+internals.Object.prototype.xor = function () {
+
+    var peers = Hoek.flatten(Array.prototype.slice.call(arguments));
+    return this._dependency('xor', null, peers);
+};
+
+
+internals.Object.prototype.or = function () {
+
+    var peers = Hoek.flatten(Array.prototype.slice.call(arguments));
+    return this._dependency('or', null, peers);
+};
+
+
+internals.Object.prototype.and = function () {
+
+    var peers = Hoek.flatten(Array.prototype.slice.call(arguments));
+    return this._dependency('and', null, peers);
+};
+
+
+internals.Object.prototype.nand = function () {
+
+    var peers = Hoek.flatten(Array.prototype.slice.call(arguments));
+    return this._dependency('nand', null, peers);
+};
+
+
+internals.Object.prototype.requiredKeys = function (children) {
+
+    children = Hoek.flatten(Array.prototype.slice.call(arguments));
+    return this.applyFunctionToChildren(children, 'required');
+};
+
+
+internals.Object.prototype.optionalKeys = function (children) {
+
+    children = Hoek.flatten(Array.prototype.slice.call(arguments));
+    return this.applyFunctionToChildren(children, 'optional');
+};
+
+
+internals.renameDefaults = {
+    alias: false,                   // Keep old value in place
+    multiple: false,                // Allow renaming multiple keys into the same target
+    override: false                 // Overrides an existing key
+};
+
+
+internals.Object.prototype.rename = function (from, to, options) {
+
+    Hoek.assert(typeof from === 'string', 'Rename missing the from argument');
+    Hoek.assert(typeof to === 'string', 'Rename missing the to argument');
+    Hoek.assert(to !== from, 'Cannot rename key to same name:', from);
+
+    for (var i = 0, il = this._inner.renames.length; i < il; ++i) {
+        Hoek.assert(this._inner.renames[i].from !== from, 'Cannot rename the same key multiple times');
+    }
+
+    var obj = this.clone();
+
+    obj._inner.renames.push({
+        from: from,
+        to: to,
+        options: Hoek.applyToDefaults(internals.renameDefaults, options || {})
+    });
+
+    return obj;
+};
+
+
+internals.groupChildren = function (children) {
+
+    children.sort();
+
+    var grouped = {};
+
+    for (var c = 0, lc = children.length; c < lc; c++) {
+        var child = children[c];
+        Hoek.assert(typeof child === 'string', 'children must be strings');
+        var group = child.split('.')[0];
+        var childGroup = grouped[group] = (grouped[group] || []);
+        childGroup.push(child.substring(group.length + 1));
+    }
+
+    return grouped;
+};
+
+
+internals.Object.prototype.applyFunctionToChildren = function (children, fn, args, root) {
+
+    children = [].concat(children);
+    Hoek.assert(children.length > 0, 'expected at least one children');
+
+    var groupedChildren = internals.groupChildren(children);
+    var obj;
+
+    if ('' in groupedChildren) {
+        obj = this[fn].apply(this, args);
+        delete groupedChildren[''];
+    }
+    else {
+        obj = this.clone();
+    }
+
+    if (obj._inner.children) {
+        root = root ? (root + '.') : '';
+
+        for (var i = 0, il = obj._inner.children.length; i < il; ++i) {
+            var child = obj._inner.children[i];
+            var group = groupedChildren[child.key];
+
+            if (group) {
+                obj._inner.children[i] = {
+                    key: child.key,
+                    _refs: child._refs,
+                    schema: child.schema.applyFunctionToChildren(group, fn, args, root + child.key)
+                };
+
+                delete groupedChildren[child.key];
+            }
+        }
+    }
+
+    var remaining = Object.keys(groupedChildren);
+    Hoek.assert(remaining.length === 0, 'unknown key(s)', remaining.join(', '));
+
+    return obj;
+};
+
+
+internals.Object.prototype._dependency = function (type, key, peers) {
+
+    peers = [].concat(peers);
+    for (var i = 0, li = peers.length; i < li; i++) {
+        Hoek.assert(typeof peers[i] === 'string', type, 'peers must be a string or array of strings');
+    }
+
+    var obj = this.clone();
+    obj._inner.dependencies.push({ type: type, key: key, peers: peers });
+    return obj;
+};
+
+
+internals.with = function (value, peers, parent, state, options) {
+
+    if (value === undefined) {
+        return null;
+    }
+
+    for (var i = 0, il = peers.length; i < il; ++i) {
+        var peer = peers[i];
+        if (!Object.prototype.hasOwnProperty.call(parent, peer) ||
+            parent[peer] === undefined) {
+
+            return Errors.create('object.with', { peer: peer }, state, options);
+        }
+    }
+
+    return null;
+};
+
+
+internals.without = function (value, peers, parent, state, options) {
+
+    if (value === undefined) {
+        return null;
+    }
+
+    for (var i = 0, il = peers.length; i < il; ++i) {
+        var peer = peers[i];
+        if (Object.prototype.hasOwnProperty.call(parent, peer) &&
+            parent[peer] !== undefined) {
+
+            return Errors.create('object.without', { peer: peer }, state, options);
+        }
+    }
+
+    return null;
+};
+
+
+internals.xor = function (value, peers, parent, state, options) {
+
+    var present = [];
+    for (var i = 0, il = peers.length; i < il; ++i) {
+        var peer = peers[i];
+        if (Object.prototype.hasOwnProperty.call(parent, peer) &&
+            parent[peer] !== undefined) {
+
+            present.push(peer);
+        }
+    }
+
+    if (present.length === 1) {
+        return null;
+    }
+
+    if (present.length === 0) {
+        return Errors.create('object.missing', { peers: peers }, state, options);
+    }
+
+    return Errors.create('object.xor', { peers: peers }, state, options);
+};
+
+
+internals.or = function (value, peers, parent, state, options) {
+
+    for (var i = 0, il = peers.length; i < il; ++i) {
+        var peer = peers[i];
+        if (Object.prototype.hasOwnProperty.call(parent, peer) &&
+            parent[peer] !== undefined) {
+            return null;
+        }
+    }
+
+    return Errors.create('object.missing', { peers: peers }, state, options);
+};
+
+
+internals.and = function (value, peers, parent, state, options) {
+
+    var missing = [];
+    var present = [];
+    var count = peers.length;
+    for (var i = 0; i < count; ++i) {
+        var peer = peers[i];
+        if (!Object.prototype.hasOwnProperty.call(parent, peer) ||
+            parent[peer] === undefined) {
+
+            missing.push(peer);
+        }
+        else {
+            present.push(peer);
+        }
+    }
+
+    var aon = (missing.length === count || present.length === count);
+    return !aon ? Errors.create('object.and', { present: present, missing: missing }, state, options) : null;
+};
+
+
+internals.nand = function (value, peers, parent, state, options) {
+
+    var present = [];
+    for (var i = 0, il = peers.length; i < il; ++i) {
+        var peer = peers[i];
+        if (Object.prototype.hasOwnProperty.call(parent, peer) &&
+            parent[peer] !== undefined) {
+
+            present.push(peer);
+        }
+    }
+
+    var values = Hoek.clone(peers);
+    var main = values.splice(0, 1)[0];
+    var allPresent = (present.length === peers.length);
+    return allPresent ? Errors.create('object.nand', { main: main, peers: values }, state, options) : null;
+};
+
+
+internals.Object.prototype.describe = function (shallow) {
+
+    var description = Any.prototype.describe.call(this);
+
+    if (this._inner.children &&
+        !shallow) {
+
+        description.children = {};
+        for (var i = 0, il = this._inner.children.length; i < il; ++i) {
+            var child = this._inner.children[i];
+            description.children[child.key] = child.schema.describe();
+        }
+    }
+
+    if (this._inner.dependencies.length) {
+        description.dependencies = Hoek.clone(this._inner.dependencies);
+    }
+
+    if (this._inner.patterns.length) {
+        description.patterns = [];
+
+        for (var p = 0, pl = this._inner.patterns.length; p < pl; ++p) {
+            var pattern = this._inner.patterns[p];
+            description.patterns.push({ regex: pattern.regex.toString(), rule: pattern.rule.describe() });
+        }
+    }
+
+    return description;
+};
+
+
+internals.Object.prototype.assert = function (ref, schema, message) {
+
+    ref = Cast.ref(ref);
+    Hoek.assert(ref.isContext || ref.depth > 1, 'Cannot use assertions for root level references - use direct key rules instead');
+    message = message || 'pass the assertion test';
+
+    var cast;
+    try {
+        cast = Cast.schema(schema);
+    }
+    catch (castErr) {
+        if (castErr.hasOwnProperty('path')) {
+            castErr.message += '(' + castErr.path + ')';
+        }
+
+        throw castErr;
+    }
+
+    var key = ref.path[ref.path.length - 1];
+    var path = ref.path.join('.');
+
+    return this._test('assert', { cast: cast, ref: ref }, function (value, state, options) {
+
+        var result = cast._validate(ref(value), null, options, value);
+        if (!result.errors) {
+            return null;
+        }
+
+        var localState = Hoek.merge({}, state);
+        localState.key = key;
+        localState.path = path;
+        return Errors.create('object.assert', { ref: localState.path, message: message }, localState, options);
+    });
+};
+
+
+internals.Object.prototype.type = function (constructor, name) {
+
+    Hoek.assert(typeof constructor === 'function', 'type must be a constructor function');
+    name = name || constructor.name;
+
+    return this._test('type', name, function (value, state, options) {
+
+        if (value instanceof constructor) {
+            return null;
+        }
+
+        return Errors.create('object.type', { type: name }, state, options);
+    });
+};
+
+
+module.exports = new internals.Object();