diff --git a/README.md b/README.md
index 00876ad..802d10c 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,4 @@
-# contexture-docs
-Documentation for Contexture
+# Contexture Documentation
+
+This is the complete documentation for [Contexture](https://github.com/smartprocure/contexture).
+
diff --git a/SUMMARY.md b/SUMMARY.md
new file mode 100644
index 0000000..eb2c259
--- /dev/null
+++ b/SUMMARY.md
@@ -0,0 +1,49 @@
+# Table of contents
+
+* [Contexture Documentation](README.md)
+
+## About Contexture
+
+* [What Is Contexture](about-contexture/what-is-contexture.md)
+* [Glossary of Terms](about-contexture/glossary-of-terms.md)
+* [Map of Repos](about-contexture/map-of-repos.md)
+* [Brief History](about-contexture/brief-history.md)
+* [Alternatives & Benchmarks](about-contexture/alternatives-and-benchmarks.md)
+
+## Getting Started
+
+* [Project Setup](getting-started/project-setup.md)
+* [Your First Contexture Script](getting-started/your-first-contexture-script.md)
+* [Connecting to Elasticsearch & MongoDB](getting-started/connecting-to-elasticsearch-and-mongodb.md)
+* [Connecting to Other Databases](getting-started/connecting-to-other-databases.md)
+* [Simple Search Box](getting-started/simple-search-box.md)
+* [Your First Filter](getting-started/your-first-filter.md)
+* [Discovering The Database](getting-started/discovering-the-database.md)
+* [IMDB Index](getting-started/imdb-index.md)
+
+## Querying
+
+* [Contexture DSL](querying/contexture-dsl.md)
+
+## Types and Type Components
+
+* [DIY Types](types-and-type-components/diy-types.md)
+* [ElasticSearch Example Types](types-and-type-components/elasticsearch-example-types.md)
+* [MongoDB Example Types](types-and-type-components/mongodb-example-types.md)
+
+## Other Components
+
+* [Generally Useful Components](other-components/generally-useful-components.md)
+* [Layout Components](other-components/layout-components.md)
+
+## Under the Hood
+
+* [Design Principles](under-the-hood/design-principles.md)
+* [Contexture Core](under-the-hood/contexture-core.md)
+* [Contexture ElasticSearch](under-the-hood/contexture-elasticsearch.md)
+* [Contexture Mongo](under-the-hood/contexture-mongo.md)
+* [Building Your Own Provider](under-the-hood/building-your-own-provider.md)
+* [Contexture Client](under-the-hood/contexture-client.md)
+* [Reactors](under-the-hood/reactors.md)
+* [Contexture React](under-the-hood/contexture-react.md)
+
diff --git a/about-contexture/alternatives-and-benchmarks.md b/about-contexture/alternatives-and-benchmarks.md
new file mode 100644
index 0000000..de6a452
--- /dev/null
+++ b/about-contexture/alternatives-and-benchmarks.md
@@ -0,0 +1,4 @@
+# Alternatives & Benchmarks
+
+TODO
+
diff --git a/about-contexture/brief-history.md b/about-contexture/brief-history.md
new file mode 100644
index 0000000..1da679a
--- /dev/null
+++ b/about-contexture/brief-history.md
@@ -0,0 +1,4 @@
+# Brief History
+
+TODO
+
diff --git a/about-contexture/glossary-of-terms.md b/about-contexture/glossary-of-terms.md
new file mode 100644
index 0000000..108c9e6
--- /dev/null
+++ b/about-contexture/glossary-of-terms.md
@@ -0,0 +1,53 @@
+# Glossary of Terms
+
+## Contexture
+
+> NOUN 1. The fact or manner of being woven or linked together to form a connected whole.
+> 1.1. A mass of things interwoven together; a fabric.
+> 1.2. The putting together of words and sentences in connected composition; the construct of a text.
+> 1.3. A connected literary structure; a continuous text.
+
+[Source](https://en.oxforddictionaries.com/definition/us/contexture).
+
+## Domain-Specific Language \(DSL\)
+
+> A domain-specific language \(DSL\) is a computer language specialized to a particular application domain. This is in contrast to a general-purpose language \(GPL\), which is broadly applicable across domains.
+
+[Source](https://en.wikipedia.org/wiki/Domain-specific_language).
+
+## Search Query
+
+According to Wikipedia, `Search Query`, in the context of the `web`, refers to:
+
+> ...a query that a user enters into a web search engine to satisfy his or her information needs. Web search queries are distinctive in that they are often plain text or hypertext with optional search-directives \(such as "and"/"or" with "-" to exclude\). They vary greatly from standard query languages, which are governed by strict syntax rules as command languages with keyword or positional parameters.
+
+[Source](https://en.wikipedia.org/wiki/Web_search_query).
+
+## Faceted Search
+
+> Faceted search, also known as faceted navigation or faceted browsing, is a technique used by eCommerce brands to help users analyze, organize, and filter large sets of product inventory based on filters such as size, color, price, and brand.
+
+[Source](https://www.dynamicyield.com/glossary/faceted-search/).
+
+> Faceted search, also called faceted navigation or faceted browsing, is a technique for accessing information organized according to a faceted classification system, allowing users to explore a collection of information by applying multiple filters. A faceted classification system classifies each information element along multiple explicit dimensions, called facets, enabling the classifications to be accessed and ordered in multiple ways rather than in a single, pre-determined, taxonomic order.
+
+[Source](https://en.wikipedia.org/wiki/Faceted_search).
+
+## Search Filter
+
+> An extension of faceted search, a search filter is a specific product attribute a visitor can use to refine the search results of a particular category listing, e.g. by size, color, price, or brand. Multiple filters may be applied to take a broad range of products and refine them into a more narrow selection, allowing the end user to retrieve the most relevant search results based on the criteria they’ve selected.
+
+[Source](https://www.dynamicyield.com/glossary/search-filter/).
+
+## Configuration Based Development
+
+> The difference between configuration-driven development and model-driven development is that the former is not restricted to the model of the code such as classes, fields, and relationships. Configuration-driven development \(CCD\) encompasses anything that can be configured within your application. For example, if your architecture dictates that particular business rules must be applied consistently across your application, you can use configuration files to configure and apply those rules.
+
+[Source](https://www.ibm.com/developerworks/library/wa-configdev/index.html).
+
+## Functional Logic Programming
+
+> Functional logic programming is the combination, in a single programming language, of the paradigms of functional programming \(including higher-order programming\) and logic programming \(nondeterministic programming, unification\). This style of programming is embodied by various programming languages, including Curry and Mercury.
+
+[Source](https://en.wikipedia.org/wiki/Functional_logic_programming).
+
diff --git a/about-contexture/map-of-repos.md b/about-contexture/map-of-repos.md
new file mode 100644
index 0000000..057e155
--- /dev/null
+++ b/about-contexture/map-of-repos.md
@@ -0,0 +1,40 @@
+# Map of Repos
+
+The Contexture framework comes to life through a list of repositories that individually specialize in some needed layer for our architecture. We will be using most \(if not all\) of these projects in our upcoming pages. Let's explore the repos we have so far:
+
+## Contexture Core
+
+[github.com/smartprocure/contexture](https://github.com/smartprocure/contexture) is where our main DSL processor lives. It is a very small layer that ties everything together. This one receives the information about the different search representations, about the databases involved, and the DSL, then outputs the search results respective to each one of the queries described in a copy of the received DSL.
+
+You can read more about the core here:
+
+* [In the repository](https://github.com/smartprocure/contexture).
+
+## Contexture Providers
+
+The Contexture Providers are the interfacing layer that ties the Contexture DSL to the targeted databases. So far, we have only two open source providers:
+
+* [contexture-elasticsearch](https://github.com/smartprocure/contexture-elasticsearch),
+
+ and
+
+* [contexture-mongo](https://github.com/smartprocure/contexture-mongo).
+
+If you are planning to use either ElasticSearch or MongoDB for your project, the best way to get started is to use those repositories. However, if you need to use Contexture with another database, you will need to implement the provider yourself. We're looking for code contributors, so please don't feel limited to the current available tools. Help us grow together!
+
+## Contexture Client
+
+The Contexture Client is responsible for triggering behaviors on the search interfaces by knowing what causes changes in one or more elements of the search tree. It is the key piece of technology that allows our search interfaces to work in real time.
+
+You can read more about the Contexture Client here:
+
+* [In the repository](https://github.com/smartprocure/contexture-client).
+
+## Contexture React
+
+The Contexture React repository holds a list of components that facilitate building search interfaces. They are mainly graphical representations of the types that exist on our Contexture Providers.
+
+You can read more about the Contexture React:
+
+* [In the repository](https://github.com/smartprocure/contexture-client).
+
diff --git a/about-contexture/what-is-contexture.md b/about-contexture/what-is-contexture.md
new file mode 100644
index 0000000..dfb5838
--- /dev/null
+++ b/about-contexture/what-is-contexture.md
@@ -0,0 +1,14 @@
+# What Is Contexture
+
+People of the Internet, here we officialy introduce you to `contexture`, our framework for building search interfaces.
+
+This framework is carefully designed to be a generic solution for a universe of unlimited possible search interfaces. We've started with a minimal set of repositories that are representative of tools that empower our business, but are intended to be merely examples. If anything, our approaches are only use cases, for the potential of this tool is ultimately yours to take.
+
+A quick search over the Internet would reveal that the word `contexture` means: `the fact or manner of being woven or linked together to form a connected whole` and also `the putting together of words and sentences in connected composition; the construction of a text`.
+
+Picking `contexture` as the name for this project means that we are trying to expose not only our ultimate intentions, but also more or less how the system is built. The way our projects work is by a DSL that is used to gather different intended search inputs, each one representing some useful abstraction of a search filter \(like an input where you can write a word to be searched, or another where you can filter the search results by one or more options\), then using the values to process a DSL that will end up retrieving values from one or more different databases, then returning these values on the respective sections of the DSL, so that each result can update each one of the components of the user interface. A more detailed description is visible in the following diagram.
+
+The canonical example of a Contexture Node is faceted search, where you have a checkbox list that is both a filter \(in the sense that it restricts results based on the checked values\) and an aggregation \(which shows the top n values that can be checked\). Contexture allows them to be nested in advanced searches with boolean joins like `and`/`or`/`not`.
+
+This thought process will become more clear as we progress through the docs. Hopefully, some pages later it will be easy to grasp how we provide a new perspective on building search interfaces, and perhaps even how you can use it to power up your business, just like we have been doing for almost a decade.
+
diff --git a/docs/CNAME b/docs/CNAME
new file mode 100644
index 0000000..d2b8e1f
--- /dev/null
+++ b/docs/CNAME
@@ -0,0 +1 @@
+docs.contexture.site
\ No newline at end of file
diff --git a/docs/index.html b/docs/index.html
new file mode 100644
index 0000000..d04e7f3
--- /dev/null
+++ b/docs/index.html
@@ -0,0 +1,70 @@
+
+
+
+
+
+
+
+
+
+
+ Contexture
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+))
+```
+
+Including this component in our search interface will show the current available cities for the search results we have so far, and will allow users to filter the search even more by letting them pick any \(or many\) of the available cities.
+
diff --git a/getting-started/imdb-index.md b/getting-started/imdb-index.md
new file mode 100644
index 0000000..3469780
--- /dev/null
+++ b/getting-started/imdb-index.md
@@ -0,0 +1,47 @@
+# IMDB Index
+
+In our Contexture React repository, we've created a Storybook live example that uses Contexture \(with no server whatsoever, everything in the client\) to query and discover a public ElasticSearch index with data similar to the data that IMDB might contain.
+
+* [Contexture React Repository](https://github.com/smartprocure/contexture-react).
+* More information about [Storybook](https://github.com/storybooks/storybook).
+* [The IMDB Live Index Explorer with Contexture](https://smartprocure.github.io/contexture-react/?selectedKind=Index%20Explorer&selectedStory=Advanced%20Search).
+* [The IMDB Live Index Explorer Source Code](https://smartprocure.github.io/contexture-react/?selectedKind=Index%20Explorer&selectedStory=Advanced%20Search).
+
+Let's see how we can use this tool.
+
+## Picking a Field
+
+The tool initially shows you a button named `Pick a Field`:
+
+
+
+This button will allow you to select any field on which you might want to run a search. If you click it, you'll see the following fields:
+
+
+
+If we pick `Actors`, for example, the search will trigger and results will appear:
+
+
+
+Now, let's click on `Select Type` and click on `Facet`. A moment afterwards, we will get a list of checkboxes with the most common actors among the results:
+
+
+
+We can see that the actor that has made the most movies \(among the ones idexed\) is Naveen Andrews. We can also see the number of movies this and other actors have made, and the total actors in the database \(of which we can only see 10 in this screenshot\). Under this list of actors, you'll see a text saying `View More`. If you click it, the next 10 actors will appear \(in order\).
+
+At the bottom of the page, you'll see a button labeled `Add Filter`. Clicking it will add another interactive component to the website, which will say `Click to add AND`.
+
+
+
+Clicking the `Click to add AND` button will show us again a `Pick a Field` button:
+
+
+
+So we can start again. Let's say we pick the `Genre` field, and we click for the `Facet` type again. A bit later, the list of ordered genres will appear:
+
+
+
+And that's it! We're discovering the database with a very simple and unpolished interface. By this point you might be curious on what components we're using to do all this magic. There's really no trick, just follow us through the tutorial. You can also skip some steps if you're particularly interested in:
+
+* [Contexture React Repository](https://github.com/smartprocure/contexture-react).
+
diff --git a/getting-started/project-setup.md b/getting-started/project-setup.md
new file mode 100644
index 0000000..35add78
--- /dev/null
+++ b/getting-started/project-setup.md
@@ -0,0 +1,58 @@
+# Project Setup
+
+The whole Contexture Framework is available through NPM. It doesn't have any extra dependency besides Node 9 and some NPM repositories.
+
+**Note:** as you progress through our documentation, you'll discover that in some cases, you will need only one or two of these repositories. This page just provides the fastest way to start that we couldcome up with.
+
+## Installing Node 9 and NPM
+
+NodeJS 9 and NPM can be installed through [the list of previous releases of NodeJS](https://nodejs.org/en/download/releases/). You might get it working with Node 10 \(if so, let us know\). We haven't fully upgraded to Node 10 yet, so until then, we encourage you to at least have a working version of Node 9 in hand.
+
+An easy way to move from one version to another is with [nvm](https://github.com/creationix/nvm). Here's a command you can run to install nvm:
+
+```text
+curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.11/install.sh | bash
+```
+
+Please follow [nvm's README](https://github.com/creationix/nvm/blob/master/README.md) for more information.
+
+## Installing Contexture
+
+Once you have NodeJS and NPM installed, you'll need either a new folder for your new project with Contexture, or to go to an existing project, then run:
+
+```text
+npm install --save contexture
+```
+
+## Installing Contexture Client
+
+To install the `contexture-client` you can run the following command in your project's root folder:
+
+```text
+npm install --save contexture-client
+```
+
+## Installing Contexture ElasticSearch
+
+To install the `contexture-elasticsearch` you can also run the following command in your project's root folder:
+
+```text
+npm install --save contexture-elasticsearch
+```
+
+## Installing Contexture Mongo
+
+To install the `contexture-mongo` you can also run the following command in your project's root folder:
+
+```text
+npm install --save contexture-mongo
+```
+
+## Installing Contexture React
+
+To install the `contexture-react` you can also run the following command in your project's root folder:
+
+```text
+npm install --save contexture-react
+```
+
diff --git a/getting-started/simple-search-box.md b/getting-started/simple-search-box.md
new file mode 100644
index 0000000..95a4d85
--- /dev/null
+++ b/getting-started/simple-search-box.md
@@ -0,0 +1,188 @@
+# Simple Search Box
+
+Building a simple search box consists of a single input field tied to any of the fields that any record might have in the specified database or index. To be able to make this text input tied to the search structure, we will need to bring `contexture-client` in. With that in mind, and the knowledge we already have of contexture, we can define the following tasks:
+
+1. Create a New Contexture Search Function.
+2. Create a Web Server With a Search Endpoint
+3. Write a Search Tree.
+4. Make the Search Tree Aware of Contexture.
+5. Write a Text Input.
+
+Let's dive in.
+
+## 1. Creating a New Conteture Search Function
+
+Just as how we saw in the previous pages, creating a new Contexture search function is about setting up the `contexture` package's default export with `schemas` and `providers`. In this case, we'll use the contexture-mongo approach in the following file \(let's call it `search.js`\):
+
+```javascript
+let Contexture = require('contexture')
+let provider = require('contexture-mongo')
+let types = require('contexture-mongo/types')
+let MongoClient = require('mongodb').MongoClient
+
+let schemas = {
+ collectionNameSchema: {
+ mongo: {
+ collection: 'collectionName'
+ }
+ }
+}
+
+module.exports = {}
+
+MongoClient.connect('mongodb://localhost:27017', function(err, client) {
+ module.exports.search = Contexture({
+ schemas,
+ providers: {
+ mongo: provider({
+ getClient: () => client,
+ types: types()
+ })
+ }
+ })
+})
+```
+
+Note that we're now exporting the search function with `module.exports.search = Contexture(...`. You can also note that we specified the schema's name to be `collectionNameSchema`, and that any search using this schema will be using MongoDb's `collectionName` collection.
+
+## 2. Create a Web Server With a Search Endpoint
+
+If we want to separate the direct access to the database from the client, the previous code should live in the server. Our next step is to expose a `/search` endpoint so our future client can reach this function. In this section, we'll write a simple web server with `express` to satisfy our needs.
+
+### 2.1. Installing the Dependencies
+
+You'll need to install `express` and `body-parser` at the root of your project, as follows:
+
+```text
+npm install --save express body-parser
+```
+
+### 2.2. Writing the Web Server
+
+Once you have the dependencies installed, you can set up the server with the following code:
+
+```javascript
+let express = require('express')
+let bodyParser = require('body-parser')
+let search = require('./search')
+let app = express()
+
+// create application/json parser
+lete jsonParser = bodyParser.json()
+
+app.post('/search', jsonParser, (req, res) => {
+ if (!req.body || !req.body.search) return res.sendStatus(400)
+ search(req.body.search).then((err, result) => {
+ if (err) return res.send(401, err)
+ res.send(200, result)
+ })
+})
+
+app.listen(3000)
+```
+
+You can read more about these topics in the following links:
+
+* [Express Documentation](https://expressjs.com/en/api.html).
+* [body-parser repository](https://github.com/expressjs/body-parser).
+
+## 3. Writing a Search Tree
+
+Having the DSL processor available through a web server endpoint, we can follow up with the structure of the search interface itself. We'll conceptualize this by writing the Contexture DSL itself.
+
+Let's use the same `searchTree` that we used in our frist script:
+
+```javascript
+let searchTree = {
+ key: 'root',
+ type: 'group',
+ schema: 'collectionNameSchema',
+ children: [{
+ key: 'namequery',
+ type: 'text',
+ field: 'name',
+ operator: 'containsWord',
+ value: 'text we want to match on the field name',
+ }, {
+ key: 'results',
+ type: 'results'
+ }]
+}
+```
+
+Keep in mind that we'll be using `collectionNameSchema` since we already defined a schema with that name on the server's `search.js` file.
+
+You can read more about writing Contexture DSL queries in our Querying documentation.
+
+## 4. Make the Search Tree Aware of Contexture
+
+Having a search tree, we will need `contexture-client` to make it smart enough for the user interface. Let's make sure we have it available in our project with:
+
+```text
+npm install --save contexture-client
+```
+
+We will also use MobX to make it easier to notify our component that the state has changed. For that purpose, we will need to install `mobx` using NPM:
+
+```text
+npm install --save mobx
+```
+
+Since we're heavy users of MobX, `contexture-client` already provides an adapter that we can use out of the box. Knowing this, let's prepare our `contexture-client` to work well with `mobx`, as follows:
+
+```javascript
+let ContextureClient = require('contexture-client')
+let ContextureMobx = require('contexture-react/dist/utils/contexture-mobx')
+
+let types = ContextureClient.exampleTypes
+let service = async search => ({
+ data: await postData('/sarch', { search })
+})
+
+let Contexture = ContextureMobx({
+ types,
+ service,
+})
+```
+
+Note that our service function will be the one responsible for sending the `searchTree` we previously defined to the DSL processor, we can wrap the search tree into a smart object that will later react to both the user input, and the search results.
+
+```javascript
+let contextureSearchTree = Contexture(searchTree)
+```
+
+You can read more about these topics here:
+
+* [MobX](https://mobx.js.org/).
+* [MobX Observers](https://mobx.js.org/refguide/observer-component.html).
+
+## 5. Writing a Text Input
+
+Having the search tree ready allows us to write a `mobx` observer component that will receive the tree and react to the result changes immediately. Here's an example:
+
+```text
+let { observer } = require('mobx')
+let SearchQuery = observer(({ tree }) =>
+ {
+ tree.getNode(['root', 'namequery']).value = e.target.value
+ }}
+ />
+
+let SearchResults = observer(({ tree }) => (
+
+))
+```
+
+Which we would render this way:
+
+```javascript
+
+
+```
+
+This will generate a text input that will trigger a new search every time the contents of the input change. This new search will get the results and show the results in a JSON form \(because of the `JSON.stringify` part\). Ideally, you will not render them in a JSON form, but render them using a list component or table.
+
diff --git a/getting-started/your-first-contexture-script.md b/getting-started/your-first-contexture-script.md
new file mode 100644
index 0000000..9e3beb5
--- /dev/null
+++ b/getting-started/your-first-contexture-script.md
@@ -0,0 +1,144 @@
+# Your First Contexture Script
+
+With everything installed, let's see a simple script that runs a simple one-time search:
+
+```javascript
+let contexture = require('contexture')
+
+let schemas = {
+ collectionNameSchema: {
+ mongo: {
+ collection: 'collectionName'
+ }
+ }
+}
+
+let searchTree = {
+ key: 'root',
+ type: 'group',
+ schema: 'collectionNameSchema',
+ children: [{
+ key: 'namequery',
+ type: 'text',
+ field: 'name',
+ operator: 'containsWord',
+ value: 'text we want to match on the field name',
+ }, {
+ key: 'results',
+ type: 'results'
+ }]
+}
+
+let result = await contexture({
+ schemas,
+ providers: {
+ mongo: require('contexture-mongo')({
+ types: require('contexture-mongo/types')(),
+ getClient: () => ({
+ // Fake mongo client.
+ // For this example we only care about
+ // collection().aggregate([...]).toArray() being a promise.
+ collection: name => ({
+ aggregate: aggregations => ({
+ toArray: async () => ['Unrealistic result example']
+ })
+ })
+ })
+ })
+ },
+}, searchTree)
+
+console.log(result.children[1].context.response.results)
+
+// Explore it yourself!
+result
+```
+
+You can also try this same code in Runkit here: [https://runkit.com/sadasant/your-first-contexture-script](https://runkit.com/sadasant/your-first-contexture-script)
+
+## What it does
+
+1. Requiring Contexture
+
+```javascript
+let contexture = require('contexture')
+```
+
+We start by requiring `contexture`. There's nothing much else to see here.
+
+
+
+1. Writing the Schemas
+
+```javascript
+let schemas = {
+ collectionNameSchema: {
+ mongo: {
+ collection: 'collectionName'
+ }
+ }
+}
+```
+
+Immediatly afterwards, we define our schemas. For this specific example, we are going to emulate doing a search on a single collection of a Mongo database. We define `collectionName` as the name of this arbitrary collection. The `schemas` object ends up containing a single schema with a key being `collectionNameSchema`, which is going to be supported by a single provider `mongo`, from which we'll be looking for the `collectionName` collection. We'll learn more about the schemas later on, in Querying → Schemas.
+
+1. Writing the Contexture DSL
+
+```javascript
+let searchTree = {
+ key: 'root',
+ type: 'group',
+ schema: 'collectionNameSchema',
+ children: [{
+ key: 'namequery',
+ type: 'text',
+ field: 'name',
+ operator: 'containsWord',
+ value: 'text we want to match on the field name',
+ }, {
+ key: 'results',
+ type: 'results'
+ }]
+}
+```
+
+Our next step is to define a simple search query using Contexture DSL. This search query will have a mandatory root group, which among other features indicates which schema we will be running this query on \(`collectionNameSchema`\). This node will have two children. The first children is going to be our search query. This query will be a `text` type query. We're indicating that we want to run a plain text search that will try to match any record which `name` contains the word `value`. The next node has the `results` type. This is where the results will be written once the search runs.
+
+1. Getting Results
+
+```javascript
+let result = await contexture({
+ schemas,
+ providers: {
+ mongo: require('contexture-mongo')({
+ types: require('contexture-mongo/types')(),
+ getClient: () => ({
+ // Fake mongo client.
+ // For this example we only care about
+ // collection().aggregate([...]).toArray() being a promise.
+ collection: name => ({
+ aggregate: aggregations => ({
+ toArray: async () => ['Unrealistic result example']
+ })
+ })
+ })
+ })
+ },
+}, searchTree)
+```
+
+The next thing we do is to actually run a one-time search. In this case, we `await` for `contexture`, passing along some very important parameters. First, we pass the schemas we previously defined. Then, we pass a providers object, which has the provider for `mongo`. This `mongo` key will be matched against the `mongo` key that we defined in the schemas, so you could change this property name to something entirely different. When we send the mongo provider, we assign the result of the initialization of `contexture-mongo`, where we send the `contxture-mongo/types` \(which **needs to be called as a function once required**\) and a `getClient` function. In a real schenario, you would just send the object that results of `require('mongodb')`. However, to provide an exceutable example in the browser, we've made a very small Mock of MongoDB where we will return a same object for any collection call, which will only allow fake aggregations, which will have a promise `toArray` function that will return our `Unrealistic result example`.
+
+Keep in mind that since `contexture` returns a promise, you can change `await contexture({ /* .. */ })` to `contexture({ /* .. */ }).then()`, but you'll need to move the code that we have after the await call into the function that is passed on the `.then()` call.
+
+1. Exploring the Results
+
+```javascript
+console.log(result.children[1].context.response.results)
+
+// Explore it yourself!
+result
+```
+
+Finally, we can use our search result! The output of the search will be added to a copy of the original search query. The location of this result will be in the children of the `root` node that has the `results` type, within a `context` object, within a `response` object, on a `results` property. This whole object is going to be exposed in the _runkit_ example for you to play with it. For more information, you can dive in here:
+
diff --git a/getting-started/your-first-filter.md b/getting-started/your-first-filter.md
new file mode 100644
index 0000000..c6aa621
--- /dev/null
+++ b/getting-started/your-first-filter.md
@@ -0,0 +1,58 @@
+# Your First Filter
+
+In the previous page, we wrote a simple search user interface where a single input would retrieve results. Now, we will add a simple filter that will allow us to get results within a given range.
+
+## Adding the Filter to the Tree
+
+The way we will add the filter is by adding a node to the tree. This node is going to have a type of `number`, which asks for a `field`, a `min` and a `max` values.
+
+```javascript
+let searchTree = {
+ key: 'root',
+ type: 'group',
+ schema: 'collectionNameSchema',
+ children: [{
+ key: 'namequery',
+ type: 'text',
+ field: 'name',
+ operator: 'containsWord',
+ value: 'text we want to match on the field name',
+ }, {
+ key: 'numberrange',
+ type: 'number',
+ field: 'age',
+ min: 0,
+ max: 100
+ }, {
+ key: 'results',
+ type: 'results'
+ }]
+}
+```
+
+With the `numberrange` node added, we can create another component with two inputs that will allow us to filter results with the range that the user specifies:
+
+```javascript
+let RangeComponent = observer(({ tree }) => (
+
+))
+```
+
+And that's it! Rendering this component will make our search aware of any change the user might desire on the minimum and maximum ages they might want to use to filter the available results.
+
diff --git a/other-components/generally-useful-components.md b/other-components/generally-useful-components.md
new file mode 100644
index 0000000..42a8082
--- /dev/null
+++ b/other-components/generally-useful-components.md
@@ -0,0 +1,75 @@
+# Generally Useful Components
+
+## ContextureProvider
+
+This component is a magic tool to make Contexture search interfaces without having to write the tree separated. With this component, you can pass the tree directly as a plain object, and any children you pass will receive the `tree` property directly.
+
+This component receives:
+
+| Property Name | Type | Required | Description |
+| :--- | :--- | :--- | :--- |
+| `types` | Object | Yes | Your client-side types, such as the default types of the Contexture Client. |
+| `service` | Object | Yes | The search function that sends the DSL to the initialized Contexture Core. |
+| `nodeKey` | Object | Yes | Key for the root node. Defaults with `root`. |
+| `...props` | Any other property \(children excluded\) | Yes | Any other property that you might want to send to the initialization of the Contexture Client. |
+
+**Note:** Any of the Contexture React Example Types components automatically add the nodes to the tree if the referenced node is not present. _This is an experimental feature_.
+
+Here's how you write your component:
+
+```javascript
+let ContextureProvider = require('contexture-react/dist/ContextureProvider')
+let ContextureClient = require('contexture-client')
+let types = ContextureClient.exampleTypes
+let service = async search => ({
+ data: await postData('/sarch', { search })
+})
+// ...
+// Later, on your render function, or where you put your components:
+
+
+
+```
+
+* [Source code of the ContextureProvider component](https://github.com/smartprocure/contexture-react/blob/master/src/ContextureProvider.js).
+
+## FilterList
+
+A component that tries to automatically render the specific type components of the children of a node.
+
+| Property Name | Type | Required | Description |
+| :--- | :--- | :--- | :--- |
+| `node` | Object | Yes | Node of the Contexture Tree where the children that want to be rendered are. |
+| `exampleTypes` | Object | No | Object which a key and a component per type. Defaults in the available example types components in contexture-elasticsearch. |
+| `fields` | Object | Yes | Object which a key and an object with at least a `label` string property, used to indicate the label of each one of the filters. |
+
+Here's how you write your component:
+
+```javascript
+let FilterList = require('contexture-react/dist/FilterList')
+let ContextureClient = require('contexture-client')
+let tree = ContextureClient({
+ key: 'root',
+ type: 'group',
+ schema: 'mySchema',
+ children: [{
+ key: 'query',
+ type: 'query',
+ field: 'myFieldName',
+ query: 'Something'
+ }]
+})
+// ...
+// Later, on your render function, or where you put your components:
+
+```
+
+* [Source code of the FilterList component](https://github.com/smartprocure/contexture-react/blob/master/src/FilterList.js).
+
diff --git a/other-components/layout-components.md b/other-components/layout-components.md
new file mode 100644
index 0000000..994b299
--- /dev/null
+++ b/other-components/layout-components.md
@@ -0,0 +1,115 @@
+# Layout Components
+
+## Awaiter
+
+Renders a loading indicator until a Promise is resolved. It will ender an exception \(currently just `Ooops...`\) if the Promise fails. if the Promise passes, the children are rendered.
+
+| Property Name | Type | Required | Description |
+| :--- | :--- | :--- | :--- |
+| `promise` | Promise | Yes | Minumum number for the range. |
+
+Here's how you write your component:
+
+```javascript
+let Awaiter = require('contexture-react/dist/layout/Awaiter')
+let promiseMaker = () => new Promise((resolve, reject)) /* ... */ resolve())
+// ...
+// Later, on your render function, or where you put your components:
+
+
My Crazy Children
+
+```
+
+* [Source code of the Awaiter component](https://github.com/smartprocure/contexture-react/blob/master/src/layout/Awaiter.js).
+
+## BarChart
+
+Allows you to build your own bar charts \(besides just relying on the DateHistogram component\).
+
+| Property Name | Type | Default Value | Description |
+| :--- | :--- | :--- | :--- |
+| `valueField` | String | `''` | The field of each record where the value used for the height of each barnis located. |
+| `categoryField` | String | `''` | The field of each record where the label of each bar is located. |
+| `data` | Array \(of Objects with both the `valueField` and the `categoryField`\) | `[]` | The data that is going to be used to build the chart. |
+| `height` | Number | `100` | Specifies the max height of the whole chart. |
+| `format` | Function | `value => undefined` | Allows you to change the value that each one of the bars has. |
+| `gutter` | Number | `5` | Allows you to specify the spacing between bars. |
+| `yAxis` | Boolean | `false` | Allows you to specify wether you want Y axis information or not. |
+
+Here's how you write your component:
+
+```javascript
+let BarChart = require('contexture-react/dist/layout/BarChart')
+// ...
+// Later, on your render function, or where you put your components:
+
+```
+
+* [Source code of the BarChart component](https://github.com/smartprocure/contexture-react/blob/master/src/layout/BarChart.js).
+
+## SpacedList
+
+Wraps every children in a div with a given style. Useful for \(as the name portrays\) making a spaced list.
+
+| Property Name | Type | Required | Description |
+| :--- | :--- | :--- | :--- |
+| `style` | Object | No | The style that will be applied to each div. Defaults in `{ marginBottom: '25px' }`. |
+
+Here's how you write your component:
+
+```javascript
+let SpacedList = require('contexture-react/dist/layout/SpacedList')
+// ...
+// Later, on your render function, or where you put your components:
+
+
Hi
+
+
+```
+
+* [Source code of the SpacedList component](https://github.com/smartprocure/contexture-react/blob/master/src/layout/SpacedList.js).
+
+## TextHighlight
+
+Used to highlight content within a text based on a pattern.
+
+| Property Name | Type | Required | Description |
+| :--- | :--- | :--- | :--- |
+| `pattern` | String | No | RegExp pattern used to find matching content. |
+| `text` | String | Yes | Text used as the target of the matches. |
+| `Wrap` | Component | No | Component used to wrap each one of the |
+
+matched. Defaults to `i`. \|
+
+Here's how you write your component:
+
+```javascript
+let TextHighlight = require('contexture-react/dist/layout/TextHighlight')
+// ...
+// Later, on your render function, or where you put your components:
+
+```
+
+* [Source code of the TextHighlight component](https://github.com/smartprocure/contexture-react/blob/master/src/layout/TextHighlight.js).
+
diff --git a/querying/contexture-dsl.md b/querying/contexture-dsl.md
new file mode 100644
index 0000000..0dce262
--- /dev/null
+++ b/querying/contexture-dsl.md
@@ -0,0 +1,29 @@
+# Contexture DSL
+
+The Contexture DSL is a JavaScript object structure, or JSON structure, that is composed of nested nodes that are equal at all levels. Each node has a `key`, a `type` and many other optional properties. The first node is called the root and is a node of type `group`. Any node of type `group` can have many children. Each children can be a node of any type. If any children is another group, this children will probably have one or more other children nodes of any type, and so on.
+
+Let's begin talking about the root.
+
+## The Root
+
+The root of a Contexture Tree is a node of type `group`. Group types are required to have a `key`, the `type: "group"` property, and an array of children `children: [/* nodes */]`. Root groups also need an extra property: then ame of the schema. In summary, this is how a root node should look:
+
+```javascript
+let searchTree = {
+ key: 'myRootNode',
+ type: 'group',
+ schema: 'mySchemaName',
+ children: [
+ // Other nodes
+ ]
+}
+```
+
+## The Children
+
+Each children will be an individual node. Each node will have at least a unique `key` \(unique per tree, but they can appear again in other trees\), and a `type`. Some types might require more properties.
+
+That's really all that it is for our DSL. The magic happens in the types and the providers. As long as your types are defined properly, and your providers build the correct queries and write them back in the tree, Contexture will work and you'll be able to use the Contexture DSL to build search interfaces of any complexity.
+
+**Note:** Many of the types have some common properties, like `field` or `values`. The only reason these properties are common is because they've made sense to be common for each one of our specific types, not because they have something to share between types. Each type has it's own properties and rules, so you should treat them as independent structures.
+
diff --git a/types-and-type-components/diy-types.md b/types-and-type-components/diy-types.md
new file mode 100644
index 0000000..22bc3a8
--- /dev/null
+++ b/types-and-type-components/diy-types.md
@@ -0,0 +1,137 @@
+# DIY Types
+
+The Contexture ecosystem provides a defined list of types that can be used to perform a wide variety of different searches. Each type we offer also has a respective component in our `contexture-react` repo. We've made these components so you can quickstart your search interfaces!
+
+Even if our types are focused on the different search interfaces we provide, our API is designed to allow you to build any type you might need for any other possible use case you might encounter.
+
+We believe that making a generic framework will allow users to be creative on their search solutions. Because of that, we will start this document by explaining how to build your own types.
+
+Writing a new single type is about writing two plain JavaScript Objects:
+
+* One which is sent to the Contexture Provider.
+* Another one which is sent to the initialization of the Context Tree.
+
+## How to Wite a Provider Type
+
+Initializing Contexture Core requires you to send a bunch of types per provider. A type on any provider is just a valid string property name on the object that is sent, accompanied with a corresponding value of a plain JavaScript Object with one or more of the following properties:
+
+| Property | Type | Params \(Type\) | Return Value Type | What it does |
+| :--- | :--- | :--- | :--- | :--- |
+| `hasValue` | Function | Node \(Object\) | Boolean | Allows Contexture to know wether or not to process this search. |
+| `filter` | Function | Node \(Object\) | Object | Returns a query with the applied input values, which will be sent later to the database provider. |
+| `result` | Function | Node \(Object\), Search \(Function\) | Promise | Allows running a direct search for this type before Comtexture sends the full seaech with the whole tree. |
+
+Once you have written a type, you can use it by sending it to an existing Contexture Provider. It should look more or less like:
+
+```javascript
+let myType = {
+ hasValue: node => node.requiredProperty,
+ filter: node => ({
+ providerQueryObject: {
+ value: node.requiredProperty
+ }
+ })
+}
+
+let provider = MyProvider({
+ types: {
+ myType
+ }
+})
+```
+
+**Type names are not exclusive across providers**. You can define one type called `myAwesomeType` in more than one provider and you'll be able to keep the same required node properties, thus the same `hasValue`. This allows us to provide the same API for several types, and re-use code even if we switch the target database of the search.
+
+Once you have a type defined for one or more providers, you should write the same type for `contexture-client`.
+
+## How to Write a Client Type
+
+Contexture Client already provides a some types based on our `Example Types` \(more on that later.\) These type definitions help the client understand how a specific node affects every other node or itself.
+
+To create a custom type, you will need to think on the behaviors you might need for each one of the following properties:
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `validate` | Function | Just as the Provider Type's `hasValue`, this function will let `contexture-client` know wether this node is valid for processing or not. |
+| `reactors` | Object | The Reactors is how each of the node properties might affect this node or other nodes. See our Introduction to Reactors |
+| `defaults` | Object | This object will help in the initialization of the nodes of the tree of this specific type through the definition of some default values on the specified properties. |
+
+More details about `contexture-client` types, their properties and their reserved words can be seen on the README of [contexture-client](https://github.com/smartprocure/contexture-client#client-types).
+
+The example types are already included in any instantiation of Contexture Client's Contexture Tree. However, you can add any type you need simply by extending the exposed `exampleTypes` with your own. In the following snippet, we initialize a `ContextureTree` with the available `exampleTypes`, and our new `myType`:
+
+```javascript
+import * as ContextureClient from 'contexture-client'
+
+let tree = ContextureClient.ContextTree({
+ types: {
+ ...ContextureClient.exampleTypes,
+ myType: {
+ validate: node => node.requiredProperty,
+ reactors: {
+ requiredProperty: 'others',
+ },
+ defaults: {
+ requiredProperty: false
+ }
+ }
+ }
+}, {
+ // Here we will have the underlying tree
+})
+```
+
+## How to Write a UI Component for a Type
+
+Writing a user interface for any type can be as simple as writing an HTML or JSX Element that will render or modify any property of the any node of an existing Contexture Tree, for example, using our custom type `myType`, we could write an input field that, onChange, will write the field's value into the `requiredProperty`. For example:
+
+```javascript
+// This is ES6+ and JSX
+
+import * as ContextureClient from 'contexture-client'
+
+let tree = ContextureClient.ContextTree(
+ {
+ service: myService,
+ types: {
+ ...ContextureClient.exampleTypes,
+ myType: {
+ validate: node => node.requiredProperty,
+ reactors: {
+ requiredProperty: 'others',
+ },
+ defaults: {
+ requiredProperty: false
+ }
+ }
+ }
+ }, {
+ key: 'root',
+ join: 'and',
+ children: [{
+ key: 'myNode',
+ type: 'myType',
+ }]
+ }
+)
+
+let node = tree.getNode(['root', 'myNode'])
+
+let Component = ({ node }) => (
+ {
+ node.requiredProperty = e.target.value
+ }}
+ />
+)
+```
+
+Now that you have a component you can render it and play with it, but the component won't render by itself. If you want to see examples of custom components with automatic updates, please look at our Managing State Guide.
+
+## The Example Types
+
+With the intention of providing practical examples of how to write types, we decided to share some of the types we use in our production applications. These types belong to two different database processors: `contexture-elasticsearch` and `contexture-mongo`.
+
+**Example Types aren't the rule**. These types are only provided to serve as a guide to build any other type you might need for your application. You can also **extend our example types**, simply by assigning new types as properties on the objects exposed by `contexture-elasticsearch` and `contexture-mongo`.
+
diff --git a/types-and-type-components/elasticsearch-example-types.md b/types-and-type-components/elasticsearch-example-types.md
new file mode 100644
index 0000000..306c6ae
--- /dev/null
+++ b/types-and-type-components/elasticsearch-example-types.md
@@ -0,0 +1,504 @@
+# ElasticSearch Example Types
+
+Contexture is designed to target any database you might need. However, so far we have only inplemented database providers for the only databases that we use: ElasticSearch and Mongo.
+
+Most of our types have relevant components already written to facilitate building search interfaces. As we progress over each one of these types, we will show small examples of simple components written to search with these types. We hope to provide enough information to allow you to take as little as you need, or as much as you want, and fulfill you expectations.
+
+Our ElasticSearch types are the following ones:
+
+## Results Type
+
+The `results` node is a node that if present, idicates to Contextre that the queries and aggregations should finally run and retrieve all the filtered values. It allows some customization properties, as shown below:
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `page` | Number | Current page of results. |
+| `pageSize` | Number | Total results per page. |
+| `sortField` | String | Field used to sort the results. |
+| `sortDir` | String | Direction of sorting \(`asc`, `desc`\) |
+
+## Bool Type
+
+The bool type is intended to work as an ElasticSearch terms aggregation with only one value for a single property. This is useful for user interfaces with a checkbox to include or exclude a specific field from a search \(or a specific field-value pair\).
+
+Here is the list of all properties this type uses:
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| field | String | Name of the field that we will be using to filter the search search. |
+| value | String | Value of the field that will be used to filter the search. |
+
+Example input:
+
+```javascript
+{
+ type: 'bool',
+ field: 'fieldName',
+ value: true
+}
+```
+
+Example output:
+
+```javascript
+{
+ term: {
+ fieldName: true
+ }
+}
+```
+
+You can read more about it in:
+
+* [Source code of the type: bool](https://github.com/smartprocure/contexture-elasticsearch/blob/master/src/example-types/bool.js).
+* [Unit tests of the type: bool](https://github.com/smartprocure/contexture-elasticsearch/blob/master/test/example-types/bool.js).
+* Elastic Search [Term Query](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-term-query.html).
+
+## Cardinality Type
+
+The Cardinality type serves to calculate an approximate count of the distinct available values. This type only uses one property, `field`. It returns it's values in the `context` of the node, rather than in the `results` node.
+
+Example input:
+
+```javascript
+{
+ type: 'cardinality',
+ field: 'Organization.Name.untouched'
+}
+```
+
+Example output:
+
+```javascript
+{
+ aggs: {
+ cardinality: {
+ cardinality: {
+ field: 'Organization.Name.untouched'
+ }
+ }
+ }
+}
+```
+
+You can read more about it in:
+
+* [Source code of the type: cardinality](https://github.com/smartprocure/contexture-elasticsearch/blob/master/src/example-types/cardinality.js).
+* [Unit tests of the type: cardinality](https://github.com/smartprocure/contexture-elasticsearch/blob/master/test/example-types/cardinality.js).
+* Elastic Search [Cardinality Aggregation](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-cardinality-aggregation.html).
+
+## Date Type
+
+The Date type is used to specify a range of dates that will be used to filter the available results. This range of dates can be specified by a string formatted date \(`YYYY-MM-DD`\) or by a small set of possible humanly readable date ranges. Details follow:
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `from` | String | Either a date formatted as `YYYY-MM-DD`, or an ES date \(formatted properly for ElasticSearch\), or one of the following values: `thisQuarter` \(for the current quarter of the year\), `lastQuarter` \(for the previously completed quarter of the year\), `nextQuarter` \(for the upcoming quarter\). |
+| `to` | String | Optional. Defaults to the current date. Only concidered if there's a `from` value, should be a date formatted as `YYYY-MM-DD` or an ES date \(formatted properly for ElasticSearch\). |
+| `useDateMath` | Boolean | Defines if we should parse `from` as one of the `*Quarter` dates. |
+| `isDateTime` | Boolean | Ignores any processing or formatting and accpets the `form` and `to` values as they come. |
+
+Example input 1:
+
+```javascript
+{
+ type: 'date',
+ field: 'fieldName',
+ from: '2016-04-25'
+}
+```
+
+Example output 1:
+
+```javascript
+{
+ range: {
+ fieldName: {
+ gte: '2016-04-25',
+ format: 'dateOptionalTime'
+ }
+ }
+}
+```
+
+Example input 2:
+
+```javascript
+{
+ type: 'date',
+ field: 'fieldName',
+ from: 'thisQuarter',
+ useDateMath: true,
+}
+```
+
+Example output 2:
+
+```javascript
+{
+ range: {
+ fieldName: {
+ gte: moment().quarter(moment().quarter()).startOf('quarter').format('YYYY-MM-DD'),
+ lte: moment.utc(datemath.parse(`${moment().quarter(moment().quarter()).startOf('quarter').format('YYYY-MM-DD')}||+3M-1d/d`)).format('YYYY-MM-DD'),
+ format: 'dateOptionalTime'
+ }
+ }
+}
+```
+
+You can read more about it in:
+
+* [Source code of the type: date](https://github.com/smartprocure/contexture-elasticsearch/blob/master/src/example-types/date.js).
+* [Unit tests of the type: date](https://github.com/smartprocure/contexture-elasticsearch/blob/master/test/example-types/date.js).
+* Elastic Search [Range QUery](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-range-query.html).
+
+## Date Histogram Type
+
+The `dateHistogram` type is very useful for retrieving the number of results within specific periods of time. The idea here is to end up building a chart showing how records have changed over time, for example by it's creation date or some other date property. This type is able to do this by running a nested stats aggregation inside a dateHistogram aggregation, while also supporting for tweaking min/max bounds.
+
+This type returns it's values in the `context` of the node, rather than in the `results` node.
+
+| Property Name | Type | Description | |
+| :--- | :--- | :--- | :--- |
+| `key_field` | String | What might be considered a good candidate for the X axis of the chart. | |
+| `value_field` | String | What might be considered a good candidate for the Y axis of the chart. | |
+| `interval` | | String | Available expressions for interval: `year` \(`1y`\), `quarter` \(`1q`\), `month` \(`1M`\), `week` \(`1w`\), `day` \(`1d`\), `hour` \(`1h`\), `minute` \(`1m`\), `second` \(`1s`\). |
+| `boundsRange_min` | Date or String | Lower date limit that will be considered to filter the possible results. | |
+| `boundsRange_max` | Date or String | Upper date limit that will be considered to filter the possible results. | |
+| `boundsRange_useDateMath` | Boolean | If set to `true`, the min and max ranges will be valid as strings representative of dates, and will be formatted by NPM's library [`@elastic/datemath`](https://github.com/elastic/datemath-js). | |
+
+Example input:
+
+```javascript
+{
+ type: 'dateHistogram',
+ key_field: 'PO.IssuedDate',
+ value_field: 'LineItem.TotalPrice'
+}
+```
+
+Example output:
+
+```javascript
+{
+ aggs: {
+ max_date: {
+ max: {
+ field: 'PO.IssuedDate',
+ },
+ },
+ min_date: {
+ min: {
+ field: 'PO.IssuedDate',
+ },
+ },
+ twoLevelAgg: {
+ date_histogram: {
+ field: 'PO.IssuedDate',
+ interval: 'year',
+ min_doc_count: 0,
+ },
+ aggs: {
+ twoLevelAgg: {
+ stats: {
+ field: 'LineItem.TotalPrice',
+ },
+ },
+ },
+ },
+ },
+}
+```
+
+You can read more about it in:
+
+* [Source code of the type: dateHistogram](https://github.com/smartprocure/contexture-elasticsearch/blob/master/src/example-types/dateHistogram.js).
+* [Unit tests of the type: dateHistogram](https://github.com/smartprocure/contexture-elasticsearch/blob/master/test/example-types/dateHistogram.js).
+* [Two Level Aggregations in ElasticSearch](https://www.elastic.co/blog/intro-to-aggregations-pt-2-sub-aggregations).
+* [Date Histogram Aggregation in ElasticSearch](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-bucket-datehistogram-aggregation.html).
+
+## Exists Type
+
+The `exists` type is used to check wether some property exsits or not. It requires only two fields: `field` and `value`.
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `field` | String | The target field we want to check. |
+| `value` | Boolean | the value we want to check. Normally true or false. |
+
+Example input:
+
+```javascript
+{
+ type: 'exists',
+ field: 'fieldName',
+ value: true
+}
+```
+
+Example output:
+
+```javascript
+{
+ exists: {
+ field: 'fieldName'
+ }
+}
+```
+
+You can read more about it in:
+
+* [Source code of the type: exists](https://github.com/smartprocure/contexture-elasticsearch/blob/master/src/example-types/exists.js).
+* [Unit tests of the type: exists](https://github.com/smartprocure/contexture-elasticsearch/blob/master/test/example-types/exists.js).
+* Elastic Search [Exists Query](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-exists-query.html).
+
+## Facet Type
+
+The `facet` type represents a list of dynamic choices, e.g. a checkbox list filter. We achieve this by running an ElasticSearch terms aggregation. We provide a way to limit the number of results that you will receive with the `size` property, so that large queries can safely be used. For that same purpose, the property `optionsFilter` is given, so that search queries can filter the results with a string.
+
+Facet returns it's values in the `context` of the node, rather than in the `results` node.
+
+| Property | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `field` | String | None, _required_ | The field it's operating on. |
+| `mode` | String \(`include` or `exclude`\) | `include` | Wether this filter acts as for the inclusion or exclusion of the selected values when picking up what results to keep. |
+| `values` | Array \(of strings\) | `[]` | Already selected values. |
+| `fieldMode` | String \(`autocomplete`, `word` or `suggest`\) | `autocomplete` | Whether to look at the entire field \(`autocomplete`\), the analyzed words in the field \(`word`\), or magic suggestions \(`suggest`\). |
+| `size` | Number | 12 | How many options to return. |
+| `cardinality` | Number | 5000 | Precision threshold override. |
+| `includeZeroes` | Boolean | false | If true, it will include options with 0 matching documents \(aka `min_doc_count: 0`\) |
+| `optionsFilter` | String | '' | Filters the options further, e.g. a find box above a checkbox list |
+| `caseSensitive` | Boolean | false | Whether options filter is case sensitive. |
+| `sort` | String \(`term` or `count`\) | `count` | Sort results alphabetically or by count of matching records. |
+
+Example input 1:
+
+```javascript
+{
+ type: 'facet',
+ field: 'fieldName',
+ values: ['abc', '123']
+}
+```
+
+Example output 1:
+
+```javascript
+{
+ terms: {
+ 'fieldName.untouched': ['abc', '123']
+ }
+}
+```
+
+Example input with exclude:
+
+```javascript
+{
+ type: 'facet',
+ field: 'fieldName',
+ mode: 'exclude',
+ values: ['abc', '123'],
+}
+```
+
+Example output with exclude:
+
+```javascript
+{
+ bool: {
+ must_not: {
+ terms: {
+ 'fieldName.untouched': ['abc', '123'],
+ },
+ },
+ },
+}
+```
+
+You can read more about it in:
+
+* [Source code of the type: facet](https://github.com/smartprocure/contexture-elasticsearch/blob/master/src/example-types/facet.js).
+* [Unit tests of the type: facet](https://github.com/smartprocure/contexture-elasticsearch/blob/master/test/example-types/facet.js).
+* Elastic Search [Terms Query](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-terms-query.html).
+
+## Geo Type
+
+The `geo` type represents a geographic radius search. It needs a geocodeLocation service passed in to it. We currently assume that you will be using a google maps geocoder search.
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `field` | String \(required\) | The field it's operating on |
+| `location` | String \(required\) | Location to geocode \(e.g. an address, businessname, anything the google geocode can take\) |
+| `radius` | Number \(required\) | Radius in miles |
+| `operator` | String \(either `within` or `not within`\) | Whether the filter forces inclusion or exclusion \(defaults with `within`\). |
+
+Example input:
+
+```javascript
+{
+ type: 'geo',
+ field: 'fieldName',
+ location: 'SmartProcure',
+ radius: 10,
+ operator: 'within',
+}
+```
+
+Example output:
+
+```javascript
+{
+ geo_distance: {
+ fieldName: '26.3170479,-80.1131784',
+ distance: '10mi',
+ },
+}
+```
+
+You can read more about it in:
+
+* [Source code of the type: geo](https://github.com/smartprocure/contexture-elasticsearch/blob/master/src/example-types/geo.js).
+* [Unit tests of the type: geo](https://github.com/smartprocure/contexture-elasticsearch/blob/master/test/example-types/geo.js).
+* [ElasticSearch's Geo Distance Query](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-geo-distance-query.html).
+
+## Number Type
+
+Number represents a number range with inclusive bounds. This type provides the ability to determine the best range values based on percentile interval and range threshold.
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `field` | String | The field we will be using to filter the results. |
+| `min` | Number | Lower boundary of the filter. |
+| `max` | Number | Upper boundary of the filter. |
+
+Some Notes: 1. An empty value as the upper boundary represents infinity. 2. An empty value as the lower boundary represents negative infinity. 3. Zero has to be respected as a boundary value. 4. If findBestRange is true it will return the best min and max range.
+
+Example input:
+
+```javascript
+{
+ type: 'number',
+ field: 'fieldName',
+ min: 500,
+ max: 1000,
+}
+```
+
+Example output:
+
+```javascript
+{
+ range: {
+ fieldName: {
+ gte: 500,
+ lte: 1000,
+ },
+ },
+}
+```
+
+You can read more about it in:
+
+* [Source code of the type: number](https://github.com/smartprocure/contexture-elasticsearch/blob/master/src/example-types/number.js).
+* [Unit tests of the type: number](https://github.com/smartprocure/contexture-elasticsearch/blob/master/test/example-types/number.js).
+
+## Number Range Histogram Type
+
+The type `numberRangeHistogram` represents a number range with inclusive bounds. This type returns feedback in the form of histogram and statistical data. This type returns it's values in the `context` of the node, rather than in the `results` node.
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `field` | String | The field we will be using to filter the results. |
+| `min` | Number | Lower boundary of the filter. |
+| `max` | Number | Upper boundary of the filter. |
+| `percentileInterval` | Number | Used to group the results based on how many of the records are within each one of the sections given by the interval, from the `min` value, up to the `max` value. |
+
+Some Notes: 1. An empty value as the upper boundary represents infinity. 2. An empty value as the lower boundary represents negative infinity. 3. Zero has to be respected as a boundary value.
+
+* [Source code of the type: numberRangeHistogram](https://github.com/smartprocure/contexture-elasticsearch/blob/master/src/example-types/numberRangeHistohgram.js).
+* [Histogram Aggregation in ElasticSearch](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/search-aggregations-bucket-histogram-aggregation.html).
+
+## Query Type
+
+Query represents a raw elasticsearch query\_string. It's mostly used to provide a simple sarch box on the user interface.
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `field` | String | The field we will be using to filter the results. |
+| `query` | String | String that will be used to match the resulting records, based on the values available for the specified field on each one of the records. |
+| `exact` | Boolean | Wether to match the query text as-is, or to try to be more flexible with the matches \(accepting values if they contain the given query, even if the casing doesn't match\). |
+
+Example input:
+
+```javascript
+{
+ type: 'query',
+ field: 'fieldName',
+ query: 'cable',
+ exact: true,
+}
+```
+
+Example output:
+
+```javascript
+{
+ query_string: {
+ query: 'cable',
+ default_operator: 'AND',
+ default_field: 'fieldName.exact',
+ analyzer: 'exact',
+ },
+}
+```
+
+You can read more about it in:
+
+* [Source code of the type: query](https://github.com/smartprocure/contexture-elasticsearch/blob/master/src/example-types/query.js).
+* [Unit tests of the type: query](https://github.com/smartprocure/contexture-elasticsearch/blob/master/test/example-types/query.js).
+
+## Text Type
+
+Text implements raw text analysis like starts with, ends with, etc. These are generally regex queries.
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `field` | String | The field we will be using to filter the results. |
+| `join` | String | Either `any`, `all` or `none`. |
+| `operator` | String | `containsWord`, `startsWith`, `wordStartsWith`, `endsWith`, `wordEndsWith`, `is` or `containsExact`. |
+| `values` | Array | Array containing all the words that want to be used as inputs. |
+
+Example input:
+
+```javascript
+{
+ type: 'text',
+ field: 'fieldName',
+ join: 'any',
+ operator: 'contains',
+ values: ['laserjet', 'printer'],
+}
+```
+
+Example output:
+
+```javascript
+{
+ query_string: {
+ default_field: 'fieldName',
+ default_operator: 'OR',
+ query: '"laserjet" "printer"',
+ },
+}
+```
+
+You can read more about it in:
+
+* [Source code of the type: text](https://github.com/smartprocure/contexture-elasticsearch/blob/master/src/example-types/text.js).
+* [Unit tests of the type: text](https://github.com/smartprocure/contexture-elasticsearch/blob/master/test/example-types/text.js).
+
+## Other ElasticSearch Example Types
+
+For more informaion about other available example types, please check: [https://github.com/smartprocure/contexture-elasticsearch](https://github.com/smartprocure/contexture-elasticsearch)
+
diff --git a/types-and-type-components/mongodb-example-types.md b/types-and-type-components/mongodb-example-types.md
new file mode 100644
index 0000000..f018281
--- /dev/null
+++ b/types-and-type-components/mongodb-example-types.md
@@ -0,0 +1,229 @@
+# MongoDB Example Types
+
+Most of our types have relevant components already written to facilitate building search interfaces. As we progress over each one of these types, we will show small examples of simple components written to search with these types. We hope to provide enough information to allow you to take as little as you need, or as much as you want, and fulfill you expectations.
+
+Our MongoDb types are the following ones:
+
+## Results Type
+
+The `results` node is a node that if present, idicates to Contextre that the queries and aggregations should finally run and retrieve all the filtered values. It allows some customization properties, as shown below:
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `page` | Number | Current page of results. |
+| `pageSize` | Number | Total results per page. |
+| `sortField` | String | Field used to sort the results. |
+| `sortDir` | String | Direction of sorting \(`asc`, `desc`\) |
+
+## Date Type
+
+The Date type is used to specify a range of dates that will be used to filter the available results. This range of dates can be specified by a string formatted date \(`YYYY-MM-DD`\) or by a small set of possible humanly readable date ranges. Details follow:
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `from` | String | Either a date formatted as `YYYY-MM-DD`, or an ES date \(formatted properly for ElasticSearch\), or one of the following values: `thisQuarter` \(for the current quarter of the year\), `lastQuarter` \(for the previously completed quarter of the year\), `nextQuarter` \(for the upcoming quarter\). |
+| `to` | String | Optional. Defaults to the current date. Only concidered if there's a `from` value, should be a date formatted as `YYYY-MM-DD` or an ES date \(formatted properly for ElasticSearch\). |
+| `useDateMath` | Boolean | Defines if we should parse `from` as one of the `*Quarter` dates. |
+| `isDateTime` | Boolean | Ignores any processing or formatting and accpets the `form` and `to` values as they come. |
+
+Example input:
+
+```javascript
+{
+ type: 'date',
+ field: 'fieldName',
+ from: '2016-04-25'
+}
+```
+
+Example output:
+
+```javascript
+{
+ fieldName: {
+ $gte: new Date('2016-04-25'),
+ },
+}
+```
+
+You can read more about it in:
+
+* [Source code of the type: date](https://github.com/smartprocure/contexture-mongo/blob/master/src/example-types/date.js).
+* [Unit tests of the type: date](https://github.com/smartprocure/contexture-mongo/blob/master/test/example-types/date.js).
+* MongoDb's [$gte](https://docs.mongodb.com/manual/reference/operator/query/gte/).
+* MongoDb's [$lte](https://docs.mongodb.com/manual/reference/operator/query/lte/).
+
+## Exists Type
+
+The `exists` type is used to check wether some property exsits or not. It requires only two fields: `field` and `value`.
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `field` | String | The target field we want to check. |
+| `value` | Boolean | the value we want to check. Normally true or false. |
+
+Example input:
+
+```javascript
+{
+ type: 'exists',
+ field: 'fieldName',
+ value: true
+}
+```
+
+Example output:
+
+```javascript
+{
+ $and: [
+ {
+ fieldName: {
+ $exists: true,
+ $ne: '',
+ },
+ },
+ {
+ fieldName: {
+ $ne: null,
+ },
+ },
+ ],
+}
+```
+
+You can read more about it in:
+
+* [Source code of the type: exists](https://github.com/smartprocure/contexture-mongo/blob/master/src/example-types/exists.js).
+* [Unit tests of the type: exists](https://github.com/smartprocure/contexture-mongo/blob/master/test/example-types/exists.js).
+* MongoDb's [$exists](https://docs.mongodb.com/manual/reference/operator/query/exists/).
+
+## Facet Type
+
+The `facet` type represents a list of dynamic choices, e.g. a checkbox list filter. We achieve this by running an ElasticSearch terms aggregation. We provide a way to limit the number of results that you will receive with the `size` property, so that large queries can safely be used. For that same purpose, the property `optionsFilter` is given, so that search queries can filter the results with a string.
+
+Facet returns it's values in the `context` of the node, rather than in the `results` node.
+
+| Property | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `field` | String | None, _required_ | The field it's operating on. |
+| `mode` | String \(`include` or `exclude`\) | `include` | Wether this filter acts as for the inclusion or exclusion of the selected values when picking up what results to keep. |
+| `values` | Array \(of strings\) | `[]` | Already selected values. |
+| `size` | Number | 10 | How many options to return. |
+
+Example input:
+
+```javascript
+{
+ type: 'facet',
+ field: 'fieldName',
+ values: ['abc', '123']
+}
+```
+
+Example input with exclude:
+
+```javascript
+{
+ type: 'facet',
+ field: 'fieldName',
+ mode: 'exclude',
+ values: ['abc', '123'],
+}
+```
+
+You can read more about it in:
+
+* [Source code of the type: facet](https://github.com/smartprocure/contexture-mongo/blob/master/src/example-types/facet.js).
+
+## Number Type
+
+Number represents a number range with inclusive bounds. This type provides the ability to determine the best range values based on percentile interval and range threshold.
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `field` | String | The field we will be using to filter the results. |
+| `min` | Number | Lower boundary of the filter. |
+| `max` | Number | Upper boundary of the filter. |
+
+Some Notes: 1. An empty value as the upper boundary represents infinity. 2. An empty value as the lower boundary represents negative infinity. 3. Zero has to be respected as a boundary value. 4. If findBestRange is true it will return the best min and max range.
+
+Example input:
+
+```javascript
+{
+ type: 'number',
+ field: 'fieldName',
+ min: 500,
+ max: 1000,
+}
+```
+
+Example output:
+
+```javascript
+{
+ fieldName: {
+ $gte: 500,
+ $lte: 1000
+ }
+}
+```
+
+You can read more about it in:
+
+* [Source code of the type: number](https://github.com/smartprocure/contexture-mongo/blob/master/src/example-types/number.js).
+* [Unit tests of the type: number](https://github.com/smartprocure/contexture-mongo/blob/master/test/example-types/number.js).
+* MongoDb's [$gte](https://docs.mongodb.com/manual/reference/operator/query/gte/).
+* MongoDb's [$lte](https://docs.mongodb.com/manual/reference/operator/query/lte/).
+
+## Text Type
+
+Text implements raw text analysis like starts with, ends with, etc. These are generally regex queries.
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `field` | String | The field we will be using to filter the results. |
+| `join` | String | Either `any`, `all` or `none`. |
+| `operator` | String | `containsWord`, `startsWith`, `wordStartsWith`, `endsWith`, `wordEndsWith`, `is` or `containsExact`. |
+| `values` | Array | Array containing all the words that want to be used as inputs. |
+
+Example input:
+
+```javascript
+{
+ type: 'text',
+ field: 'fieldName',
+ join: 'any',
+ operator: 'contains',
+ values: ['laserjet', 'printer'],
+}
+```
+
+Example output:
+
+```javascript
+{
+ $or: [{
+ fieldName: {
+ $regex: 'laserjet',
+ $options: 'i'
+ }
+ }, {
+ fieldName: {
+ $regex: 'printer',
+ $options: 'i'
+ }
+ }]
+}
+```
+
+You can read more about it in:
+
+* [Source code of the type: text](https://github.com/smartprocure/contexture-mongo/blob/master/src/example-types/text.js).
+* [Unit tests of the type: text](https://github.com/smartprocure/contexture-mongo/blob/master/test/example-types/text.js).
+
+## Other MongoDb Example Types
+
+For more informaion about other available example types, please check: [https://github.com/smartprocure/contexture-mongo](https://github.com/smartprocure/contexture-mongo)
+
diff --git a/under-the-hood/building-your-own-provider.md b/under-the-hood/building-your-own-provider.md
new file mode 100644
index 0000000..dfab9ae
--- /dev/null
+++ b/under-the-hood/building-your-own-provider.md
@@ -0,0 +1,67 @@
+# Building Your Own Provider
+
+Writing a new provider consists of writing a function \(or class or any other approach you might like\), that will receive a configuration object with at least the following properties:
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `types` | `Object` | See the example-types in [contexture-elasticsearch](https://github.com/smartprocure/contexture-elasticsearch) and [contexture-mongo](https://github.com/smartprocure/contexture-mongo). |
+| `getClient` | `Function` | A function that returns the main database client that you will be using. |
+
+You might also add any new property if your provider needs it for processing the searches.
+
+The main provider function is expected to return an Object with:
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `types` | `Object` | See the example-types in [contexture-elasticsearch](https://github.com/smartprocure/contexture-elasticsearch) and [contexture-mongo](https://github.com/smartprocure/contexture-mongo). |
+| `groupCombinator(group, filters)` | `Function` | A function that returns a valid query for grouping individual aggregations. More on that below. |
+| `runSearch(options = {}, context, schema, filters, aggs)` | `Function -> Promise` | A function that will be responsible for running each one of the individual searches that the types in the Contexture DSL might indicate. More on that below. |
+
+## Group Combinator Function
+
+The `groupCombinator` function is used to transform an incoming query into the underlying database's group combinator. It receives a `group` Object that contains a property `join`, which indicates which boolean operation wants to be used. The `join` values we use are `and`, `or` and `not`, but you can specify any `join` value for your provider, as long as you make sure the resulting query is valid. The result should be a native database query structure with the given `filters` within a boolean operator. For example, in ElasticSearch, this means:
+
+| Boolean Operation | ElasticSearch Combinator |
+| :--- | :--- |
+| `and` | `{ bool: { must: filters } }` |
+| `or` | `{ bool: { should: filters, minimum_should_match: 1 } }` |
+| `not` | `{ bool: { must_not: filters } }` |
+
+However, in MongoDB, this is how it works:
+
+| Boolean Operation | MongoDB Combinator |
+| :--- | :--- |
+| `and` | `{ $and: filters }` |
+| `or` | `{ $or: filters }` |
+| `not` | `{ $nor: filters }` |
+
+## Run Search Function
+
+The `runSearch` function will run each search that is indicated by the Contexture DSL. It receives several parameters:
+
+| Property Name | Type | Description |
+| :--- | :--- | :--- |
+| `options` | `Object` | Object that is sent as the last parameter to the main `Contexture` call. |
+| `context` | `Object` | The current node that is triggering the search. |
+| `schema` | `Object` | The schema that is related to this node or root. Usually assigned at the root of the search tree. |
+| `filters` | `Array` | The filters that have resulted from parsing this node and it's children. |
+| `aggs` | `Array` | Any other aggregation that might have been received from previous processing operations of the Contexture DSL. |
+
+In this function, you should call to the `getClient` function that the provider originally received, then you should accomodate the incoming `filters` and `aggs` into the final query that will be sent to the client's aggregation method. Since you'll have the schema, you'll be able to get the information you need for your specific database with `schema.myDatabase.myProperty`.
+
+The final search query should be an Object and should be pushed into the `context._meta.requests` array, for debugging purposes. Once you have the result, you should also add it to the final query object, so that it can be accessible by reading the context path, then `_meta.requests[index].response`, where `index` is the position where the final query lives. For example:
+
+```javascript
+let request = {
+ /* My Database DSL Object */
+}
+
+context._meta.requests.push(request)
+
+let result = Promise.resolve(databaseClient(request))
+
+return result.tap(results => {
+ request.response = results
+})
+```
+
diff --git a/under-the-hood/contexture-client.md b/under-the-hood/contexture-client.md
new file mode 100644
index 0000000..50da32f
--- /dev/null
+++ b/under-the-hood/contexture-client.md
@@ -0,0 +1,4 @@
+# Contexture Client
+
+TODO
+
diff --git a/under-the-hood/contexture-core.md b/under-the-hood/contexture-core.md
new file mode 100644
index 0000000..9034401
--- /dev/null
+++ b/under-the-hood/contexture-core.md
@@ -0,0 +1,57 @@
+# Contexture Core
+
+The core of Contexture is a package of its own. Located at [github.com/smartprocure/contexture](https://github.com/smartprocure/contexture), it offers the very underlying function that is designed to process every one of the search queries. It begins with a simple curried function which, once the providers and the schemas are received, proceeds to process the Contexture DSL by walking down the given search tree, cleaning up every node of possible inconsistencies, then mutating the tree with the directions given by the provider types and schemas, up until a valid search query is obtained. This query is delivered to the provider `runSearch` method, and the result is finally added back to the tree.
+
+With this in mind, let's get some specifications.
+
+## Default Export
+
+Contexture's default export is a function that receives a total of three parameters, where the first two parameters are curried.
+
+The first argument is expected to be a plain JavaScript Object with two keys:
+
+* `providers`: Should be an object where each key will have a Contexture Provider.
+* `schemas`: Should be an object where each key will have a Contexture Schema.
+
+Calling this function with this object only will return another function, which can be used as an asynchronous search runner. You can also pass in all the arguments as once, but the separation of parameters makes it easier to scope setting up the database providers, the types and the schemas from the search execution.
+
+Example declaration of a search function by passing the schema & providers object first:
+
+```javascript
+const search = Contexture({
+ schemas: {
+ ...mongoSchemas,
+ ...elasticSearchSchemas,
+ },
+ providers: {
+ mongo: require('contexture-mongo')({ /* provider configuration */ }),
+ elasticsearch: require('contexture-elasticsearch')({ /* provider configuration */}),
+ },
+})
+
+// How you might use it with an express-like API:
+// app.use('/search', async req, res) =>
+// res.send(await search(req.body.search))
+```
+
+The other two parameters are the search tree \(the Contexture DSL\), and an optional object that will be sent along to the provider's `runSearch` function as the first parameter, that can contain any property, but that should at least contain the following properties:
+
+| Option | Description |
+| :--- | :--- |
+| `debug` | Sends `_meta` as part of the response, which includes per node request records, relevant filters, and other debug info. |
+| `onResult` | A callback which is called whenever a node finishes producing it's results, which can be used to send partial results over websockets for example. |
+
+This function, called at least up to the DSL search tree, will return a copy of the given search tree, filled with both properties needed to run the search, but also with the search results, which are assigned in the tree based on each one of the types that each specific search might be using. For more about how this happens, check out the Contexture Types.
+
+## The Algorithm
+
+_Coming soon..._
+
+* Initial values in the tree.
+* Flat lenses.
+* State flags.
+* Add filters.
+* DFS initialization.
+
+## Utility Functions
+
diff --git a/under-the-hood/contexture-elasticsearch.md b/under-the-hood/contexture-elasticsearch.md
new file mode 100644
index 0000000..0b63342
--- /dev/null
+++ b/under-the-hood/contexture-elasticsearch.md
@@ -0,0 +1,4 @@
+# Contexture ElasticSearch
+
+TODO
+
diff --git a/under-the-hood/contexture-mongo.md b/under-the-hood/contexture-mongo.md
new file mode 100644
index 0000000..2f58d0d
--- /dev/null
+++ b/under-the-hood/contexture-mongo.md
@@ -0,0 +1,4 @@
+# Contexture Mongo
+
+TODO
+
diff --git a/under-the-hood/contexture-react.md b/under-the-hood/contexture-react.md
new file mode 100644
index 0000000..b4e78b6
--- /dev/null
+++ b/under-the-hood/contexture-react.md
@@ -0,0 +1,4 @@
+# Contexture React
+
+TODO
+
diff --git a/under-the-hood/design-principles.md b/under-the-hood/design-principles.md
new file mode 100644
index 0000000..b94c6e2
--- /dev/null
+++ b/under-the-hood/design-principles.md
@@ -0,0 +1,26 @@
+# Design Principles
+
+* Intentionally stateless.
+* Detached from state management tools.
+* Can work well with state management tools.
+* Modern ES6+
+* Non-strict functional programming.
+* Configuration based architecture.
+* Focus on a very extensible small core.
+* Small DSL.
+ * Database agnostic.
+ * Isomorphic Tree State.
+ * Optimized for database discovery.
+ * Optimized for advanced search interfaces.
+ * Aiming to be effective for arbitrarily complex database indexes.
+ * Simplicity over performance.
+* Reaction management.
+ * Tree walking.
+ * State flags.
+ * What updates.
+ * Pauses.
+* Why types?
+* Why a results type?
+* Why schemas?
+* Why providers?
+
diff --git a/under-the-hood/reactors.md b/under-the-hood/reactors.md
new file mode 100644
index 0000000..11a7f0e
--- /dev/null
+++ b/under-the-hood/reactors.md
@@ -0,0 +1,22 @@
+# Reactors
+
+When any node changes, depending on the type, it might be reasonable to re-trigger a search call for other nodes. We call this process the selection of `reactors`, where the possible reactors are only three: `self`, `others` and `all`.
+
+Reactors should be specified in the Client Types, where each type will have a specific reactor for each one of it's properties. For example \(taken from our client side [example types](https://github.com/smartprocure/contexture-client/blob/master/src/exampleTypes.js)\):
+
+```javascript
+facet: {
+ reactors: {
+ values: 'others',
+ mode: 'others',
+ size: 'self',
+ optionsFilter: 'self',
+ sort: 'self',
+ }
+}
+```
+
+The client side type defined above will be effective for any node with type `facet`, where the properties `values` and `mode` will affect only all the other nodes \(and not itself\), and the properties `size`, `optionsFilter` and `sort` will affect only the specific `facet` node and no other node.
+
+The one remaining reactor that isn't covered by that example is the `all` reactor. The difference between `others` and `all` is that `others` excludes the node where the change is happening, and `all` includes all other nodes and the node where the change is happening \(effectively combining `self` and `others`\).
+