diff --git a/.ci/setup_and_test.sh b/.ci/setup_and_test.sh
deleted file mode 100755
index 93135dc6..00000000
--- a/.ci/setup_and_test.sh
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-mkdir -p /root/go/src/github.com/kuzzleio/sdk-go
-cp -fr /mnt/* /root/go/src/github.com/kuzzleio/sdk-go/
-cd /root/go/src/github.com/kuzzleio/sdk-go/
-go get ./...
-./test.sh
-cp -fr /root/go/src/github.com/kuzzleio/sdk-go/.cover /mnt/
-cd /mnt
diff --git a/.ci/test_with_coverage.sh b/.ci/test_with_coverage.sh
new file mode 100755
index 00000000..290876b7
--- /dev/null
+++ b/.ci/test_with_coverage.sh
@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+set -e
+
+cover_dir=".cover"
+profile="$cover_dir/cover.out"
+mode=count
+timeout=${TIMEOUT:=1m}
+
+generate_cover_data() {
+    rm -rf "$cover_dir"
+    mkdir "$cover_dir"
+    go test -timeout "$timeout" -covermode="$mode" -coverprofile="$profile" ./...
+}
+
+show_cover_report() {
+    go tool cover -${1}="$profile"
+}
+
+linter_check() {
+    invalid_files=$(gofmt -l "$1")
+
+    if [ -n "${invalid_files}" ]; then
+        echo "Lint errors on the following files:"
+        echo ${invalid_files}
+        exit 1
+    fi
+}
+
+linter_check .
+generate_cover_data
+show_cover_report func
+
+case "$1" in
+"")
+    ;;
+--html)
+    show_cover_report html ;;
+*)
+    echo >&2 "error: invalid option: $1"; exit 1 ;;
+esac
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 31936ac2..ad1bb24e 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -19,6 +19,10 @@
   List any dependencies that are required for this change.
 -->
 
+<!-- Uncomment this section to link PR on other SDKs
+:large_blue_circle :arrow_right: https://github.com/kuzzleio/sdk-c/pull/
+-->
+
 ### How should this be manually tested?
 
 <!--
diff --git a/.gitignore b/.gitignore
index add6fd4a..37cd8cc4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 .cover
+.compiled_test
 .idea
 .vscode
 main.go
diff --git a/.travis.yml b/.travis.yml
index 546a9a99..92ce3a18 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,55 +1,374 @@
-os: linux
-dist: trusty
+jobs:
+  include:
+# -----------------------------------------------
+# Linux amd64
+# -----------------------------------------------
 
-language: minimal
-sudo: required
+  - name: Linux amd64 - Go 1.12.x (with coverage)
+    os: linux
+    dist: xenial
+    sudo: true
+    language: go
+    go: 1.12.x
+    cache:
+      directories:
+      - "$HOME/.cache/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=linux
+    - export GOARCH=amd64
+    - "./.ci/test_with_coverage.sh"
+    after_success:
+    - bash <(curl -s https://codecov.io/bash)
 
-services:
-  - docker
+  - name: Linux amd64 - Go 1.11.x
+    if: type = cron OR branch = master
+    os: linux
+    dist: xenial
+    sudo: true
+    language: go
+    go: 1.11.x
+    cache:
+      directories:
+      - "$HOME/.cache/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=linux
+    - export GOARCH=amd64
+    - go test -v ./...
 
-after_success:
-  - bash <(curl -s https://codecov.io/bash)
+  - name: Linux amd64 - Go 1.10.x
+    if: type = cron OR branch = master
+    os: linux
+    dist: xenial
+    sudo: true
+    language: go
+    go: 1.10.x
+    cache:
+      directories:
+      - "$HOME/.cache/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=linux
+    - export GOARCH=amd64
+    - go test -v ./...
+
+# -----------------------------------------------
+# Linux i386
+# -----------------------------------------------
+
+  - name: Linux i386 - Go 1.12.x
+    os: linux
+    dist: xenial
+    sudo: true
+    language: go
+    go: 1.12.x
+    cache:
+      directories:
+      - "$HOME/.cache/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=linux
+    - export GOARCH=386
+    - go test -v ./...
+
+  - name: Linux i386 - Go 1.11.x
+    if: type = cron OR branch = master
+    os: linux
+    dist: xenial
+    sudo: true
+    language: go
+    go: 1.11.x
+    cache:
+      directories:
+      - "$HOME/.cache/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=linux
+    - export GOARCH=386
+    - go test -v ./...
+
+  - name: Linux i386 - Go 1.10.x
+    if: type = cron OR branch = master
+    os: linux
+    dist: xenial
+    sudo: true
+    language: go
+    go: 1.10.x
+    cache:
+      directories:
+      - "$HOME/.cache/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=linux
+    - export GOARCH=386
+    - go test -v ./...
+
+# -----------------------------------------------
+# Linux arm64
+# -----------------------------------------------
+
+  - name: Linux arm64 - Go 1.12.x
+    os: linux
+    dist: xenial
+    sudo: true
+    addons:
+      apt:
+        packages:
+        - qemu-user-static
+    language: go
+    go: 1.12.x
+    cache:
+      directories:
+      - "$HOME/.cache/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=linux
+    - export GOARCH=arm64
+    - taskset -c 1 go test -v -exec "qemu-aarch64-static" ./...
+
+  - name: Linux arm64 - Go 1.11.x
+    if: type = cron OR branch = master
+    os: linux
+    dist: xenial
+    sudo: true
+    addons:
+      apt:
+        packages:
+        - qemu-user-static
+    language: go
+    go: 1.11.x
+    cache:
+      directories:
+      - "$HOME/.cache/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=linux
+    - export GOARCH=arm64
+    - taskset -c 1 go test -v -exec "qemu-aarch64-static" ./...
+
+# -----------------------------------------------
+# Linux armhf
+# -----------------------------------------------
+
+  - name: Linux armhf - Go 1.12.x
+    os: linux
+    dist: xenial
+    sudo: true
+    addons:
+      apt:
+        packages:
+        - qemu-user-static
+    language: go
+    go: 1.12.x
+    cache:
+      directories:
+      - "$HOME/.cache/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=linux
+    - export GOARCH=arm
+    - export GOARM=7
+    - taskset -c 1 go test -v -exec "qemu-arm-static" ./...
+
+  - name: Linux armhf - Go 1.11.x
+    if: type = cron OR branch = master
+    os: linux
+    dist: xenial
+    sudo: true
+    addons:
+      apt:
+        packages:
+        - qemu-user-static
+    language: go
+    go: 1.11.x
+    cache:
+      directories:
+      - "$HOME/.cache/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=linux
+    - export GOARCH=arm
+    - export GOARM=7
+    - taskset -c 1 go test -v -exec "qemu-arm-static" ./...
+
+  - name: Linux armhf - Go 1.10.x
+    # Go 1.10.x run is only run for armhf build
+    # not for arm64 one. Since ARM64 QEMU static 
+    # crash when used with Go 1.10.x
+    if: type = cron OR branch = master
+    os: linux
+    dist: xenial
+    sudo: true
+    addons:
+      apt:
+        packages:
+        - qemu-user-static
+    language: go
+    go: 1.10.x
+    cache:
+      directories:
+      - "$HOME/.cache/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=linux
+    - export GOARCH=arm
+    - export GOARM=7
+    - taskset -c 1 go test -v -exec "qemu-arm-static" ./...
+
+# -----------------------------------------------
+# MacOS amd64
+# -----------------------------------------------
+
+  - name: MacOS amd64 - Go 1.12.x
+    if: type = cron OR branch = master
+    os: osx
+    language: go
+    go: 1.12.x
+    cache:
+      directories:
+      - "$HOME/Library/Caches/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=darwin
+    - export GOARCH=amd64
+    - go test -v ./...
+
+  - name: MacOS amd64 - Go 1.11.x
+    if: type = cron OR branch = master
+    os: osx
+    language: go
+    go: 1.11.x
+    cache:
+      directories:
+      - "$HOME/Library/Caches/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=darwin
+    - export GOARCH=amd64
+    - go test -v ./...
+
+  - name: MacOS amd64 - Go 1.10.x
+    if: type = cron OR branch = master
+    os: osx
+    language: go
+    go: 1.10.x
+    cache:
+      directories:
+      - "$HOME/Library/Caches/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=darwin
+    - export GOARCH=amd64
+    - go test -v ./...
+
+# -----------------------------------------------
+# MacOS i386
+# -----------------------------------------------
+
+  - name: MacOS i386 - Go 1.12.x
+    if: type = cron OR branch = master
+    os: osx
+    language: go
+    go: 1.12.x
+    cache:
+      directories:
+      - "$HOME/Library/Caches/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=darwin
+    - export GOARCH=386
+    - go test -v ./...
+
+  - name: MacOS i386 - Go 1.11.x
+    if: type = cron OR branch = master
+    os: osx
+    language: go
+    go: 1.11.x
+    cache:
+      directories:
+      - "$HOME/Library/Caches/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=darwin
+    - export GOARCH=386
+    - go test -v ./...
+
+  - name: MacOS i386 - Go 1.10.x
+    if: type = cron OR branch = master
+    os: osx
+    language: go
+    go: 1.10.x
+    cache:
+      directories:
+      - "$HOME/Library/Caches/go-build"
+      - "$HOME/gopath/pkg"
+    script:
+    - export GOOS=darwin
+    - export GOARCH=386
+    - go test -v ./...
+
+# -----------------------------------------------
+# Windows amd64
+# -----------------------------------------------
+
+  - name: Windows amd64 - Go 1.12.x
+    if: type = cron OR branch = master
+    os: windows
+    language: go
+    go: 1.12.x
+    script:
+    - GOOS=windows
+    - GOARCH=amd64
+    - go test -v ./...
+  - name: Windows amd64 - Go 1.11.x
+    if: type = cron OR branch = master
+    os: windows
+    language: go
+    go: 1.11.x
+    script:
+    - GOOS=windows
+    - GOARCH=amd64
+    - go test -v ./...
+
+# -----------------------------------------------
+# Windows i386
+# -----------------------------------------------
+
+  - name: Windows i386 - Go 1.12.x
+    if: type = cron OR branch = master
+    os: windows
+    language: go
+    go: 1.12.x
+    script:
+    - GOOS=windows
+    - GOARCH=386
+    - go test -v ./...
+
+  - name: Windows i386 - Go 1.11.x
+    if: type = cron OR branch = master
+    os: windows
+    language: go
+    go: 1.11.x
+    script:
+    - GOOS=windows
+    - GOARCH=386
+    - go test -v ./...
+
+  - name: Windows i386 - Go 1.10.x
+    if: type = cron OR branch = master
+    os: windows
+    language: go
+    go: 1.10.x
+    script:
+    - GOOS=windows
+    - GOARCH=386
+    - go test -v ./...
+
+notifications:
+  slack:
+    rooms:
+    - secure: "5yW4WxRGTgzTYN081dnnuZugsMFhR/QBYvEtt6DoZknYDIL6owP23EcnErZA9TpNgzLSFBIxSKBRByBN9HKYM22d7QyJG2UWGGggE+05vYhP+WjiQOVV2/xQvUFDEImJKt9VcILtiUFG3eHG6ud4QU1COzgo7SiB4TNPKtHw+uXwkfTxyeOFSB8cmMw4ksLajfDzCxFrayCG4ebZ3HxQb/xvO97JdxyGcRSyWopA/9OS0GcVJdQ5itRF36yyDJcQa3d2J3/cx7ril4lDq7mv0hvvM2sbnLEKytnIOLUuPsmKQkQj+S3GY7499NudKLBEmhLF7z+zTYiWpUeQBeqpY8xdFrq/wsSebRyPsbeSTBofGZZTIQvT0j4/l7WiuhifMrLsA2sqeGCOKEdFO/AsSRa2tOVZZfhsUR9bATkm2qgCfW2UWyAAUtlRT5A7wJ73r0JUgQjAw/RkW20DJPFvJv0wmEMZqo2AJLwrIbY3eu+NvT9mNP17V5nWe8lC61/vhg7tUAubOMq6pd5SlGJOZ8LhOwR5N4w638lFeu4nHyL/XF+tF4qR7bFk5jWFUWgUrA41zoDeUrURmqA9eRm6n+anHTe8bFVTBl7pXcTq8ZXrXw3PQYhkaBbuXTfS12mcWLg/Z3iKTm8hVfJasLtSEQWlA73fUz7fNLxGBXK4X6w="
+    on_success: change
+    on_failure: always
 
-matrix:
-  include:
-# ---------------------------------------------
-# AMD64: Build and Test
-# ---------------------------------------------
-    - env:
-        - ARCH="amd64"
-
-      script:
-        # Build
-        - docker run --rm -it -v "$(pwd)":/mnt kuzzleio/sdk-cross:golang ./.ci/setup_and_test.sh
-
-# ---------------------------------------------
-# I386: Build and Test
-# ---------------------------------------------
-    - env:
-        - ARCH="i386"
-
-      script:
-        # Build
-        - docker run --rm -it -v "$(pwd)":/mnt kuzzleio/sdk-cross:golang-i386 ./.ci/setup_and_test.sh
-
-# ---------------------------------------------
-# ARMV7: Build and Test
-# ---------------------------------------------
-    - env:
-        - ARCH="armhf"
-
-      script:
-        # Build
-        - docker run --rm --privileged multiarch/qemu-user-static:register
-        - docker run --rm -it -v "$(pwd)":/mnt kuzzleio/sdk-cross:armhf-golang-runner taskset -c 1 ./.ci/setup_and_test.sh
-
-# ---------------------------------------------
-# ARMV8: Build and Test
-# ---------------------------------------------
-    - env:
-        - ARCH="aarch64"
-
-      script:
-        # Build
-        - docker run --rm --privileged multiarch/qemu-user-static:register
-        - docker run --rm -it -v "$(pwd)":/mnt kuzzleio/sdk-cross:aarch64-golang-runner taskset -c 1 ./.ci/setup_and_test.sh
diff --git a/README.md b/README.md
index 285d394f..66aac083 100644
--- a/README.md
+++ b/README.md
@@ -1,176 +1,103 @@
-[![Build Status](https://travis-ci.org/kuzzleio/sdk-go.svg?branch=master)](https://travis-ci.org/kuzzleio/sdk-go) [![codecov.io](http://codecov.io/github/kuzzleio/sdk-php/coverage.svg?branch=master)](http://codecov.io/github/kuzzleio/sdk-go?branch=master) [![GoDoc](https://godoc.org/github.com/kuzzleio/sdk-go?status.svg)](https://godoc.org/github.com/kuzzleio/sdk-go)
-[![Go Report Card](https://goreportcard.com/badge/github.com/kuzzleio/sdk-go)](https://goreportcard.com/report/github.com/kuzzleio/sdk-go)
-
-Official Kuzzle GO SDK with wrappers for C++ and JAVA SDK
-======
-
-## About Kuzzle
-
-A backend software, self-hostable and ready to use to power modern apps.
-
-You can access the Kuzzle repository on [Github](https://github.com/kuzzleio/kuzzle)
-
-* [SDK Documentation](https://godoc.org/github.com/kuzzleio/sdk-go)
-* [Installation](#installation)
-* [Basic usage](#basic-usage)
-* [Running tests](#tests)
-* [License](#license)
-
-## SDK Documentation
-
-The complete SDK documentation is available [here](http://docs.kuzzle.io/sdk-reference/)
-
-## Installation
-
-````sh
+<p align="center">
+  <img src="https://user-images.githubusercontent.com/7868838/53850936-31e57180-3fbd-11e9-8392-8f3e26bf2aa8.png"/>
+</p>
+<p align="center">
+  <img src="https://img.shields.io/badge/tested%20on-linux%20%7C%20osx%20%7C%20windows-blue.svg">
+  <a href="https://travis-ci.org/kuzzleio/sdk-go">
+    <img src="https://travis-ci.org/kuzzleio/sdk-go.svg?branch=master"/>
+  </a>
+  <a href="https://codecov.io/gh/kuzzleio/sdk-go">
+    <img src="https://codecov.io/gh/kuzzleio/sdk-go/branch/master/graph/badge.svg" />
+  </a>
+  <a href="https://goreportcard.com/report/github.com/kuzzleio/sdk-go">
+    <img src="https://goreportcard.com/badge/github.com/kuzzleio/sdk-go" />
+  </a>
+  <a href="https://godoc.org/github.com/kuzzleio/sdk-go">
+    <img src="https://godoc.org/github.com/kuzzleio/sdk-go?status.svg"/>
+  </a>
+  <a href="https://github.com/kuzzleio/sdk-go/blob/master/LICENSE">
+    <img alt="undefined" src="https://img.shields.io/github/license/kuzzleio/sdk-go.svg?style=flat">
+  </a>
+</p>
+
+## About
+
+### Kuzzle Go
+
+This is the official Go SDK for the free and open-source backend Kuzzle. It provides a way to dial with a Kuzzle server from Go applications.
+The SDK provides a native __WebSocket__ support. You can add your own network protocol by implementing the Protocol interface.
+
+<p align="center">
+  :books: <b><a href="https://docs.kuzzle.io/sdk-reference/go/1">Documentation</a></b>
+</p>
+
+### Kuzzle
+
+Kuzzle is a ready-to-use, **on-premises and scalable backend** that enables you to manage your persistent data and be notified in real-time on whatever happens to it. 
+It also provides you with a flexible and powerful user-management system.
+
+* :watch: __[Kuzzle in 5 minutes](https://kuzzle.io/company/about-us/kuzzle-in-5-minutes/)__
+* :octocat: __[Github](https://github.com/kuzzleio/kuzzle)__
+* :earth_africa: __[Website](https://kuzzle.io)__
+* :books: __[Documentation](https://docs.kuzzle.io)__
+* :email: __[Gitter](https://gitter.im/kuzzleio/kuzzle)__
+
+## Usage
+
+### Installation
+
+Simply download the SDK to your `GOPATH`.
+
+```go
 go get github.com/kuzzleio/sdk-go
-````
-
-## Basic usage
-
-````go
-func main() {
-    conn := websocket.NewWebSocket("localhost:7512", nil)
-    k, _ := kuzzle.NewKuzzle(conn, nil)
-
-    res, err := k.GetAllStatistics(nil)
-
-    if err != nil {
-        fmt.Println(err.Error())
-        return
-    }
-
-    for _, stat := range res {
-        fmt.Println(stat.Timestamp, stat.FailedRequests, stat.Connections, stat.CompletedRequests, stat.OngoingRequests)
-    }
-}
-
-
-````
-
-## <a name="tests"></a> Running Tests
-
-### Unit tests
-
-To run the tests you can simply execute the coverage.sh script
-```sh
-./test.sh
-```
-
-You can also get html coverage by running
-```sh
-./test.sh --html
 ```
-### e2e tests
 
-#### JAVA
+### Example
 
-```sh
-cd internal/wrappers
-make java
-cd features/java
-gradle cucumber
-```
-
-#### C++
+The SDK supports different protocols. When instantiating, 
+you must choose the protocol to use and fill in the different options needed to connect to Kuzzle.  
 
-```sh
-make cpp
-cd internal/wrappers
-./build_cpp_tests.sh̀
-./_build_cpp_tests/KuzzleSDKStepDefs > /dev/null &
-cucumber
-```
+```go
+package main
 
+import (
+	"fmt"
 
+	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
+)
 
-## Wrappers
-
-### Dependencies
-
-Before generating the wrappers you will need to install:
-
-- You will need a g++ compatible C++11
-- [swig](www.swig.org)
-- [Java 8](http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html) (don't forget to set your JAVA_HOME environment variable)
-- Python You will need to install python-dev to compile the python SDK
-
-### Generate
-
-## JAVA
-
-```sh
-make java
-```
-
-You will find the final jars files in `internal/wrappers/build/java/build/libs`
-
-## CPP
-
-```sh
-make cpp
-```
-You will find the final .so file in `internal/wrappers/build/cpp`
-
-## Python
-```sh
-make python
-```
-You will find the final .so file in `internal/wrappers/build/python`
-
-## CSHARP
-
-### Build on Windows
-
-#### Prerequisites
-- Visual Studio 2017
-- Windows SDK
-- Go - https://golang.org/doc/install
-- Mono (x64) - https://www.mono-project.com/download/stable/
-- Make (GNU - Windows) - http://gnuwin32.sourceforge.net/packages/make.htm
-- MinGW (x64 - Posix) - https://sourceforge.net/projects/mingw-w64/files/mingw-w64/mingw-w64-release/
-
-#### Compiling Csharp
-- Add Go/Mono/Make/MinGW intallation directory to PATH
-- Run Visual Studio developper command line tool
-- Execute `make csharp`
+func main() {
+	conn := websocket.NewWebSocket("localhost", nil)
+	k, _ := kuzzle.NewKuzzle(conn, nil)
+	k.Connect()
 
-## All at once
+	timestamp, err := k.Server.Now(nil)
 
-You can generate all sdk's at once by typing
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
 
-```sh
-make all
+	fmt.Println(timestamp)
+}
 ```
 
-## Generate wrappers and launch e2e tests using Docker
+## Contributing
 
-You can use Docker to simplify wrappers generation and testing
+First of all, thank you to take the time to contribute to this SDK. To help us validating your future pull request,
+please make sure your work pass linting and unit tests.
 
-### Build
-
-In project root, use:
-
-```bash
-$ docker run --rm -it -v "$(pwd)":/go/src/github.com/kuzzleio/sdk-go kuzzleio/sdk-cross:amd64 /build.sh
+```bash 
+$ bash .ci/test_with_coverage.sh 
 ```
 
-This command will build all wrappers using our Docker Image
-
-### Testing
+If you want to see current coverage run the script with this argument.
 
-E2E tests need a running Kuzzle instance so run the script:
-
-```bash
-$ sh .codepipeline/start_kuzzle.sh
+```bash 
+$ bash .ci/test_with_coverage.sh  --html
 ```
 
-Now run tests using Docker:
-
-```bash
-$ docker run --rm -it --network codepipeline_default --link kuzzle -v "$(pwd)":/go/src/github.com/kuzzleio/sdk-go kuzzleio/sdk-cross:amd64 /test.sh
-```
+This should open a new tab in your favorite web browser and allow you to see the lines of code covered by the unit tests.
 
-## License
 
-[Apache 2](LICENSE.md)
diff --git a/auth/checkToken_test.go b/auth/checkToken_test.go
index 767c36e4..6340f3d8 100644
--- a/auth/checkToken_test.go
+++ b/auth/checkToken_test.go
@@ -19,9 +19,9 @@ import (
 	"testing"
 
 	"github.com/kuzzleio/sdk-go/auth"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/auth/createMyCredentials_test.go b/auth/createMyCredentials_test.go
index 14e4cc7d..a3d821dc 100644
--- a/auth/createMyCredentials_test.go
+++ b/auth/createMyCredentials_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/auth/credentialsExist_test.go b/auth/credentialsExist_test.go
index 5767aa64..c8759f8a 100644
--- a/auth/credentialsExist_test.go
+++ b/auth/credentialsExist_test.go
@@ -18,9 +18,9 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/auth/deleteMyCredentials_test.go b/auth/deleteMyCredentials_test.go
index 3ddb1bcc..fd9ce1d3 100644
--- a/auth/deleteMyCredentials_test.go
+++ b/auth/deleteMyCredentials_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/auth/getCurrentUser_test.go b/auth/getCurrentUser_test.go
index b8dc943c..9977a541 100644
--- a/auth/getCurrentUser_test.go
+++ b/auth/getCurrentUser_test.go
@@ -20,9 +20,9 @@ import (
 	"testing"
 
 	"github.com/kuzzleio/sdk-go/auth"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/auth/getMyCredentials_test.go b/auth/getMyCredentials_test.go
index 0990c6fe..c2c1b3f0 100644
--- a/auth/getMyCredentials_test.go
+++ b/auth/getMyCredentials_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/auth/getMyRights_test.go b/auth/getMyRights_test.go
index 7abfe2fd..1f1ff1da 100644
--- a/auth/getMyRights_test.go
+++ b/auth/getMyRights_test.go
@@ -20,9 +20,9 @@ import (
 	"log"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/auth/getStrategies_test.go b/auth/getStrategies_test.go
index 6388d35f..4b613965 100644
--- a/auth/getStrategies_test.go
+++ b/auth/getStrategies_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/auth/login_test.go b/auth/login_test.go
index fc4732a8..bd1b241d 100644
--- a/auth/login_test.go
+++ b/auth/login_test.go
@@ -19,10 +19,10 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/event"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/auth/logout_test.go b/auth/logout_test.go
index 028bccf9..f2f3430e 100644
--- a/auth/logout_test.go
+++ b/auth/logout_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/auth/update_my_credentials_test.go b/auth/update_my_credentials_test.go
index 585fcd62..6024d8d0 100644
--- a/auth/update_my_credentials_test.go
+++ b/auth/update_my_credentials_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/auth/update_self_test.go b/auth/update_self_test.go
index c89f5c52..8f3a5b01 100644
--- a/auth/update_self_test.go
+++ b/auth/update_self_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/auth/validate_my_credentials_test.go b/auth/validate_my_credentials_test.go
index 64c65727..42041cef 100644
--- a/auth/validate_my_credentials_test.go
+++ b/auth/validate_my_credentials_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/collection/search_specifications.go b/collection/search_specifications.go
index f426896b..b5724400 100644
--- a/collection/search_specifications.go
+++ b/collection/search_specifications.go
@@ -21,12 +21,21 @@ import (
 )
 
 // SearchSpecifications searches specifications across indexes/collections according to the provided filters.
-func (dc *Collection) SearchSpecifications(options types.QueryOptions) (*types.SearchResult, error) {
+func (dc *Collection) SearchSpecifications(body json.RawMessage, options types.QueryOptions) (*types.SearchResult, error) {
+	if body == nil {
+		return nil, types.NewError("Document.Search: body required", 400)
+	}
+
 	ch := make(chan *types.KuzzleResponse)
 
 	query := &types.KuzzleRequest{
 		Controller: "collection",
 		Action:     "searchSpecifications",
+		Body:       body,
+	}
+	if options != nil {
+		query.From = options.From()
+		query.Size = options.Size()
 	}
 
 	go dc.Kuzzle.Query(query, options, ch)
@@ -37,8 +46,10 @@ func (dc *Collection) SearchSpecifications(options types.QueryOptions) (*types.S
 		return nil, res.Error
 	}
 
-	specifications := &types.SearchResult{}
-	json.Unmarshal(res.Result, &specifications)
+	sr, err := types.NewSearchResult(dc.Kuzzle, "scrollSpecifications", query, options, res)
+	if err != nil {
+		return nil, err
+	}
 
-	return specifications, nil
+	return sr, nil
 }
diff --git a/collection/search_specifications_test.go b/collection/search_specifications_test.go
index 0fd1c22c..1c4582ff 100644
--- a/collection/search_specifications_test.go
+++ b/collection/search_specifications_test.go
@@ -36,7 +36,7 @@ func TestSearchSpecificationsError(t *testing.T) {
 
 	nc := collection.NewCollection(k)
 
-	_, err := nc.SearchSpecifications(nil)
+	_, err := nc.SearchSpecifications(nil, nil)
 	assert.NotNil(t, err)
 }
 
@@ -79,18 +79,72 @@ func TestSearchSpecifications(t *testing.T) {
 
 	nc := collection.NewCollection(k)
 
-	res, err := nc.SearchSpecifications(nil)
+	res, err := nc.SearchSpecifications(json.RawMessage(`{"foo": "bar"}`), nil)
 	assert.Equal(t, 1, res.Total)
 	assert.Nil(t, err)
 }
 
+func TestSearchSpecificationsNext(t *testing.T) {
+	c := &internal.MockedConnection{
+		MockSend: func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
+			return &types.KuzzleResponse{Result: json.RawMessage(`{
+				"hits": [
+					{
+						"_id": "id1",
+						"_source": "specification1"
+					},
+					{
+						"_id": "id1",
+						"_source": "specification1"
+					}
+				],
+				"total": 42
+			}`)}
+		},
+	}
+	k, _ := kuzzle.NewKuzzle(c, nil)
+
+	options := types.NewQueryOptions()
+	options.SetFrom(0)
+	options.SetSize(2)
+
+	sr, err := k.Collection.SearchSpecifications(json.RawMessage(`{}`), options)
+	assert.Nil(t, err)
+	assert.NotNil(t, sr)
+
+	c.MockSend = func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
+		assert.Equal(t, 2, options.From())
+		assert.Equal(t, 2, options.Size())
+
+		return &types.KuzzleResponse{Result: json.RawMessage(`{
+			"hits": [
+				{
+					"_id": "id3",
+					"_source": "specification3"
+				},
+				{
+					"_id": "id4",
+					"_source": "specification4"
+				}
+			],
+			"total": 42
+		}`)}
+	}
+
+	nsr, err := sr.Next()
+	assert.Nil(t, err)
+	assert.NotNil(t, nsr)
+	assert.Equal(t, 42, nsr.Total)
+	assert.Equal(t, 4, nsr.Fetched)
+}
+
 func ExampleCollection_SearchSpecifications() {
 	c := &internal.MockedConnection{}
 	k, _ := kuzzle.NewKuzzle(c, nil)
 
 	nc := collection.NewCollection(k)
 
-	res, err := nc.SearchSpecifications(nil)
+	res, err := nc.SearchSpecifications(json.RawMessage(`{}`), nil)
 
 	if err != nil {
 		fmt.Println(err.Error())
diff --git a/collection/update_specifications.go b/collection/update_specifications.go
index cb7d8896..8b97e319 100644
--- a/collection/update_specifications.go
+++ b/collection/update_specifications.go
@@ -16,12 +16,13 @@ package collection
 
 import (
 	"encoding/json"
+	"fmt"
 
 	"github.com/kuzzleio/sdk-go/types"
 )
 
 // UpdateSpecifications updates the current specifications of this collection.
-func (dc *Collection) UpdateSpecifications(index string, collection string, body json.RawMessage, options types.QueryOptions) (json.RawMessage, error) {
+func (dc *Collection) UpdateSpecifications(index string, collection string, specifications json.RawMessage, options types.QueryOptions) (json.RawMessage, error) {
 	if index == "" {
 		return nil, types.NewError("Collection.UpdateSpecifications: index required", 400)
 	}
@@ -30,19 +31,28 @@ func (dc *Collection) UpdateSpecifications(index string, collection string, body
 		return nil, types.NewError("Collection.UpdateSpecifications: collection required", 400)
 	}
 
-	if body == nil {
-		return nil, types.NewError("Collection.UpdateSpecifications: body required", 400)
+	if specifications == nil {
+		return nil, types.NewError("Collection.UpdateSpecifications: specifications required", 400)
 	}
 
 	ch := make(chan *types.KuzzleResponse)
 
+	body := make(map[string]map[string]json.RawMessage)
+	body[index] = make(map[string]json.RawMessage)
+	body[index][collection] = specifications
+
+	jsonBody, err := json.Marshal(body)
+
+	if err != nil {
+		return nil, types.NewError(fmt.Sprintf("Unable to construct body: %s\n", err.Error()), 500)
+	}
+
 	query := &types.KuzzleRequest{
-		Collection: collection,
-		Index:      index,
 		Controller: "collection",
 		Action:     "updateSpecifications",
-		Body:       body,
+		Body:       json.RawMessage(jsonBody),
 	}
+
 	go dc.Kuzzle.Query(query, options, ch)
 
 	res := <-ch
diff --git a/collection/validate_specifications.go b/collection/validate_specifications.go
index 03c26223..0bcefdc7 100644
--- a/collection/validate_specifications.go
+++ b/collection/validate_specifications.go
@@ -22,37 +22,50 @@ import (
 )
 
 // ValidateSpecifications validates the provided specifications.
-func (dc *Collection) ValidateSpecifications(body json.RawMessage, options types.QueryOptions) (bool, error) {
-	if body == nil {
-		return false, types.NewError("Collection.ValidateSpecifications: body required", 400)
+func (dc *Collection) ValidateSpecifications(index string, collection string, specifications json.RawMessage, options types.QueryOptions) (*types.ValidationResponse, error) {
+	if index == "" {
+		return nil, types.NewError("Collection.ValidateSpecifications: index required", 400)
+	}
+
+	if collection == "" {
+		return nil, types.NewError("Collection.ValidateSpecifications: collection required", 400)
+	}
+
+	if specifications == nil {
+		return nil, types.NewError("Collection.ValidateSpecifications: specifications required", 400)
 	}
 
 	ch := make(chan *types.KuzzleResponse)
 
+	body := make(map[string]map[string]json.RawMessage)
+	body[index] = make(map[string]json.RawMessage)
+	body[index][collection] = specifications
+
+	jsonBody, err := json.Marshal(body)
+
+	if err != nil {
+		return nil, types.NewError(fmt.Sprintf("Unable to construct body: %s\n", err.Error()), 500)
+	}
+
 	query := &types.KuzzleRequest{
 		Controller: "collection",
 		Action:     "validateSpecifications",
-		Body:       body,
+		Body:       json.RawMessage(jsonBody),
 	}
+
 	go dc.Kuzzle.Query(query, options, ch)
 
 	res := <-ch
 
 	if res.Error.Error() != "" {
-		return false, res.Error
-	}
-
-	var validationRes struct {
-		Valid       bool
-		Details     []string
-		Descritpion string
+		return nil, res.Error
 	}
 
-	err := json.Unmarshal(res.Result, &validationRes)
+	vr, err := types.NewValidationResponse(res.Result)
 
 	if err != nil {
-		return false, types.NewError(fmt.Sprintf("Unable to parse response: %s\n%s", err.Error(), res.Result), 500)
+		return nil, err
 	}
 
-	return validationRes.Valid, nil
+	return vr, nil
 }
diff --git a/collection/validate_specifications_test.go b/collection/validate_specifications_test.go
index 4dadb317..7efc32ea 100644
--- a/collection/validate_specifications_test.go
+++ b/collection/validate_specifications_test.go
@@ -28,10 +28,10 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestValidateSpecificationsBodyNull(t *testing.T) {
+func TestValidateSpecificationsSpecificationsNull(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
 	nc := collection.NewCollection(k)
-	_, err := nc.ValidateSpecifications(nil, nil)
+	_, err := nc.ValidateSpecifications("index", "collection", nil, nil)
 	assert.NotNil(t, err)
 }
 
@@ -44,7 +44,7 @@ func TestValidateSpecificationsError(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(c, nil)
 
 	nc := collection.NewCollection(k)
-	_, err := nc.ValidateSpecifications(json.RawMessage(`{"body": "body"}`), nil)
+	_, err := nc.ValidateSpecifications("index", "collection", json.RawMessage(`{"body": "body"}`), nil)
 	assert.NotNil(t, err)
 }
 
@@ -62,10 +62,10 @@ func TestValidateSpecifications(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(c, nil)
 
 	nc := collection.NewCollection(k)
-	res, err := nc.ValidateSpecifications(json.RawMessage(`{"body": "body"}`), nil)
+	vr, err := nc.ValidateSpecifications("index", "collection", json.RawMessage(`{"body": "body"}`), nil)
 	assert.Nil(t, err)
-	assert.NotNil(t, res)
-	assert.Equal(t, true, res)
+	assert.NotNil(t, vr)
+	assert.Equal(t, true, vr.Valid)
 }
 
 func ExampleCollection_ValidateSpecifications() {
@@ -73,7 +73,7 @@ func ExampleCollection_ValidateSpecifications() {
 	k, _ := kuzzle.NewKuzzle(c, nil)
 
 	nc := collection.NewCollection(k)
-	res, err := nc.ValidateSpecifications(json.RawMessage(`{"body": "body"}`), nil)
+	res, err := nc.ValidateSpecifications("index", "collection", json.RawMessage(`{"body": "body"}`), nil)
 
 	if err != nil {
 		fmt.Println(err.Error())
diff --git a/connection/websocket/web_socket.go b/connection/websocket/web_socket.go
deleted file mode 100644
index ca701a76..00000000
--- a/connection/websocket/web_socket.go
+++ /dev/null
@@ -1,634 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package websocket
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/url"
-	"sync"
-	"time"
-
-	"github.com/gorilla/websocket"
-	"github.com/kuzzleio/sdk-go/connection"
-	"github.com/kuzzleio/sdk-go/event"
-	"github.com/kuzzleio/sdk-go/state"
-	"github.com/kuzzleio/sdk-go/types"
-)
-
-const (
-	MAX_EMIT_TIMEOUT  = 10
-	MAX_CONNECT_RETRY = 10
-)
-
-type subscription struct {
-	roomID              string
-	channel             string
-	filters             json.RawMessage
-	notificationChannel chan<- types.KuzzleNotification
-	onReconnectChannel  chan<- interface{}
-	subscribeToSelf     bool
-}
-
-type webSocket struct {
-	ws      *websocket.Conn
-	mu      *sync.Mutex
-	queuing bool
-	state   int
-
-	listenChan         chan []byte
-	channelsResult     sync.Map
-	subscriptions      sync.Map
-	lastUrl            string
-	wasConnected       bool
-	eventListeners     map[int]map[chan<- interface{}]bool
-	eventListenersOnce map[int]map[chan<- interface{}]bool
-
-	retrying              bool
-	nbRetried             int
-	stopRetryingToConnect bool
-	requestHistory        map[string]time.Time
-
-	autoQueue          bool
-	autoReconnect      bool
-	autoReplay         bool
-	autoResubscribe    bool
-	host               string
-	offlineQueue       []*types.QueryObject
-	offlineQueueLoader connection.OfflineQueueLoader
-	port               int
-	queueFilter        connection.QueueFilter
-	queueMaxSize       int
-	queueTTL           time.Duration
-	reconnectionDelay  time.Duration
-	replayInterval     time.Duration
-	ssl                bool
-}
-
-var defaultQueueFilter connection.QueueFilter
-
-// NewWebSocket instanciates a new webSocket connection object
-func NewWebSocket(host string, options types.Options) connection.Connection {
-	defaultQueueFilter = func([]byte) bool {
-		return true
-	}
-
-	var opts types.Options
-
-	if options == nil {
-		opts = types.NewOptions()
-	} else {
-		opts = options
-	}
-
-	ws := &webSocket{
-		mu:                    &sync.Mutex{},
-		queueTTL:              opts.QueueTTL(),
-		offlineQueue:          []*types.QueryObject{},
-		queueMaxSize:          opts.QueueMaxSize(),
-		channelsResult:        sync.Map{},
-		subscriptions:         sync.Map{},
-		eventListeners:        make(map[int]map[chan<- interface{}]bool),
-		eventListenersOnce:    make(map[int]map[chan<- interface{}]bool),
-		requestHistory:        make(map[string]time.Time),
-		autoQueue:             opts.AutoQueue(),
-		autoReconnect:         opts.AutoReconnect(),
-		autoReplay:            opts.AutoReplay(),
-		autoResubscribe:       opts.AutoResubscribe(),
-		reconnectionDelay:     opts.ReconnectionDelay(),
-		replayInterval:        opts.ReplayInterval(),
-		state:                 state.Ready,
-		retrying:              false,
-		nbRetried:             0,
-		stopRetryingToConnect: false,
-		queueFilter:           defaultQueueFilter,
-		port:                  opts.Port(),
-		ssl:                   opts.SslConnection(),
-	}
-	ws.host = host
-
-	if opts.OfflineMode() == types.Auto {
-		ws.autoReconnect = true
-		ws.autoQueue = true
-		ws.autoReplay = true
-		ws.autoResubscribe = true
-	}
-	ws.state = state.Offline
-
-	return ws
-}
-
-//Connect connects to a kuzzle instance
-func (ws *webSocket) Connect() (bool, error) {
-	if ws.state != state.Offline {
-		return false, nil
-	}
-
-	ws.state = state.Connecting
-
-	if ws.autoQueue {
-		ws.queuing = true
-	}
-
-	addr := fmt.Sprintf("%s:%d", ws.host, ws.port)
-
-	if ws.lastUrl != addr {
-		ws.wasConnected = false
-		ws.lastUrl = addr
-	}
-
-	var scheme string
-
-	if ws.ssl {
-		scheme = "wss"
-	} else {
-		scheme = "ws"
-	}
-
-	u := url.URL{Scheme: scheme, Host: addr}
-	socket, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
-
-	if err != nil {
-		ws.state = state.Offline
-		ws.EmitEvent(event.NetworkError, err)
-
-		if ws.autoReconnect && !ws.retrying && !ws.stopRetryingToConnect && ws.nbRetried < MAX_CONNECT_RETRY {
-			ws.retrying = true
-			time.Sleep(ws.reconnectionDelay)
-			ws.retrying = false
-			ws.nbRetried++
-			ws.Connect()
-		} else {
-			ws.EmitEvent(event.Disconnected, nil)
-		}
-
-		return false, err
-	}
-
-	ws.ws = socket
-	ws.state = state.Connected
-	ws.stopRetryingToConnect = false
-	ws.queuing = false
-
-	if ws.wasConnected {
-		ws.EmitEvent(event.Reconnected, nil)
-	} else {
-		ws.wasConnected = true
-		ws.EmitEvent(event.Connected, nil)
-	}
-
-	ws.listenChan = make(chan []byte)
-
-	go ws.listen()
-
-	go func() {
-		for {
-			_, message, err := ws.ws.ReadMessage()
-			ws.listenChan <- message
-			// TODO: either send a Disconnected event on a proper disconnection,
-			// or a NetworkError one if the socket has been unexpectedly closed
-			if err != nil {
-				close(ws.listenChan)
-				ws.ws.Close()
-				ws.state = state.Offline
-				if ws.autoQueue {
-					ws.queuing = true
-				}
-				ws.EmitEvent(event.Disconnected, nil)
-				return
-			}
-		}
-	}()
-
-	ws.PlayQueue()
-
-	return ws.wasConnected, err
-}
-
-func (ws *webSocket) Send(query []byte, options types.QueryOptions, responseChannel chan<- *types.KuzzleResponse, requestId string) error {
-	queuable := options == nil || options.Queuable()
-	queuable = queuable && ws.queueFilter(query)
-
-	if ws.queuing && queuable {
-		ws.cleanQueue()
-		qo := &types.QueryObject{
-			Timestamp: time.Now(),
-			ResChan:   responseChannel,
-			Query:     query,
-			RequestId: requestId,
-			Options:   options,
-		}
-		ws.offlineQueue = append(ws.offlineQueue, qo)
-		ws.EmitEvent(event.OfflineQueuePush, qo)
-		return nil
-	}
-
-	if ws.state == state.Connected {
-		return ws.emitRequest(&types.QueryObject{
-			Query:     query,
-			ResChan:   responseChannel,
-			RequestId: requestId,
-		})
-	}
-
-	ws.discardRequest(responseChannel, query)
-	return nil
-}
-
-func (ws *webSocket) discardRequest(responseChannel chan<- *types.KuzzleResponse, query []byte) {
-	if responseChannel != nil {
-		responseChannel <- &types.KuzzleResponse{Status: 400, Error: types.NewError("Unable to execute request: not connected to a Kuzzle server.\nDiscarded request: "+string(query), 400)}
-	}
-}
-
-// Clean up the queue, ensuring the queryTTL and queryMaxSize properties are respected
-func (ws *webSocket) cleanQueue() {
-	now := time.Now()
-	now = now.Add(-ws.queueTTL * time.Millisecond)
-
-	// Clean queue of timed out query
-	if ws.queueTTL > 0 {
-		var query *types.QueryObject
-		for _, query = range ws.offlineQueue {
-			if query.Timestamp.Before(now) {
-				ws.offlineQueue = ws.offlineQueue[1:]
-			} else {
-				break
-			}
-		}
-	}
-
-	if ws.queueMaxSize > 0 && len(ws.offlineQueue) > ws.queueMaxSize {
-		for len(ws.offlineQueue) > ws.queueMaxSize {
-			eventListener := ws.eventListeners[event.OfflineQueuePop]
-			for c := range eventListener {
-				c <- ws.offlineQueue[0]
-			}
-
-			eventListener = ws.eventListenersOnce[event.OfflineQueuePop]
-			for c := range eventListener {
-				c <- ws.offlineQueue[0]
-				delete(ws.eventListenersOnce[event.OfflineQueuePop], c)
-			}
-
-			ws.offlineQueue = ws.offlineQueue[1:]
-		}
-	}
-}
-
-func (ws *webSocket) RegisterSub(channel, roomID string, filters json.RawMessage, subscribeToSelf bool, notifChan chan<- types.KuzzleNotification, onReconnectChannel chan<- interface{}) {
-	subs, found := ws.subscriptions.Load(channel)
-
-	if !found {
-		subs = map[string]subscription{}
-	}
-
-	subs.(map[string]subscription)[roomID] = subscription{
-		channel:             channel,
-		roomID:              roomID,
-		notificationChannel: notifChan,
-		onReconnectChannel:  onReconnectChannel,
-		filters:             filters,
-		subscribeToSelf:     subscribeToSelf,
-	}
-
-	ws.subscriptions.Store(channel, subs)
-}
-
-func (ws *webSocket) UnregisterSub(roomID string) {
-	ws.subscriptions.Range(func(k, v interface{}) bool {
-		for k, sub := range v.(map[string]subscription) {
-			if sub.roomID == roomID {
-				close(sub.onReconnectChannel)
-				close(sub.notificationChannel)
-				delete(v.(map[string]subscription), k)
-			}
-		}
-		return true
-	})
-}
-
-func (ws *webSocket) CancelSubs() {
-	ws.subscriptions.Range(func(roomId, s interface{}) bool {
-		for _, sub := range s.(map[string]subscription) {
-			if sub.notificationChannel != nil {
-				close(sub.onReconnectChannel)
-			}
-			ws.subscriptions.Delete(roomId)
-		}
-		return true
-	})
-}
-
-func (ws *webSocket) listen() {
-	for {
-		msg := <-ws.listenChan
-
-		var message types.KuzzleResponse
-		json.Unmarshal(msg, &message)
-
-		if s, found := ws.subscriptions.Load(message.RoomId); found {
-			var notification types.KuzzleNotification
-			_, fromSelf := ws.requestHistory[message.RequestId]
-
-			json.Unmarshal(msg, &notification)
-
-			for _, sub := range s.(map[string]subscription) {
-				if sub.notificationChannel != nil && (!fromSelf || sub.subscribeToSelf) {
-					sub.notificationChannel <- notification
-				}
-			}
-
-		} else if c, found := ws.channelsResult.Load(message.RequestId); found {
-			if message.Error.Error() != "" && message.Error.Message == "Token expired" {
-				ws.EmitEvent(event.TokenExpired, nil)
-			}
-
-			// If this is a response to a query we simply broadcast the response to the corresponding channel
-			c.(chan<- *types.KuzzleResponse) <- &message
-			close(c.(chan<- *types.KuzzleResponse))
-			ws.channelsResult.Delete(message.RequestId)
-		} else if c, found := ws.channelsResult.Load(message.RoomId); found {
-			c.(chan<- *types.KuzzleResponse) <- &message
-			close(c.(chan<- *types.KuzzleResponse))
-			ws.channelsResult.Delete(message.RequestId)
-		} else {
-			ws.EmitEvent(event.Discarded, &message)
-		}
-	}
-}
-
-// Adds a listener to a Kuzzle global event. When an event is fired, listeners are called in the order of their insertion.
-func (ws *webSocket) AddListener(event int, channel chan<- interface{}) {
-	if ws.eventListeners[event] == nil {
-		ws.eventListeners[event] = make(map[chan<- interface{}]bool)
-	}
-	ws.eventListeners[event][channel] = true
-}
-
-// Removes all listeners, either from all events and close channels
-func (ws *webSocket) RemoveAllListeners(event int) {
-	for k := range ws.eventListeners {
-		if event == k || event == -1 {
-			delete(ws.eventListeners, k)
-		}
-	}
-
-	for k := range ws.eventListenersOnce {
-		if event == k || event == -1 {
-			delete(ws.eventListenersOnce, k)
-		}
-	}
-}
-
-// Removes a listener from an event.
-func (ws *webSocket) RemoveListener(event int, c chan<- interface{}) {
-	delete(ws.eventListeners[event], c)
-	delete(ws.eventListenersOnce[event], c)
-}
-
-func (ws *webSocket) Once(event int, channel chan<- interface{}) {
-	if ws.eventListenersOnce[event] == nil {
-		ws.eventListenersOnce[event] = make(map[chan<- interface{}]bool)
-	}
-	ws.eventListenersOnce[event][channel] = true
-}
-
-func (ws *webSocket) ListenerCount(event int) int {
-	return len(ws.eventListenersOnce[event]) + len(ws.eventListeners[event])
-}
-
-// Emit an event to all registered listeners
-func (ws *webSocket) EmitEvent(event int, arg interface{}) {
-	for c := range ws.eventListeners[event] {
-		c <- arg
-	}
-	for c := range ws.eventListenersOnce[event] {
-		c <- arg
-		close(c)
-		delete(ws.eventListenersOnce[event], c)
-	}
-}
-
-func (ws *webSocket) StartQueuing() {
-	if ws.state == state.Offline && !ws.autoQueue {
-		ws.queuing = true
-	}
-}
-
-func (ws *webSocket) StopQueuing() {
-	if ws.state == state.Offline && !ws.autoQueue {
-		ws.queuing = false
-	}
-}
-
-func (ws *webSocket) ClearQueue() {
-	ws.offlineQueue = nil
-}
-
-// PlayQueue replays the requests queued during offline mode. Works only if the SDK is not in a disconnected state, and if the autoReplay option is set to false.
-func (ws *webSocket) PlayQueue() {
-	if ws.state != state.Offline && !ws.autoReplay {
-		ws.cleanQueue()
-		ws.dequeue()
-	}
-}
-
-func (ws *webSocket) mergeOfflineQueueWithLoader() error {
-	type query struct {
-		requestId  string `json:"requestId"`
-		controller string `json:"controller"`
-		action     string `json:"action"""`
-	}
-
-	additionalOfflineQueue := ws.offlineQueueLoader.Load()
-
-	for _, additionalQuery := range additionalOfflineQueue {
-		for _, offlineQuery := range ws.offlineQueue {
-			q := query{}
-			json.Unmarshal(additionalQuery.Query, &q)
-			if q.requestId != "" || q.action != "" || q.controller != "" {
-				offlineQ := query{}
-				json.Unmarshal(offlineQuery.Query, &offlineQ)
-				if q.requestId != offlineQ.requestId {
-					ws.offlineQueue = append(ws.offlineQueue, additionalQuery)
-				} else {
-					additionalOfflineQueue = additionalOfflineQueue[:1]
-				}
-			} else {
-				return types.NewError("Invalid offline queue request. One or more missing properties: requestId, action, controller.")
-			}
-		}
-	}
-	return nil
-}
-
-func (ws *webSocket) dequeue() error {
-	if ws.offlineQueueLoader != nil {
-		err := ws.mergeOfflineQueueWithLoader()
-		if err != nil {
-			return err
-		}
-	}
-	// Example from sdk where we have a good use of _
-	if len(ws.offlineQueue) > 0 {
-		for _, query := range ws.offlineQueue {
-			ws.emitRequest(query)
-			ws.offlineQueue = ws.offlineQueue[:1]
-			ws.EmitEvent(event.OfflineQueuePop, query)
-			time.Sleep(ws.replayInterval * time.Millisecond)
-			ws.offlineQueue = ws.offlineQueue[:1]
-		}
-	} else {
-		ws.queuing = false
-	}
-	return nil
-}
-
-func (ws *webSocket) emitRequest(query *types.QueryObject) error {
-	now := time.Now()
-	now = now.Add(-MAX_EMIT_TIMEOUT * time.Second)
-
-	ws.channelsResult.Store(query.RequestId, query.ResChan)
-
-	ws.mu.Lock()
-	defer ws.mu.Unlock()
-	err := ws.ws.WriteMessage(websocket.TextMessage, query.Query)
-	if err != nil {
-		return err
-	}
-
-	// Track requests made to allow Room.subscribeToSelf to work
-	ws.requestHistory[query.RequestId] = time.Now()
-	for i, request := range ws.requestHistory {
-		if request.Before(now) {
-			delete(ws.requestHistory, i)
-		}
-	}
-
-	return nil
-}
-
-func (ws *webSocket) Close() error {
-	ws.stopRetryingToConnect = true
-	ws.ws.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
-	ws.state = state.Disconnected
-
-	return ws.ws.Close()
-}
-
-func (ws *webSocket) isValidState() bool {
-	switch ws.state {
-	case state.Initializing, state.Ready, state.Disconnected, state.Error, state.Offline:
-		return true
-	}
-	return false
-}
-
-func (ws *webSocket) State() int {
-	return ws.state
-}
-
-func (ws *webSocket) RequestHistory() map[string]time.Time {
-	return ws.requestHistory
-}
-
-func (ws *webSocket) AutoQueue() bool {
-	return ws.autoQueue
-}
-
-func (ws *webSocket) AutoReconnect() bool {
-	return ws.autoReconnect
-}
-
-func (ws *webSocket) AutoResubscribe() bool {
-	return ws.autoResubscribe
-}
-
-func (ws *webSocket) AutoReplay() bool {
-	return ws.autoReplay
-}
-
-func (ws *webSocket) Host() string {
-	return ws.host
-}
-
-func (ws *webSocket) OfflineQueue() []*types.QueryObject {
-	return ws.offlineQueue
-}
-
-func (ws *webSocket) OfflineQueueLoader() connection.OfflineQueueLoader {
-	return ws.offlineQueueLoader
-}
-
-func (ws *webSocket) Port() int {
-	return ws.port
-}
-
-func (ws *webSocket) QueueFilter() connection.QueueFilter {
-	return ws.queueFilter
-}
-
-func (ws *webSocket) QueueMaxSize() int {
-	return ws.queueMaxSize
-}
-
-func (ws *webSocket) QueueTTL() time.Duration {
-	return ws.queueTTL
-}
-
-func (ws *webSocket) ReplayInterval() time.Duration {
-	return ws.replayInterval
-}
-
-func (ws *webSocket) ReconnectionDelay() time.Duration {
-	return ws.reconnectionDelay
-}
-
-func (ws *webSocket) SslConnection() bool {
-	return ws.ssl
-}
-
-func (ws *webSocket) SetAutoQueue(v bool) {
-	ws.autoQueue = v
-}
-
-func (ws *webSocket) SetAutoReplay(v bool) {
-	ws.autoReplay = v
-}
-
-func (ws *webSocket) SetOfflineQueueLoader(v connection.OfflineQueueLoader) {
-	ws.offlineQueueLoader = v
-}
-
-func (ws *webSocket) SetQueueFilter(v connection.QueueFilter) {
-	if v == nil {
-		ws.queueFilter = defaultQueueFilter
-	} else {
-		ws.queueFilter = v
-	}
-}
-
-func (ws *webSocket) SetQueueMaxSize(v int) {
-	ws.queueMaxSize = v
-}
-
-func (ws *webSocket) SetQueueTTL(v time.Duration) {
-	ws.queueTTL = v
-}
-
-func (ws *webSocket) SetReplayInterval(v time.Duration) {
-	ws.replayInterval = v
-}
diff --git a/document/count.go b/document/count.go
index 057c7f9b..6489e188 100644
--- a/document/count.go
+++ b/document/count.go
@@ -34,10 +34,6 @@ func (d *Document) Count(index string, collection string, body json.RawMessage,
 		return 0, types.NewError("Document.Count: collection required", 400)
 	}
 
-	if body == nil {
-		return 0, types.NewError("Document.Count: body required", 400)
-	}
-
 	ch := make(chan *types.KuzzleResponse)
 
 	query := &types.KuzzleRequest{
@@ -47,6 +43,10 @@ func (d *Document) Count(index string, collection string, body json.RawMessage,
 		Action:     "count",
 		Body:       body,
 	}
+	if options != nil {
+		query.IncludeTrash = options.IncludeTrash()
+	}
+
 	go d.Kuzzle.Query(query, options, ch)
 
 	res := <-ch
diff --git a/document/count_test.go b/document/count_test.go
index fd93f5dc..c228b5ca 100644
--- a/document/count_test.go
+++ b/document/count_test.go
@@ -39,13 +39,6 @@ func TestCountCollectionNull(t *testing.T) {
 	assert.NotNil(t, err)
 }
 
-func TestCountBodyNull(t *testing.T) {
-	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
-	d := document.NewDocument(k)
-	_, err := d.Count("index", "collection", nil, nil)
-	assert.NotNil(t, err)
-}
-
 func TestCountDocumentError(t *testing.T) {
 	c := &internal.MockedConnection{
 		MockSend: func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
diff --git a/document/deleteByQuery.go b/document/deleteByQuery.go
index 8e183502..6bd927b3 100644
--- a/document/deleteByQuery.go
+++ b/document/deleteByQuery.go
@@ -16,22 +16,23 @@ package document
 
 import (
 	"encoding/json"
+	"fmt"
 
 	"github.com/kuzzleio/sdk-go/types"
 )
 
 // DeleteByQuery deletes all the documents from Kuzzle that match the given filter or query.
-func (d *Document) DeleteByQuery(index string, collection string, body string, options types.QueryOptions) ([]string, error) {
+func (d *Document) DeleteByQuery(index string, collection string, body json.RawMessage, options types.QueryOptions) ([]string, error) {
 	if index == "" {
-		return nil, types.NewError("Document.MCreate: index required", 400)
+		return nil, types.NewError("Document.DeleteByQuery: index required", 400)
 	}
 
 	if collection == "" {
-		return nil, types.NewError("Document.MCreate: collection required", 400)
+		return nil, types.NewError("Document.DeleteByQuery: collection required", 400)
 	}
 
-	if body == "" {
-		return nil, types.NewError("Document.MCreate: body required", 400)
+	if body == nil {
+		return nil, types.NewError("Document.DeleteByQuery: body required", 400)
 	}
 
 	ch := make(chan *types.KuzzleResponse)
@@ -52,9 +53,13 @@ func (d *Document) DeleteByQuery(index string, collection string, body string, o
 		return nil, res.Error
 	}
 
-	var deleted []string
-	json.Unmarshal(res.Result, &deleted)
-
-	return deleted, nil
+	var deleted struct {
+		Ids []string `json:"ids"`
+	}
+	err := json.Unmarshal(res.Result, &deleted)
+	if err != nil {
+		return nil, types.NewError(fmt.Sprintf("Unable to parse response: %s\n%s", err.Error(), res.Result), 500)
+	}
 
+	return deleted.Ids, nil
 }
diff --git a/document/deleteByQuery_test.go b/document/deleteByQuery_test.go
index 1a666d8f..031a211e 100644
--- a/document/deleteByQuery_test.go
+++ b/document/deleteByQuery_test.go
@@ -29,7 +29,7 @@ func TestDeleteByQueryIndexNull(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.DeleteByQuery("", "collection", "body", nil)
+	_, err := d.DeleteByQuery("", "collection", json.RawMessage(`{"foo": "bar"}`), nil)
 	assert.NotNil(t, err)
 }
 
@@ -37,7 +37,7 @@ func TestDeleteByQueryCollectionNull(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.DeleteByQuery("index", "", "body", nil)
+	_, err := d.DeleteByQuery("index", "", json.RawMessage(`{"foo": "bar"}`), nil)
 	assert.NotNil(t, err)
 }
 
@@ -45,7 +45,7 @@ func TestDeleteByQueryBodyNull(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.DeleteByQuery("index", "collection", "", nil)
+	_, err := d.DeleteByQuery("index", "collection", nil, nil)
 	assert.NotNil(t, err)
 }
 
@@ -58,7 +58,7 @@ func TestDeleteByQueryDocumentError(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(c, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.DeleteByQuery("index", "collection", "body", nil)
+	_, err := d.DeleteByQuery("index", "collection", json.RawMessage(`{"foo": "bar"}`), nil)
 	assert.NotNil(t, err)
 	assert.Equal(t, "Unit test error", err.(types.KuzzleError).Message)
 }
@@ -85,6 +85,6 @@ func TestDeleteByQueryDocument(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(c, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.DeleteByQuery("index", "collection", "body", nil)
+	_, err := d.DeleteByQuery("index", "collection", json.RawMessage(`{"foo": "bar"}`), nil)
 	assert.Nil(t, err)
 }
diff --git a/document/get.go b/document/get.go
index 8fbdf870..4618b2f0 100644
--- a/document/get.go
+++ b/document/get.go
@@ -43,6 +43,9 @@ func (d *Document) Get(index string, collection string, _id string, options type
 		Action:     "get",
 		Id:         _id,
 	}
+	if options != nil {
+		query.IncludeTrash = options.IncludeTrash()
+	}
 
 	go d.Kuzzle.Query(query, options, ch)
 
diff --git a/document/mCreate.go b/document/mCreate.go
index 13da8ecd..1732c01c 100644
--- a/document/mCreate.go
+++ b/document/mCreate.go
@@ -21,7 +21,7 @@ import (
 )
 
 // MCreate creates the provided documents.
-func (d *Document) MCreate(index string, collection string, body json.RawMessage, options types.QueryOptions) (json.RawMessage, error) {
+func (d *Document) MCreate(index string, collection string, documents json.RawMessage, options types.QueryOptions) (json.RawMessage, error) {
 	if index == "" {
 		return nil, types.NewError("Document.MCreate: index required", 400)
 	}
@@ -30,18 +30,22 @@ func (d *Document) MCreate(index string, collection string, body json.RawMessage
 		return nil, types.NewError("Document.MCreate: collection required", 400)
 	}
 
-	if body == nil {
+	if documents == nil {
 		return nil, types.NewError("Document.MCreate: body required", 400)
 	}
 
 	ch := make(chan *types.KuzzleResponse)
 
+	type body struct {
+		Documents json.RawMessage `json:"documents"`
+	}
+
 	query := &types.KuzzleRequest{
 		Index:      index,
 		Collection: collection,
 		Controller: "document",
 		Action:     "mCreate",
-		Body:       body,
+		Body:       &body{documents},
 	}
 
 	go d.Kuzzle.Query(query, options, ch)
diff --git a/document/mCreateOrReplace.go b/document/mCreateOrReplace.go
index ea134e6f..4ddfa295 100644
--- a/document/mCreateOrReplace.go
+++ b/document/mCreateOrReplace.go
@@ -21,7 +21,7 @@ import (
 )
 
 // MCreateOrReplace creates or replaces the provided documents.
-func (d *Document) MCreateOrReplace(index string, collection string, body json.RawMessage, options types.QueryOptions) (json.RawMessage, error) {
+func (d *Document) MCreateOrReplace(index string, collection string, documents json.RawMessage, options types.QueryOptions) (json.RawMessage, error) {
 	if index == "" {
 		return nil, types.NewError("Document.MCreateOrReplace: index required", 400)
 	}
@@ -30,18 +30,22 @@ func (d *Document) MCreateOrReplace(index string, collection string, body json.R
 		return nil, types.NewError("Document.MCreateOrReplace: collection required", 400)
 	}
 
-	if body == nil {
+	if documents == nil {
 		return nil, types.NewError("Document.MCreateOrReplace: body required", 400)
 	}
 
 	ch := make(chan *types.KuzzleResponse)
 
+	type body struct {
+		Documents json.RawMessage `json:"documents"`
+	}
+
 	query := &types.KuzzleRequest{
 		Index:      index,
 		Collection: collection,
 		Controller: "document",
 		Action:     "mCreateOrReplace",
-		Body:       body,
+		Body:       &body{documents},
 	}
 
 	go d.Kuzzle.Query(query, options, ch)
diff --git a/document/mCreateOrReplace_test.go b/document/mCreateOrReplace_test.go
index a6ff7c74..3e874506 100644
--- a/document/mCreateOrReplace_test.go
+++ b/document/mCreateOrReplace_test.go
@@ -110,6 +110,6 @@ func TestMCreateOrReplaceDocument(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(c, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.MCreateOrReplace("index", "collection", json.RawMessage(`{"foo":"bar"}`), nil)
+	_, err := d.MCreateOrReplace("index", "collection", json.RawMessage(`["foo","bar"]`), nil)
 	assert.Nil(t, err)
 }
diff --git a/document/mCreate_test.go b/document/mCreate_test.go
index 2a62f296..853b2eeb 100644
--- a/document/mCreate_test.go
+++ b/document/mCreate_test.go
@@ -110,6 +110,6 @@ func TestMCreateDocument(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(c, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.MCreate("index", "collection", json.RawMessage(`{"foo":"bar"}`), nil)
+	_, err := d.MCreate("index", "collection", json.RawMessage(`["foo", "bar"]`), nil)
 	assert.Nil(t, err)
 }
diff --git a/document/mGet.go b/document/mGet.go
index 1972f404..b221e7df 100644
--- a/document/mGet.go
+++ b/document/mGet.go
@@ -21,7 +21,7 @@ import (
 )
 
 // MGet fetches multiple documents at once
-func (d *Document) MGet(index string, collection string, ids []string, includeTrash bool, options types.QueryOptions) (json.RawMessage, error) {
+func (d *Document) MGet(index string, collection string, ids []string, options types.QueryOptions) (json.RawMessage, error) {
 	if index == "" {
 		return nil, types.NewError("Document.MGet: index required", 400)
 	}
@@ -37,8 +37,7 @@ func (d *Document) MGet(index string, collection string, ids []string, includeTr
 	ch := make(chan *types.KuzzleResponse)
 
 	type body struct {
-		Ids          []string `json:"ids"`
-		IncludeTrash bool     `json:"includeTrash"`
+		Ids []string `json:"ids"`
 	}
 
 	query := &types.KuzzleRequest{
@@ -46,7 +45,10 @@ func (d *Document) MGet(index string, collection string, ids []string, includeTr
 		Collection: collection,
 		Controller: "document",
 		Action:     "mGet",
-		Body:       &body{Ids: ids, IncludeTrash: includeTrash},
+		Body:       &body{ids},
+	}
+	if options != nil {
+		query.IncludeTrash = options.IncludeTrash()
 	}
 
 	go d.Kuzzle.Query(query, options, ch)
diff --git a/document/mGet_test.go b/document/mGet_test.go
index 3ef55e56..d7486d23 100644
--- a/document/mGet_test.go
+++ b/document/mGet_test.go
@@ -30,7 +30,7 @@ func TestMGetIndexNull(t *testing.T) {
 	d := document.NewDocument(k)
 	var ids []string
 	ids = append(ids, "id1")
-	_, err := d.MGet("", "collection", ids, true, nil)
+	_, err := d.MGet("", "collection", ids, nil)
 	assert.NotNil(t, err)
 }
 
@@ -39,7 +39,7 @@ func TestMGetCollectionNull(t *testing.T) {
 	d := document.NewDocument(k)
 	var ids []string
 	ids = append(ids, "id1")
-	_, err := d.MGet("index", "", ids, true, nil)
+	_, err := d.MGet("index", "", ids, nil)
 	assert.NotNil(t, err)
 }
 
@@ -47,7 +47,7 @@ func TestMGetIdsNull(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
 	d := document.NewDocument(k)
 	var ids []string
-	_, err := d.MGet("index", "collection", ids, true, nil)
+	_, err := d.MGet("index", "collection", ids, nil)
 	assert.NotNil(t, err)
 }
 
@@ -61,7 +61,7 @@ func TestMGetDocumentError(t *testing.T) {
 	d := document.NewDocument(k)
 	var ids []string
 	ids = append(ids, "id1")
-	_, err := d.MGet("index", "collection", ids, true, nil)
+	_, err := d.MGet("index", "collection", ids, nil)
 	assert.NotNil(t, err)
 	assert.Equal(t, "Unit test error", err.(types.KuzzleError).Message)
 }
@@ -115,6 +115,6 @@ func TestMGetDocument(t *testing.T) {
 	d := document.NewDocument(k)
 	var ids []string
 	ids = append(ids, "id1")
-	_, err := d.MGet("index", "collection", ids, true, nil)
+	_, err := d.MGet("index", "collection", ids, nil)
 	assert.Nil(t, err)
 }
diff --git a/document/mReplace.go b/document/mReplace.go
index 24e80724..b6628055 100644
--- a/document/mReplace.go
+++ b/document/mReplace.go
@@ -21,7 +21,7 @@ import (
 )
 
 // MReplace replaces multiple documents at once.
-func (d *Document) MReplace(index string, collection string, body json.RawMessage, options types.QueryOptions) (json.RawMessage, error) {
+func (d *Document) MReplace(index string, collection string, documents json.RawMessage, options types.QueryOptions) (json.RawMessage, error) {
 	if index == "" {
 		return nil, types.NewError("Document.MReplace: index required", 400)
 	}
@@ -30,18 +30,22 @@ func (d *Document) MReplace(index string, collection string, body json.RawMessag
 		return nil, types.NewError("Document.MReplace: collection required", 400)
 	}
 
-	if body == nil {
+	if documents == nil {
 		return nil, types.NewError("Document.MReplace: body required", 400)
 	}
 
 	ch := make(chan *types.KuzzleResponse)
 
+	type body struct {
+		Documents json.RawMessage `json:"documents"`
+	}
+
 	query := &types.KuzzleRequest{
 		Collection: collection,
 		Index:      index,
 		Controller: "document",
 		Action:     "mReplace",
-		Body:       body,
+		Body:       &body{documents},
 	}
 
 	go d.Kuzzle.Query(query, options, ch)
diff --git a/document/mReplace_test.go b/document/mReplace_test.go
index 33df1660..bcf12e2b 100644
--- a/document/mReplace_test.go
+++ b/document/mReplace_test.go
@@ -29,7 +29,7 @@ func TestMReplaceIndexNull(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.MReplace("", "collection", json.RawMessage(`{"foo":"bar"}`), nil)
+	_, err := d.MReplace("", "collection", json.RawMessage(`["foo", "bar"]`), nil)
 	assert.NotNil(t, err)
 }
 
@@ -37,7 +37,7 @@ func TestMReplaceCollectionNull(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.MReplace("index", "", json.RawMessage(`{"foo":"bar"}`), nil)
+	_, err := d.MReplace("index", "", json.RawMessage(`["foo", "bar"]`), nil)
 	assert.NotNil(t, err)
 }
 
@@ -58,7 +58,7 @@ func TestMReplaceDocumentError(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(c, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.MReplace("index", "collection", json.RawMessage(`{"foo":"bar"}`), nil)
+	_, err := d.MReplace("index", "collection", json.RawMessage(`["foo", "bar"]`), nil)
 	assert.NotNil(t, err)
 	assert.Equal(t, "Unit test error", err.(types.KuzzleError).Message)
 }
@@ -111,6 +111,6 @@ func TestMReplaceDocument(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(c, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.MReplace("index", "collection", json.RawMessage(`{"foo":"bar"}`), nil)
+	_, err := d.MReplace("index", "collection", json.RawMessage(`["foo", "bar"]`), nil)
 	assert.Nil(t, err)
 }
diff --git a/document/mUpdate.go b/document/mUpdate.go
index 1dd53fbc..3853eadd 100644
--- a/document/mUpdate.go
+++ b/document/mUpdate.go
@@ -21,7 +21,7 @@ import (
 )
 
 // MUpdate updates multiple documents at once
-func (d *Document) MUpdate(index string, collection string, body json.RawMessage, options types.QueryOptions) (json.RawMessage, error) {
+func (d *Document) MUpdate(index string, collection string, documents json.RawMessage, options types.QueryOptions) (json.RawMessage, error) {
 	if index == "" {
 		return nil, types.NewError("Document.MUpdate: index required", 400)
 	}
@@ -30,18 +30,22 @@ func (d *Document) MUpdate(index string, collection string, body json.RawMessage
 		return nil, types.NewError("Document.MUpdate: collection required", 400)
 	}
 
-	if body == nil {
+	if documents == nil {
 		return nil, types.NewError("Document.MUpdate: body required", 400)
 	}
 
 	ch := make(chan *types.KuzzleResponse)
 
+	type body struct {
+		Documents json.RawMessage `json:"documents"`
+	}
+
 	query := &types.KuzzleRequest{
 		Collection: collection,
 		Index:      index,
 		Controller: "document",
 		Action:     "mUpdate",
-		Body:       body,
+		Body:       &body{documents},
 	}
 
 	go d.Kuzzle.Query(query, options, ch)
diff --git a/document/mUpdate_test.go b/document/mUpdate_test.go
index 590ffc08..deb5be41 100644
--- a/document/mUpdate_test.go
+++ b/document/mUpdate_test.go
@@ -29,7 +29,7 @@ func TestMUpdateIndexNull(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.MUpdate("", "collection", json.RawMessage(`{"foo":"bar"}`), nil)
+	_, err := d.MUpdate("", "collection", json.RawMessage(`["foo", "bar"]`), nil)
 	assert.NotNil(t, err)
 }
 
@@ -37,7 +37,7 @@ func TestMUpdateCollectionNull(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.MUpdate("index", "", json.RawMessage(`{"foo":"bar"}`), nil)
+	_, err := d.MUpdate("index", "", json.RawMessage(`["foo", "bar"]`), nil)
 	assert.NotNil(t, err)
 }
 
@@ -58,7 +58,7 @@ func TestMUpdateDocumentError(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(c, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.MUpdate("index", "collection", json.RawMessage(`{"foo":"bar"}`), nil)
+	_, err := d.MUpdate("index", "collection", json.RawMessage(`["foo", "bar"]`), nil)
 	assert.NotNil(t, err)
 	assert.Equal(t, "Unit test error", err.(types.KuzzleError).Message)
 }
@@ -111,6 +111,6 @@ func TestMUpdateDocument(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(c, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.MUpdate("index", "collection", json.RawMessage(`{"foo":"bar"}`), nil)
+	_, err := d.MUpdate("index", "collection", json.RawMessage(`["foo", "bar"]`), nil)
 	assert.Nil(t, err)
 }
diff --git a/document/search.go b/document/search.go
index ad73fe6d..c2861c32 100644
--- a/document/search.go
+++ b/document/search.go
@@ -43,6 +43,11 @@ func (d *Document) Search(index string, collection string, body json.RawMessage,
 		Action:     "search",
 		Body:       body,
 	}
+	if options != nil {
+		query.IncludeTrash = options.IncludeTrash()
+		query.From = options.From()
+		query.Size = options.Size()
+	}
 
 	go d.Kuzzle.Query(query, options, ch)
 
@@ -52,7 +57,11 @@ func (d *Document) Search(index string, collection string, body json.RawMessage,
 		return nil, res.Error
 	}
 
-	sr := types.NewSearchResult(collection, body, options, res)
+	sr, err := types.NewSearchResult(d.Kuzzle, "scroll", query, options, res)
+
+	if err != nil {
+		return nil, err
+	}
 
 	return sr, nil
 }
diff --git a/document/search_test.go b/document/search_test.go
index 5cfad12c..a38801d2 100644
--- a/document/search_test.go
+++ b/document/search_test.go
@@ -77,7 +77,8 @@ func TestSearchDocument(t *testing.T) {
 
 			return &types.KuzzleResponse{Result: []byte(`
 			{
-				"hits": ["id1", "id2"]
+				"hits": ["id1", "id2"],
+				"total": 42
 			}`),
 			}
 		},
@@ -85,6 +86,166 @@ func TestSearchDocument(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(c, nil)
 	d := document.NewDocument(k)
 
-	_, err := d.Search("index", "collection", json.RawMessage(`{"foo":"bar"}`), nil)
+	response, err := d.Search("index", "collection", json.RawMessage(`{"foo":"bar"}`), nil)
+	assert.Nil(t, err)
+	assert.Equal(t, 2, response.Fetched)
+	assert.Equal(t, 42, response.Total)
+}
+
+func TestSearchDocumentNextFromSize(t *testing.T) {
+	c := &internal.MockedConnection{
+		MockSend: func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
+			return &types.KuzzleResponse{Result: json.RawMessage(`{
+				"hits": ["id1", "id2"],
+				"total": 42
+			}`)}
+		},
+	}
+	k, _ := kuzzle.NewKuzzle(c, nil)
+
+	options := types.NewQueryOptions()
+	options.SetFrom(0)
+	options.SetSize(2)
+
+	sr, err := k.Document.Search("index", "collection", json.RawMessage(`{}`), options)
+	assert.Nil(t, err)
+	assert.Equal(t, 42, sr.Total)
+	assert.Equal(t, 2, sr.Fetched)
+
+	c.MockSend = func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
+		parsedQuery := &types.KuzzleRequest{}
+		json.Unmarshal(query, parsedQuery)
+
+		assert.Equal(t, 2, parsedQuery.From)
+		assert.Equal(t, 2, parsedQuery.Size)
+
+		return &types.KuzzleResponse{Result: json.RawMessage(`{
+			"hits": ["id3"]
+		}`)}
+	}
+
+	nsr, err := sr.Next()
+	assert.Nil(t, err)
+	assert.Equal(t, 3, nsr.Fetched)
+}
+
+func TestSearchDocumentNextEnd(t *testing.T) {
+	c := &internal.MockedConnection{
+		MockSend: func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
+			return &types.KuzzleResponse{Result: json.RawMessage(`{
+				"hits": ["id1", "id2"],
+				"total": 2
+			}`)}
+		},
+	}
+	k, _ := kuzzle.NewKuzzle(c, nil)
+
+	options := types.NewQueryOptions()
+	options.SetFrom(0)
+	options.SetSize(2)
+
+	sr, err := k.Document.Search("index", "collection", json.RawMessage(`{}`), options)
+	assert.Nil(t, err)
+
+	nsr, err := sr.Next()
+
+	assert.Nil(t, err)
+	assert.Nil(t, nsr)
+}
+
+func TestSearchDocumentNextSort(t *testing.T) {
+	c := &internal.MockedConnection{
+		MockSend: func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
+			return &types.KuzzleResponse{Result: json.RawMessage(`{
+				"hits": [
+					{
+						"_id": "id1",
+						"_source": {
+							"foo": {
+								"bar": 3
+							}
+						}
+					},
+					{
+						"_id": "id2",
+						"_source": {
+							"foo": {
+								"bar": 12
+							}
+						}
+					}
+				],
+				"total": 42
+			}`)}
+		},
+	}
+	k, _ := kuzzle.NewKuzzle(c, nil)
+
+	options := types.NewQueryOptions()
+	options.SetSize(2)
+
+	sr, err := k.Document.Search("index", "collection", json.RawMessage(`{
+		"sort":[ 
+			{"_uid": "asc"},
+			{ "foo.bar": "desc" }
+		]
+	}`), options)
+	assert.Nil(t, err)
+
+	c.MockSend = func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
+		parsedQuery := &types.KuzzleRequest{}
+		json.Unmarshal(query, parsedQuery)
+
+		assert.Equal(t, []interface{}{"id2", float64(12)}, parsedQuery.Body.(map[string]interface{})["search_after"])
+
+		return &types.KuzzleResponse{Result: json.RawMessage(`{
+			"hits": ["id3", "id4"],
+			"total": 42
+		}`)}
+	}
+
+	nsr, err := sr.Next()
+	assert.Nil(t, err)
+	assert.Equal(t, 4, nsr.Fetched)
+	assert.NotNil(t, nsr)
+}
+
+func TestSearchDocumentNextScroll(t *testing.T) {
+	c := &internal.MockedConnection{
+		MockSend: func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
+			return &types.KuzzleResponse{Result: json.RawMessage(`{
+				"hits": ["id1", "id2"],
+				"total": 42,
+				"_scroll_id": "scroll_id"
+			}`)}
+		},
+	}
+	k, _ := kuzzle.NewKuzzle(c, nil)
+
+	options := types.NewQueryOptions()
+	options.SetScroll("1m")
+
+	sr, err := k.Document.Search("index", "collection", json.RawMessage(`{}`), options)
+	assert.Nil(t, err)
+	assert.Equal(t, "scroll_id", sr.ScrollId)
+
+	c.MockSend = func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
+		parsedQuery := &types.KuzzleRequest{}
+		json.Unmarshal(query, parsedQuery)
+
+		assert.Equal(t, "1m", options.Scroll())
+		assert.Equal(t, "scroll_id", options.ScrollId())
+		assert.Equal(t, "scroll", parsedQuery.Action)
+
+		return &types.KuzzleResponse{Result: json.RawMessage(`{
+			"hits": ["id3", "id4"],
+			"total": 42,
+			"_scroll_id": "new_scroll"
+		}`)}
+	}
+
+	nsr, err := sr.Next()
 	assert.Nil(t, err)
+	assert.Equal(t, 4, nsr.Fetched)
+	assert.Equal(t, "new_scroll", nsr.ScrollId)
 }
diff --git a/document/validate.go b/document/validate.go
index 1de12136..024f142c 100644
--- a/document/validate.go
+++ b/document/validate.go
@@ -52,8 +52,10 @@ func (d *Document) Validate(index string, collection string, body json.RawMessag
 		return false, res.Error
 	}
 
-	var valid bool
+	var valid struct {
+		Valid bool `json:"valid"`
+	}
 	json.Unmarshal(res.Result, &valid)
 
-	return valid, nil
+	return valid.Valid, nil
 }
diff --git a/document/validate_test.go b/document/validate_test.go
index a11eec9a..40ccb1be 100644
--- a/document/validate_test.go
+++ b/document/validate_test.go
@@ -71,11 +71,12 @@ func TestValidateDocument(t *testing.T) {
 			assert.Equal(t, "index", parsedQuery.Index)
 			assert.Equal(t, "collection", parsedQuery.Collection)
 
-			return &types.KuzzleResponse{Result: []byte(`true`)}
+			return &types.KuzzleResponse{Result: []byte(`{"valid": true}`)}
 		},
 	}
 	k, _ := kuzzle.NewKuzzle(c, nil)
 	d := document.NewDocument(k)
-	_, err := d.Validate("index", "collection", json.RawMessage(`{"foo":"bar"}`), nil)
+	response, err := d.Validate("index", "collection", json.RawMessage(`{"foo":"bar"}`), nil)
 	assert.Nil(t, err)
+	assert.True(t, response)
 }
diff --git a/index/create_test.go b/index/create_test.go
index 57205daf..8c00c252 100644
--- a/index/create_test.go
+++ b/index/create_test.go
@@ -19,10 +19,10 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/index"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/index/delete_test.go b/index/delete_test.go
index d8ae1eff..fbb27145 100644
--- a/index/delete_test.go
+++ b/index/delete_test.go
@@ -19,10 +19,10 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/index"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/index/exists_test.go b/index/exists_test.go
index 7b5e3e05..60a3b94a 100644
--- a/index/exists_test.go
+++ b/index/exists_test.go
@@ -19,10 +19,10 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/index"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/index/getAutoRefresh.go b/index/get_auto_refresh.go
similarity index 100%
rename from index/getAutoRefresh.go
rename to index/get_auto_refresh.go
diff --git a/index/getAutoRefresh_test.go b/index/get_auto_refresh_test.go
similarity index 97%
rename from index/getAutoRefresh_test.go
rename to index/get_auto_refresh_test.go
index 4177df21..315fc65f 100644
--- a/index/getAutoRefresh_test.go
+++ b/index/get_auto_refresh_test.go
@@ -19,10 +19,10 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/index"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/index/mDelete_test.go b/index/mDelete_test.go
index 14e97a62..557168b7 100644
--- a/index/mDelete_test.go
+++ b/index/mDelete_test.go
@@ -19,10 +19,10 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/index"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/index/refreshInternal_test.go b/index/refreshInternal_test.go
index e9d957fd..3e9f11fd 100644
--- a/index/refreshInternal_test.go
+++ b/index/refreshInternal_test.go
@@ -19,10 +19,10 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/index"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/index/refresh_test.go b/index/refresh_test.go
index d51be19c..f4be8bd5 100644
--- a/index/refresh_test.go
+++ b/index/refresh_test.go
@@ -19,10 +19,10 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/index"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/index/setAutoRefresh_test.go b/index/setAutoRefresh_test.go
index 515617df..03bb84cf 100644
--- a/index/setAutoRefresh_test.go
+++ b/index/setAutoRefresh_test.go
@@ -19,10 +19,10 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/index"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/internal/mock_connection.go b/internal/mock_connection.go
index 80ca831e..1ce69471 100644
--- a/internal/mock_connection.go
+++ b/internal/mock_connection.go
@@ -18,21 +18,18 @@ import (
 	"encoding/json"
 	"time"
 
-	"github.com/kuzzleio/sdk-go/connection"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/mock"
 )
 
-var offlineQueue []*types.QueryObject
-
 type MockedConnection struct {
 	mock.Mock
 	MockSend               func([]byte, types.QueryOptions) *types.KuzzleResponse
 	MockEmitEvent          func(int, interface{})
-	MockAddListener        func(int, chan<- interface{})
+	MockAddListener        func(int, chan<- json.RawMessage)
 	MockRemoveAllListeners func(int)
-	MockRemoveListener     func(int, chan<- interface{})
-	MockOnce               func(int, chan<- interface{})
+	MockRemoveListener     func(int, chan<- json.RawMessage)
+	MockOnce               func(int, chan<- json.RawMessage)
 	MockListenerCount      func(int) int
 
 	state int
@@ -47,7 +44,6 @@ func (c *MockedConnection) Send(query []byte, options types.QueryOptions, respon
 }
 
 func (c *MockedConnection) Connect() (bool, error) {
-	offlineQueue = make([]*types.QueryObject, 1)
 	return false, nil
 }
 
@@ -55,13 +51,13 @@ func (c *MockedConnection) Close() error {
 	return nil
 }
 
-func (c *MockedConnection) AddListener(event int, channel chan<- interface{}) {
+func (c *MockedConnection) AddListener(event int, channel chan<- json.RawMessage) {
 	if c.MockAddListener != nil {
 		c.MockAddListener(event, channel)
 	}
 }
 
-func (c *MockedConnection) Once(event int, channel chan<- interface{}) {
+func (c *MockedConnection) Once(event int, channel chan<- json.RawMessage) {
 	if c.MockOnce != nil {
 		c.MockOnce(event, channel)
 	}
@@ -84,7 +80,7 @@ func (c *MockedConnection) EmitEvent(event int, arg interface{}) {
 	}
 }
 
-func (c *MockedConnection) RegisterSub(channel, roomID string, filters json.RawMessage, subscribeToSelf bool, notifChan chan<- types.KuzzleNotification, onReconnectChan chan<- interface{}) {
+func (c *MockedConnection) RegisterSub(channel, roomID string, filters json.RawMessage, subscribeToSelf bool, notifChan chan<- types.NotificationResult, onReconnectChan chan<- interface{}) {
 }
 
 func (c *MockedConnection) CancelSubs() {}
@@ -99,76 +95,34 @@ func (c *MockedConnection) RequestHistory() map[string]time.Time {
 
 func (c *MockedConnection) RenewSubscriptions() {}
 
-func (c *MockedConnection) StartQueuing() {}
-
-func (c *MockedConnection) StopQueuing() {}
-
-func (c *MockedConnection) RemoveListener(event int, channel chan<- interface{}) {
+func (c *MockedConnection) RemoveListener(event int, channel chan<- json.RawMessage) {
 	if c.MockRemoveListener != nil {
 		c.MockRemoveListener(event, channel)
 	}
 }
 
-func (c *MockedConnection) PlayQueue() {}
-
 func (c *MockedConnection) RemoveAllListeners(event int) {
 	if c.MockRemoveAllListeners != nil {
 		c.MockRemoveAllListeners(event)
 	}
 }
 
-func (c *MockedConnection) ClearQueue() {
-	offlineQueue = nil
-}
-
-func (c *MockedConnection) AutoQueue() bool {
-	return true
-}
-
-func (c *MockedConnection) AutoReconnect() bool {
-	return true
-}
-
 func (c *MockedConnection) AutoResubscribe() bool {
 	return true
 }
 
-func (c *MockedConnection) AutoReplay() bool {
-	return true
-}
-
 func (c *MockedConnection) Host() string {
 	return ""
 }
 
-func (c *MockedConnection) OfflineQueue() []*types.QueryObject {
-	return offlineQueue
-}
-
-func (c *MockedConnection) OfflineQueueLoader() connection.OfflineQueueLoader {
-	return nil
+func (c *MockedConnection) IsReady() bool {
+	return true
 }
 
 func (c *MockedConnection) Port() int {
 	return 0
 }
 
-func (c *MockedConnection) QueueFilter() connection.QueueFilter {
-	return nil
-}
-
-func (c *MockedConnection) QueueMaxSize() int {
-	return 0
-}
-
-func (c *MockedConnection) QueueTTL() time.Duration {
-	return 0
-}
-
-func (c *MockedConnection) ReplayInterval() time.Duration {
-	return 0
-}
-
 func (c *MockedConnection) ReconnectionDelay() time.Duration {
 	return 0
 }
@@ -177,32 +131,7 @@ func (c *MockedConnection) SslConnection() bool {
 	return false
 }
 
-func (c *MockedConnection) SetAutoQueue(v bool) {
-}
-
-func (c *MockedConnection) SetAutoReplay(v bool) {
-}
-
-func (c *MockedConnection) SetOfflineQueueLoader(v connection.OfflineQueueLoader) {
-}
-
-func (c *MockedConnection) SetQueueFilter(v connection.QueueFilter) {
-}
-
-func (c *MockedConnection) SetQueueMaxSize(v int) {
-}
-
-func (c *MockedConnection) SetQueueTTL(v time.Duration) {
-}
-
-func (c *MockedConnection) SetReplayInterval(v time.Duration) {
-}
-
 // mock specific functions
 func (c *MockedConnection) SetState(value int) {
 	c.state = value
 }
-
-func (c *MockedConnection) AddToOfflineQueue(q *types.QueryObject) {
-	offlineQueue = append(offlineQueue, q)
-}
diff --git a/internal/mock_room.go b/internal/mock_room.go
index 13a4c2cb..b146e138 100644
--- a/internal/mock_room.go
+++ b/internal/mock_room.go
@@ -20,15 +20,15 @@ type MockedRoom struct {
 	MockedSubscribe func()
 }
 
-func (m MockedRoom) Subscribe(realtimeNotificationChannel chan<- *types.KuzzleNotification) {
+func (m MockedRoom) Subscribe(realtimeNotificationChannel chan<- *types.NotificationResult) {
 	m.MockedSubscribe()
 }
 func (m MockedRoom) Unsubscribe() error {
 	return nil
 }
 
-func (m MockedRoom) GetRealtimeChannel() chan<- *types.KuzzleNotification {
-	return make(chan<- *types.KuzzleNotification)
+func (m MockedRoom) GetRealtimeChannel() chan<- *types.NotificationResult {
+	return make(chan<- *types.NotificationResult)
 }
 
 func (m MockedRoom) GetResponseChannel() chan<- *types.SubscribeResponse {
diff --git a/internal/wrappers/.gitignore b/internal/wrappers/.gitignore
deleted file mode 100644
index b46c86b9..00000000
--- a/internal/wrappers/.gitignore
+++ /dev/null
@@ -1,37 +0,0 @@
-# IDE
-.idea
-
-# swig generated wrapper code
-kcore_wrap.c
-
-# build
-build/c
-build/java/build
-build/java/src
-build/java/io
-build/android/app/build
-build/android/app/src/main/java/
-build/android/app/src/main/jniLibs/
-build/android/build/
-build/android/.gradle/
-build/io/
-build/java/.gradle/
-
-# features
-features/docker-compose.yml
-features/features.iml
-features/java/.classpath
-features/java/.gradle/
-features/java/.project
-features/java/.settings/
-features/java/bin/
-features/java/build/
-features/.gradle/
-features/java/java.iml
-features/java/libs/
-
-wrappers.iml
-.classpath
-.gradle/
-.project
-.settings/
\ No newline at end of file
diff --git a/internal/wrappers/.travis.yml b/internal/wrappers/.travis.yml
deleted file mode 100644
index 60ae288c..00000000
--- a/internal/wrappers/.travis.yml
+++ /dev/null
@@ -1,17 +0,0 @@
-language: go
-sudo: required
-go:
-  - 1.9
-install:
-  - git clone https://github.com/json-c/json-c.git
-  - cd json-c
-  - sudo apt-get install build-essential
-  - sh autogen.sh
-  - ./configure
-  - make
-  - sudo make install
-  - cd -
-  - go get -t -v ./...
-script:
-  - wrongfmt=$(gofmt -l .); if [ -n "$wrongfmt" ]; then printf "File format error:\n$wrongfmt\n"; (exit 1); fi
-  - make core
diff --git a/internal/wrappers/LICENSE b/internal/wrappers/LICENSE
deleted file mode 100644
index dd231b79..00000000
--- a/internal/wrappers/LICENSE
+++ /dev/null
@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2015-2017 Kuzzle
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/internal/wrappers/Makefile b/internal/wrappers/Makefile
deleted file mode 100644
index e8888c09..00000000
--- a/internal/wrappers/Makefile
+++ /dev/null
@@ -1,245 +0,0 @@
-ROOT_DIR = $(dir $(abspath $(lastword $(MAKEFILE_LIST))))
-ifeq ($(OS),Windows_NT)
-	STATICLIB = .lib
-	DYNLIB = .dll
-	GOROOT ?= C:/Go
-	GOCC ?= $(GOROOT)bin\go
-	SEP = \\
-	RM = del /Q /F /S
-	RRM = rmdir /S /Q
-	MV = rename
-	CMDSEP = &
-	ROOT_DIR_CLEAN = $(subst /,\,$(ROOT_DIR))
-	LIB_PREFIX =
-else
-	STATICLIB = .a
-	DYNLIB = .so
-	GOROOT ?= /usr/local/go
-	GOCC ?= $(GOROOT)/bin/go
-	SEP = /
-	RM = rm -f
-	RRM = rm -f -r
-	MV = mv -f
-	CMDSEP = ;
-	ROOT_DIR_CLEAN = $(ROOT_DIR)
-	LIB_PREFIX = lib
-endif
-
-PATHSEP = $(strip $(SEP))
-ROOTOUTDIR = $(ROOT_DIR)build
-JAVA_HOME ?= /usr/local
-PYTHON_INCLUDE_DIR ?= `pkg-config --cflags python3`
-GOFLAGS = -buildmode=c-archive
-GOSRC = .$(PATHSEP)cgo$(PATHSEP)kuzzle$(PATHSEP)
-GOTARGETDIR = $(ROOTOUTDIR)/c
-GOTARGET = $(GOTARGETDIR)$(PATHSEP)$(LIB_PREFIX)kuzzlesdk$(STATICLIB)
-GOTARGETSO = $(GOTARGETDIR)$(PATHSEP)$(LIB_PREFIX)kuzzlesdk$(DYNLIB)
-CPPDIR = $(ROOT_DIR)cpp
-HEADERSDIR = $(ROOT_DIR)headers
-
-CPPFLAGS = -g -fPIC -std=c++11
-INCS = -I$(HEADERSDIR) -I$(CPPDIR) -I$(ROOT_DIR)templates -I$(GOTARGETDIR)
-LDFLAGS = -L$(GOTARGETDIR)
-LIBS = -lkuzzlesdk
-SRCS = kcore_wrap.cxx
-OBJS = $(SRCS:.cxx=.o)
-
-JAVAINCLUDE = -I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/linux
-PYTHONINCLUDE = $(PYTHON_INCLUDE_DIR) -I$(ROOT_DIR)templates/python
-
-CPP_SDK_SRCS = kuzzle.cpp \
-					document.cpp \
-					collection.cpp \
-					realtime.cpp \
-					auth.cpp \
-					server.cpp \
-					index.cpp
-
-CPPSRCS = $(CPP_SDK_SRCS) \
-					kcore_wrap.cxx
-
-CPPSDK = $(CPP_SDK_SRCS:.cpp=.o)
-
-SWIG = swig
-
-all: python java csharp android
-
-kcore_wrap.o: kcore_wrap.cxx
-	$(CXX) -c $< -o $@ $(CPPFLAGS) $(LDFLAGS) $(LIBS) $(INCS) $(LANGINCLUDE)
-
-%.o: cpp/%.cpp
-	$(CXX) -fPIC -c $< -o $(OUTDIR)/$@ $(CPPFLAGS) -I./headers -I./build/c/ -L./build/c -lkuzzlesdk
-
-core_java:
-ifneq ($(OS),Windows_NT)
-ifeq ($(wildcard $(GOCC)),)
-	$(error "Unable to find go compiler")
-endif
-endif
-	cd ..$(PATHSEP)..$(PATHSEP) && go get .$(PATHSEP)... $(CMDSEP) cd internal$(PATHSEP)wrappers
-	$(GOCC) build -o $(GOTARGET) $(GOFLAGS) $(GOSRC)
-	$(GOCC) build -o $(GOTARGETSO) $(GOFLAGS) $(GOSRC)
-ifeq ($(OS),Windows_NT)
-	$(MV) $(subst /,\,$(GOTARGETDIR)$(PATHSEP)$(LIB_PREFIX)kuzzlesdk.h) kuzzle.h
-else
-	$(MV) $(GOTARGETDIR)$(PATHSEP)$(LIB_PREFIX)kuzzlesdk.h $(GOTARGETDIR)$(PATHSEP)kuzzle.h
-endif
-
-core_python: core_java
-
-core_csharp: core_java
-
-core_cpp: core_java
-
-wrapper_java: $(OBJS)
-
-wrapper_python: $(OBJS)
-
-wrapper_csharp: $(OBJS)
-
-java_object:
-	$(CXX) -shared kcore_wrap.o -o $(OUTDIR)/$(LIB_PREFIX)kuzzle-wrapper-java$(DYNLIB) $(CPPFLAGS) $(LDFLAGS) $(LIBS) $(INCS) $(JAVAINCLUDE)
-	strip $(OUTDIR)/$(LIB_PREFIX)kuzzle-wrapper-java$(DYNLIB)
-
-android_object:
-	$(CXX) -shared kcore_wrap.o -o $(OUTDIR)/../../../../jniLibs/$(ARCH)/$(LIB_PREFIX)kuzzle-wrapper-android$(DYNLIB) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) $(LIBS) $(INCS) $(JAVAINCLUDE)
-	strip $(OUTDIR)/../../../../jniLibs/$(ARCH)/$(LIB_PREFIX)kuzzle-wrapper-android$(DYNLIB)
-
-python_object:
-	$(CXX) -shared kcore_wrap.o -o $(OUTDIR)/$(LIB_PREFIX)kuzzle-wrapper-python$(DYNLIB) $(CPPFLAGS) $(LDFLAGS) $(LIBS) $(INCS) $(PYTHONINCLUDE)
-	strip $(OUTDIR)/$(LIB_PREFIX)kuzzle-wrapper-python$(DYNLIB)
-
-csharp_object:
-ifeq ($(OS),Windows_NT)
-	$(CXX) -shared kcore_wrap.o -o $(OUTDIR)/$(LIB_PREFIX)kuzzle-wrapper-csharp$(DYNLIB) $(CPPFLAGS) $(LDFLAGS) $(LIBS) $(INCS) -lWinmm -lntdll -lWS2_32
-else
-	$(CXX) -shared kcore_wrap.o -o $(OUTDIR)/$(LIB_PREFIX)kuzzle-wrapper-csharp$(DYNLIB) $(CPPFLAGS) $(LDFLAGS) $(LIBS) $(INCS)
-endif
-	strip $(OUTDIR)/$(LIB_PREFIX)kuzzle-wrapper-csharp$(DYNLIB)
-
-swig:
-	$(SWIG) -Wall -c++ -$(LANGUAGE) $(SWIGOPTS) -outdir $(OUTDIR) -o $(SRCS) $(INCS) $(LANGINCLUDE) templates/$(LANGUAGE)/core.i
-
-swig_java:
-ifeq ($(OS),Windows_NT)
-	@if not exist $(OUTDIR) mkdir $(OUTDIR)
-else
-	mkdir -p $(OUTDIR)
-endif
-	$(SWIG) -Wall -c++ -java -package io.kuzzle.sdk -outdir $(OUTDIR) -o $(SRCS) $(INCS) $(JAVAINCLUDE) templates/java/core.i
-
-swig_android:
-ifeq ($(OS),Windows_NT)
-	@if not exist $(OUTDIR) mkdir $(OUTDIR)
-else
-	mkdir -p $(OUTDIR)
-endif
-	$(SWIG) -Wall -c++ -java -package io.kuzzle.sdk -outdir $(OUTDIR) -o $(SRCS) $(INCS) $(JAVAINCLUDE) templates/android/core.i
-
-swig_python:
-ifeq ($(OS),Windows_NT)
-	@if not exist $(OUTDIR) mkdir $(OUTDIR)
-else
-	mkdir -p $(OUTDIR)
-endif
-	$(SWIG) -Wall -c++ -python -py3 -outdir $(OUTDIR) -o $(SRCS) $(INCS) $(PYTHONINCLUDE) templates/python/core.i
-
-swig_csharp:
-ifeq ($(OS),Windows_NT)
-	@if not exist $(subst /,\,$(OUTDIR)) mkdir $(subst /,\,$(OUTDIR))
-else
-	mkdir -p $(OUTDIR)
-endif
-	$(SWIG) -Wall -c++ -csharp -namespace Kuzzleio -dllimport kuzzle-wrapper-csharp -outdir $(OUTDIR) -o $(SRCS) $(INCS)  templates/csharp/core.i
-
-makedir:
-ifeq ($(OS),Windows_NT)
-	@if not exist $(subst /,\,$(OUTDIR)) mkdir $(subst /,\,$(OUTDIR))
-else
-	mkdir -p $(OUTDIR)
-endif
-
-java: LANGINCLUDE = $(JAVAINCLUDE)
-java: OUTDIR = $(ROOTOUTDIR)/java/io/kuzzle/sdk
-java: core_java swig_java wrapper_java java_object
-	$(JAVA_HOME)/bin/javac $(OUTDIR)/*.java
-	mkdir -p $(ROOTOUTDIR)/io/kuzzle/sdk/resources
-	cp build/java/io/kuzzle/sdk/$(LIB_PREFIX)kuzzle-wrapper-java.so build/io/kuzzle/sdk/resources
-	mkdir -p $(ROOTOUTDIR)/java/src/main/resources
-	mkdir -p $(ROOTOUTDIR)/java/src/main/java
-	mv build/java/io/kuzzle/sdk/$(LIB_PREFIX)kuzzle-wrapper-java.so $(ROOTOUTDIR)/java/src/main/resources/
-	ln -sf $(ROOTOUTDIR)/java/io/kuzzle/sdk/* $(ROOTOUTDIR)/java/src/main/java/
-	cd build/java && sh gradlew sourcesJar jar javadocJar && cd -
-	cp -p $(GOTARGET) $(OUTDIR)
-	cp -p $(GOTARGETSO) $(OUTDIR)
-
-csharp: OUTDIR = $(ROOTOUTDIR)/csharp
-csharp: core_csharp swig_csharp wrapper_csharp csharp_object
-	mcs -t:library $(OUTDIR)/*.cs -sdk:2 -out:$(OUTDIR)/$(LIB_PREFIX)kuzzle-csharp$(DYNLIB)
-ifeq ($(OS),Windows_NT)
-	$(RM) "$(subst /,\,$(OUTDIR))$(PATHSEP)*.cs"
-else
-	$(RM) $(OUTDIR)$(PATHSEP)*.cs
-endif
-
-makeabifolder:
-	mkdir -p $(OUTDIR)/../../../../jniLibs/$(ARCH)
-
-android: ARCH ?= x86
-android: LANGINCLUDE = $(JAVAINCLUDE)
-android: GOFLAGS = -buildmode=c-shared
-android: OUTDIR = $(ROOTOUTDIR)/android/app/src/main/java/io/kuzzle/sdk
-android: makeabifolder core_java swig_android wrapper_java android_object
-	cd build/android/app/src/main/jni && ndk-build && cd - && cd build/android && cp app/src/main/obj/local/$(ARCH)/*.so app/src/main/jniLibs/$(ARCH)/ && bash ./gradlew assemble
-
-python: LANGINCLUDE = $(PYTHONINCLUDE)
-python: OUTDIR = $(ROOTOUTDIR)/python
-python: CC = $(CPP)
-python: CFLAGS = -fPIC
-python: core_python swig_python wrapper_python python_object
-	cp $(ROOT_DIR)templates/python/*.py $(OUTDIR)
-	cp $(ROOT_DIR)$(SRCS) $(OUTDIR)/
-	cp $(ROOT_DIR)kcore_wrap.h $(OUTDIR)/
-	python3 $(OUTDIR)/setup.py build_ext -I $(HEADERSDIR):$(CPPDIR):$(OUTDIR):$(GOTARGETDIR):$(OUTDIR)/templates/python -L $(OUTDIR):$(GOTARGETDIR) -R $(GOTARGETDIR) -l kuzzlesdk  -b $(OUTDIR) -t $(OUTDIR)/tmp
-	cp -p $(GOTARGET) $(OUTDIR)
-	cp -p $(GOTARGETSO) $(OUTDIR)
-
-cpp: OUTDIR = $(ROOTOUTDIR)/cpp
-cpp: LANGUAGE = c++
-cpp: makedir core_cpp $(CPPSDK)
-		ar rvs $(OUTDIR)/libcpp$(STATICLIB) $(OUTDIR)/*.o
-		$(CXX) -shared -fPIC -o $(OUTDIR)/libcpp$(DYNLIB) -Wl,--whole-archive $(OUTDIR)/libcpp$(STATICLIB) build/c/$(LIB_PREFIX)kuzzlesdk$(STATICLIB) -Wl,--no-whole-archive
-
-clean:
-ifeq ($(OS),Windows_NT)
-	if exist kcore_wrap.cxx $(RM) kcore_wrap.cxx
-	if exist kcore_wrap.h $(RM) kcore_wrap.h
-	if exist kcore_wrap.o $(RM) kcore_wrap.o
-	if exist build$(PATHSEP)c $(RRM) build$(PATHSEP)c
-	if exist build$(PATHSEP)java$(PATHSEP)src  $(RRM) build$(PATHSEP)java$(PATHSEP)src
-	if exist build$(PATHSEP)java$(PATHSEP)io $(RRM) build$(PATHSEP)java$(PATHSEP)io
-	if exist build$(PATHSEP)java$(PATHSEP)build $(RRM) build$(PATHSEP)java$(PATHSEP)build
-	if exist build$(PATHSEP)python $(RRM) build$(PATHSEP)python
-	if exist build$(PATHSEP)csharp $(RRM) build$(PATHSEP)csharp
-	if exist build$(PATHSEP)io $(RRM) build$(PATHSEP)io
-	if exist build$(PATHSEP)android$(PATHSEP)app$(PATHSEP)build build$(PATHSEP)android$(PATHSEP)app$(PATHSEP)build
-	if exist build$(PATHSEP)android$(PATHSEP)app$(PATHSEP)src$(PATHSEP)main$(PATHSEP)java build$(PATHSEP)android$(PATHSEP)app$(PATHSEP)src$(PATHSEP)main$(PATHSEP)java
-	if exist build$(PATHSEP)android$(PATHSEP)app$(PATHSEP)src$(PATHSEP)main$(PATHSEP)jniLibs build$(PATHSEP)android$(PATHSEP)app$(PATHSEP)src$(PATHSEP)main$(PATHSEP)jniLibs
-	if exist build$(PATHSEP)android$(PATHSEP)build build$(PATHSEP)android$(PATHSEP)build
-else
-	$(RRM) build/c
-	$(RRM) build/java/src build/java/io build/java/build
-	$(RRM) build/python
-	$(RRM) build/csharp
-	$(RRM) build/cpp
-	$(RRM) kcore_wrap.cxx kcore_wrap.h kcore_wrap.o
-	$(RRM) build/io
-	$(RRM) build/android/app/build
-	$(RRM) build/android/app/src/main/java
-	$(RRM) build/android/app/src/main/jniLibs/
-	$(RRM) build/android/build
-endif
-.PHONY: all java csharp python wrapper swig clean object core
-
-
-.DEFAULT_GOAL := all
diff --git a/internal/wrappers/README.md b/internal/wrappers/README.md
deleted file mode 100644
index e4903e40..00000000
--- a/internal/wrappers/README.md
+++ /dev/null
@@ -1,41 +0,0 @@
-[![Build Status](https://travis-ci.org/kuzzleio/sdk-go.svg?branch=master)](https://travis-ci.org/kuzzleio/sdk-go)
-
-# SDK Wrappers
-
-This project contains a CGO wrapper to Kuzzle's [Go SDK](https://github.com/kuzzleio/sdk-go) and [SWIG templates](http://www.swig.org/), allowing to publish Kuzzle's SDK in multiple languages.
-
-# Pre-requisites
-
-* [Go](https://golang.org/doc/install)
-* G++ 6.x
-
-## C++ SDK
-
-You can use Docker to run the C++ functional tests:
- - Build the SDK : `docker run --rm -it -v "$(pwd)":/go/src/github.com/kuzzleio/sdk-go kuzzleio/sdk-cross:amd64 /build.sh`
- - Run a Kuzzle stack : `sh .codepipeline/start_kuzzle.sh`
- - Build and run features : `docker run --rm -it --network codepipeline_default --link kuzzle -e KUZZLE_HOST=kuzzle -v "$(pwd)":/go/src/github.com/kuzzleio/sdk-go  kuzzleio/sdk-cross:amd64 sh internal/wrappers/features/run_cpp.sh`
-`
-
-You can specify a single feature file to be run by passing it as argument to the `run_***.sh` script.  
-Run only the collection features : `docker run --rm -it --network codepipeline_default --link kuzzle -e KUZZLE_HOST=kuzzle -v "$(pwd)":/go/src/github.com/kuzzleio/sdk-go  kuzzleio/sdk-cross:amd64 sh internal/wrappers/features/run_cpp.sh collection.feature`
-
-# Contributing
-
-* Clone this project:
-
-```sh
-$ git clone git@github.com:kuzzleio/sdk-wrappers.git
-```
-
-* Build all SDKs:
-
-```sh
-$ make
-```
-
-* If you need to build the CGO wrapper only:
-
-```sh
-$ make core
-```
diff --git a/internal/wrappers/build/android/app/build.gradle b/internal/wrappers/build/android/app/build.gradle
deleted file mode 100644
index 6e8241af..00000000
--- a/internal/wrappers/build/android/app/build.gradle
+++ /dev/null
@@ -1,139 +0,0 @@
-apply plugin: 'com.android.library'
-
-version = "4.0"
-
-configurations {
-    javadocDeps
-}
-
-android {
-    compileSdkVersion 26
-    defaultConfig {
-        minSdkVersion 14
-        targetSdkVersion 26
-        versionCode 1
-        versionName version
-
-    }
-    sourceSets {
-      main {
-          java {
-              srcDir 'src/main/java'
-          }
-          jni.srcDirs = []
-      }
-    }
-    buildTypes {
-        release {
-            minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
-        }
-    }
-    lintOptions {
-        abortOnError false
-    }
-}
-
-dependencies {
-    implementation 'com.android.support:appcompat-v7:26.1.0'
-    implementation 'com.android.support:support-annotations:21.0.1'
-}
-
-repositories {
-    jcenter()
-}
-
-ext {
-    bintrayRepo = 'maven'
-    bintrayName = 'kuzzle-sdk-android'
-
-    publishedGroupId = 'io.kuzzle'
-    libraryName = 'kuzzle-sdk-android'
-    artifact = 'sdk-android'
-
-    libraryDescription = 'Kuzzle Android SDK aar'
-
-    siteUrl = 'https://github.com/kuzzleio/sdk-go'
-    gitUrl = 'https://github.com/kuzzleio/sdk-go.git'
-    githubRepository= 'kuzzleio/sdk-go'
-
-    libraryVersion = version
-
-    developerId = 'kblondel'
-    developerName = 'Kevin Blondel'
-    developerEmail = 'kblondel@kaliop.com'
-
-    licenseName = 'The Apache Software License, Version 2.0'
-    licenseUrl = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
-    allLicenses = ["Apache-2.0"]
-}
-// from: 'https://raw.githubusercontent.com/nisrulz/JCenter/master/installv1.gradle'
-apply plugin: 'com.github.dcendents.android-maven'
-
-group = publishedGroupId                               // Maven Group ID for the artifact
-
-install {
-    repositories.mavenInstaller {
-        // This generates POM.xml with proper parameters
-        pom {
-            project {
-                packaging 'aar'
-                groupId publishedGroupId
-                artifactId artifact
-
-                // Add your description here
-                name libraryName
-                description libraryDescription
-                url siteUrl
-
-                // Set your license
-                licenses {
-                    license {
-                        name licenseName
-                        url licenseUrl
-                    }
-                }
-                developers {
-                    developer {
-                        id developerId
-                        name developerName
-                        email developerEmail
-                    }
-                }
-                scm {
-                    connection gitUrl
-                    developerConnection gitUrl
-                    url siteUrl
-
-                }
-            }
-        }
-    }
-}
-
-// from: 'https://raw.githubusercontent.com/nisrulz/JCenter/master/bintrayv1.gradle'
-apply plugin: 'com.jfrog.bintray'
-
-// Bintray
-bintray {
-    user = System.getenv("bintray_user")
-    key = System.getenv("bintray_apikey")
-
-    configurations = ['archives']
-    pkg {
-        repo = bintrayRepo
-        name = bintrayName
-        desc = libraryDescription
-        websiteUrl = siteUrl
-        issueTrackerUrl = siteUrl+'/issues'
-        vcsUrl = gitUrl
-        licenses = allLicenses
-        githubRepo = githubRepository //Optional Github repository
-        githubReleaseNotesFile = 'README.md' //Optional Github readme file
-        publish = true
-        publicDownloadNumbers = true
-        version {
-            desc = libraryDescription
-        }
-    }
-}
diff --git a/internal/wrappers/build/android/app/src/main/AndroidManifest.xml b/internal/wrappers/build/android/app/src/main/AndroidManifest.xml
deleted file mode 100644
index 5d729e26..00000000
--- a/internal/wrappers/build/android/app/src/main/AndroidManifest.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="io.kuzzle.sdk">
-
-    <uses-sdk android:minSdkVersion="14"/>
-    <application android:allowBackup="true" android:supportsRtl="true">
-    </application>
-
-</manifest>
\ No newline at end of file
diff --git a/internal/wrappers/build/android/app/src/main/jni/Android.mk b/internal/wrappers/build/android/app/src/main/jni/Android.mk
deleted file mode 100644
index b0bb6d71..00000000
--- a/internal/wrappers/build/android/app/src/main/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# File: Android.mk
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := kuzzlesdk
-LOCAL_SRC_FILES := ../../../../../../build/c/libkuzzlesdk.so
-include $(PREBUILT_SHARED_LIBRARY)
-
-
-include $(CLEAR_VARS)
-LOCAL_MODULE    := kuzzle
-LOCAL_CFLAGS    := -frtti
-LOCAL_CPP_FEATURES := rtti exceptions
-LOCAL_CPPFLAGS += -std=gnu++11 -I../../../../../../headers -I../../../../../../cpp/ -I../../../../../../build/c
-LOCAL_SHARED_LIBRARIES := kuzzlesdk
-LOCAL_SRC_FILES := ../../../../../../kcore_wrap.cxx
-include $(BUILD_SHARED_LIBRARY)
\ No newline at end of file
diff --git a/internal/wrappers/build/android/app/src/main/jni/Application.mk b/internal/wrappers/build/android/app/src/main/jni/Application.mk
deleted file mode 100644
index ac4a41a9..00000000
--- a/internal/wrappers/build/android/app/src/main/jni/Application.mk
+++ /dev/null
@@ -1,4 +0,0 @@
-APP_OPTIM := release
-APP_STL := gnustl_shared
-APP_PLATFORM := android-14
-APP_ABI := x86
\ No newline at end of file
diff --git a/internal/wrappers/build/android/build.gradle b/internal/wrappers/build/android/build.gradle
deleted file mode 100644
index 838516fc..00000000
--- a/internal/wrappers/build/android/build.gradle
+++ /dev/null
@@ -1,23 +0,0 @@
-buildscript {
-    
-    repositories {
-        google()
-        jcenter()
-    }
-    dependencies {
-        classpath 'com.android.tools.build:gradle:3.0.1'
-        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.7.3'
-        classpath 'com.github.dcendents:android-maven-gradle-plugin:1.4.1' 
-    }
-}
-
-allprojects {
-    repositories {
-        google()
-        jcenter()
-    }
-}
-
-task clean(type: Delete) {
-    delete rootProject.buildDir
-}
diff --git a/internal/wrappers/build/android/gradle.properties b/internal/wrappers/build/android/gradle.properties
deleted file mode 100644
index 2427fd0b..00000000
--- a/internal/wrappers/build/android/gradle.properties
+++ /dev/null
@@ -1 +0,0 @@
-org.gradle.jvmargs=-Xmx1536m
\ No newline at end of file
diff --git a/internal/wrappers/build/android/gradle/wrapper/gradle-wrapper.jar b/internal/wrappers/build/android/gradle/wrapper/gradle-wrapper.jar
deleted file mode 100644
index 13372aef..00000000
Binary files a/internal/wrappers/build/android/gradle/wrapper/gradle-wrapper.jar and /dev/null differ
diff --git a/internal/wrappers/build/android/gradle/wrapper/gradle-wrapper.properties b/internal/wrappers/build/android/gradle/wrapper/gradle-wrapper.properties
deleted file mode 100644
index 82fa6a2a..00000000
--- a/internal/wrappers/build/android/gradle/wrapper/gradle-wrapper.properties
+++ /dev/null
@@ -1,6 +0,0 @@
-#Fri Jun 29 12:12:40 CEST 2018
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.1-all.zip
diff --git a/internal/wrappers/build/android/gradlew b/internal/wrappers/build/android/gradlew
deleted file mode 100644
index 9d82f789..00000000
--- a/internal/wrappers/build/android/gradlew
+++ /dev/null
@@ -1,160 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-##
-##  Gradle start up script for UN*X
-##
-##############################################################################
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn ( ) {
-    echo "$*"
-}
-
-die ( ) {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-esac
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-        JAVACMD="$JAVA_HOME/bin/java"
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
-fi
-
-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
-    JVM_OPTS=("$@")
-}
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
-
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
diff --git a/internal/wrappers/build/android/gradlew.bat b/internal/wrappers/build/android/gradlew.bat
deleted file mode 100644
index aec99730..00000000
--- a/internal/wrappers/build/android/gradlew.bat
+++ /dev/null
@@ -1,90 +0,0 @@
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windowz variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval[2+2]" == "4" goto 4NT_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
diff --git a/internal/wrappers/build/android/settings.gradle b/internal/wrappers/build/android/settings.gradle
deleted file mode 100644
index e7b4def4..00000000
--- a/internal/wrappers/build/android/settings.gradle
+++ /dev/null
@@ -1 +0,0 @@
-include ':app'
diff --git a/internal/wrappers/build/java/build.gradle b/internal/wrappers/build/java/build.gradle
deleted file mode 100644
index 6848fca3..00000000
--- a/internal/wrappers/build/java/build.gradle
+++ /dev/null
@@ -1,101 +0,0 @@
-buildscript {
-  repositories {
-        jcenter()
-   }
-}
-
-plugins {
-  id "com.jfrog.bintray" version "1.7.3"
-}
-
-group = 'io.kuzzle'
-version = '1.0.0'
-
-allprojects {
-	repositories {
-		jcenter()
-	}
-	apply plugin: 'maven-publish'
-	apply plugin: 'java'
-  apply plugin: 'java-library'
-}
-
-task sourcesJar(type: Jar, dependsOn: classes) {
-    classifier = 'sources'
-    from sourceSets.main.allSource
-}
-
-javadoc.failOnError = false
-task javadocJar(type: Jar, dependsOn: javadoc) {
-    classifier = 'javadoc'
-    from javadoc.destinationDir
-}
-
-bintray {
-    user = System.getenv('BINTRAY_USER')
-    key = System.getenv('BINTRAY_KEY')
-    publications = ['MyPublication']
-
-    pkg {
-        repo = 'maven'
-        name = 'kuzzle-sdk-' + System.getenv('ARCH')
-        userOrg = 'kuzzle'
-        licenses = ['Apache-2.0']
-        desc = 'Kuzzle JAVA SDK'
-        vcsUrl = 'https://github.com/kuzzleio/sdk-go.git'
-        websiteUrl = 'https://kuzzle.io'
-        issueTrackerUrl = 'https://github.com/kuzzleio/sdk-go/issues'
-        publicDownloadNumbers = true
-        publish = true
-    }
-}
-
-def pomConfig = {
-    licenses {
-        license {
-            name "The Apache Software License, Version 2.0"
-            url "http://www.apache.org/licenses/LICENSE-2.0.txt"
-            distribution "repo"
-        }
-    }
-    developers {
-        developer {
-            id "kuzzle"
-            name "kuzzle"
-            email "support@kuzzle.io"
-        }
-    }
-    
-    scm {
-       url "https://github.com/kuzzleio/sdk-go"
-    }
-}
-
-publishing {
-    publications {
-        MyPublication(MavenPublication) {
-            from components.java
-            artifact sourcesJar
-            artifact javadocJar
-            groupId 'io.kuzzle'
-            artifactId 'kuzzle-sdk-' + System.getenv('ARCH')
-            version version
-            pom.withXml {
-                def root = asNode()
-                root.appendNode('description', 'Kuzzle JAVA SDK')
-                root.appendNode('name', 'kuzzle-sdk')
-                root.appendNode('url', 'https://github.com/kuzzleio/sdk-go')
-                root.children().last() + pomConfig
-            }
-        }
-    }
-}
-
-dependencies {
-  compile fileTree(dir: 'src/main/java', include: ['*.so'])
-}
-
-artifacts {
-    archives sourcesJar
-    archives javadocJar
-}
\ No newline at end of file
diff --git a/internal/wrappers/build/java/gradle/wrapper/gradle-wrapper.jar b/internal/wrappers/build/java/gradle/wrapper/gradle-wrapper.jar
deleted file mode 100644
index c44b679a..00000000
Binary files a/internal/wrappers/build/java/gradle/wrapper/gradle-wrapper.jar and /dev/null differ
diff --git a/internal/wrappers/build/java/gradle/wrapper/gradle-wrapper.properties b/internal/wrappers/build/java/gradle/wrapper/gradle-wrapper.properties
deleted file mode 100644
index 568c50bf..00000000
--- a/internal/wrappers/build/java/gradle/wrapper/gradle-wrapper.properties
+++ /dev/null
@@ -1,5 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.5.1-bin.zip
diff --git a/internal/wrappers/build/java/gradlew b/internal/wrappers/build/java/gradlew
deleted file mode 100755
index cccdd3d5..00000000
--- a/internal/wrappers/build/java/gradlew
+++ /dev/null
@@ -1,172 +0,0 @@
-#!/usr/bin/env sh
-
-##############################################################################
-##
-##  Gradle start up script for UN*X
-##
-##############################################################################
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn () {
-    echo "$*"
-}
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-        JAVACMD="$JAVA_HOME/bin/java"
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
-fi
-
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=$(save "$@")
-
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
-
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
-fi
-
-exec "$JAVACMD" "$@"
diff --git a/internal/wrappers/build/java/gradlew.bat b/internal/wrappers/build/java/gradlew.bat
deleted file mode 100644
index e95643d6..00000000
--- a/internal/wrappers/build/java/gradlew.bat
+++ /dev/null
@@ -1,84 +0,0 @@
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
diff --git a/internal/wrappers/build/java/settings.gradle b/internal/wrappers/build/java/settings.gradle
deleted file mode 100644
index 25da16a3..00000000
--- a/internal/wrappers/build/java/settings.gradle
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
- * This file was generated by the Gradle 'init' task.
- *
- * The settings file is used to specify which projects to include in your build.
- * 
- * Detailed information about configuring a multi-project build in Gradle can be found
- * in the user guide at https://docs.gradle.org/4.5.1/userguide/multi_project_builds.html
- */
-
-rootProject.name = 'kuzzlesdk'
diff --git a/internal/wrappers/build_cpp_tests.sh b/internal/wrappers/build_cpp_tests.sh
deleted file mode 100755
index d2ddff0d..00000000
--- a/internal/wrappers/build_cpp_tests.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#/bin/bash
-set -e
-cmake -E make_directory _build_cpp_tests
-cmake -E chdir _build_cpp_tests cmake ../features/step_defs_cpp
-cmake --build  _build_cpp_tests -- -j2
diff --git a/internal/wrappers/cgo/kuzzle/auth.go b/internal/wrappers/cgo/kuzzle/auth.go
deleted file mode 100644
index 39f399d5..00000000
--- a/internal/wrappers/cgo/kuzzle/auth.go
+++ /dev/null
@@ -1,189 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-/*
-  #cgo CFLAGS: -I../../headers
-
-  #include <stdlib.h>
-  #include <errno.h>
-  #include "kuzzlesdk.h"
-  #include "sdk_wrappers_internal.h"
-*/
-import "C"
-import (
-	"encoding/json"
-	"sync"
-	"unsafe"
-
-	"github.com/kuzzleio/sdk-go/auth"
-	"github.com/kuzzleio/sdk-go/kuzzle"
-)
-
-// map which stores instances to keep references in case the gc passes
-var authInstances sync.Map
-
-//register new instance of server
-func registerAuth(instance interface{}, ptr unsafe.Pointer) {
-	authInstances.Store(instance, ptr)
-}
-
-// unregister an instance from the instances map
-//export unregisterAuth
-func unregisterAuth(a *C.auth) {
-	authInstances.Delete(a)
-}
-
-// Allocates memory
-//export kuzzle_new_auth
-func kuzzle_new_auth(a *C.auth, k *C.kuzzle) {
-	kuz := (*kuzzle.Kuzzle)(k.instance)
-	auth := auth.NewAuth(kuz)
-
-	ptr := unsafe.Pointer(auth)
-	a.instance = ptr
-	a.k = k
-
-	registerAuth(a, ptr)
-}
-
-//export kuzzle_check_token
-func kuzzle_check_token(a *C.auth, token *C.char) *C.token_validity {
-	result := (*C.token_validity)(C.calloc(1, C.sizeof_token_validity))
-
-	res, err := (*auth.Auth)(a.instance).CheckToken(C.GoString(token))
-	if err != nil {
-		Set_token_validity_error(result, err)
-		return result
-	}
-
-	result.valid = C.bool(res.Valid)
-	result.state = C.CString(res.State)
-	result.expires_at = C.ulonglong(res.ExpiresAt)
-
-	return result
-}
-
-//export kuzzle_create_my_credentials
-func kuzzle_create_my_credentials(a *C.auth, strategy *C.char, credentials *C.char, options *C.query_options) *C.string_result {
-	res, err := (*auth.Auth)(a.instance).CreateMyCredentials(
-		C.GoString(strategy),
-		json.RawMessage(C.GoString(credentials)),
-		SetQueryOptions(options))
-
-	str := string(res)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_credentials_exist
-func kuzzle_credentials_exist(a *C.auth, strategy *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*auth.Auth)(a.instance).CredentialsExist(
-		C.GoString(strategy),
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_delete_my_credentials
-func kuzzle_delete_my_credentials(a *C.auth, strategy *C.char, options *C.query_options) *C.error_result {
-	err := (*auth.Auth)(a.instance).DeleteMyCredentials(
-		C.GoString(strategy),
-		SetQueryOptions(options))
-
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_get_current_user
-func kuzzle_get_current_user(a *C.auth) *C.user_result {
-	u, err := (*auth.Auth)(a.instance).GetCurrentUser()
-
-	return goToCUserResult(a.k, u, err)
-}
-
-//export kuzzle_get_my_credentials
-func kuzzle_get_my_credentials(a *C.auth, strategy *C.char, options *C.query_options) *C.string_result {
-	res, err := (*auth.Auth)(a.instance).GetMyCredentials(
-		C.GoString(strategy),
-		SetQueryOptions(options))
-
-	str := string(res)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_get_my_rights
-func kuzzle_get_my_rights(a *C.auth, options *C.query_options) *C.user_rights_result {
-	res, err := (*auth.Auth)(a.instance).GetMyRights(SetQueryOptions(options))
-
-	return goToCUserRightsResult(res, err)
-}
-
-//export kuzzle_get_strategies
-func kuzzle_get_strategies(a *C.auth, options *C.query_options) *C.string_array_result {
-	res, err := (*auth.Auth)(a.instance).GetStrategies(SetQueryOptions(options))
-
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_login
-func kuzzle_login(a *C.auth, strategy *C.char, credentials *C.char, expires_in *C.int) *C.string_result {
-	var expire int
-	if expires_in != nil {
-		expire = int(*expires_in)
-	}
-
-	res, err := (*auth.Auth)(a.instance).Login(C.GoString(strategy), json.RawMessage(C.GoString(credentials)), &expire)
-
-	return goToCStringResult(&res, err)
-}
-
-//export kuzzle_logout
-func kuzzle_logout(a *C.auth) *C.char {
-	err := (*auth.Auth)(a.instance).Logout()
-	if err != nil {
-		return C.CString(err.Error())
-	}
-
-	return nil
-}
-
-//export kuzzle_update_my_credentials
-func kuzzle_update_my_credentials(a *C.auth, strategy *C.char, credentials *C.char, options *C.query_options) *C.string_result {
-	res, err := (*auth.Auth)(a.instance).UpdateMyCredentials(
-		C.GoString(strategy),
-		json.RawMessage(C.GoString(credentials)),
-		SetQueryOptions(options))
-
-	str := string(res)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_update_self
-func kuzzle_update_self(a *C.auth, data *C.char, options *C.query_options) *C.user_result {
-	res, err := (*auth.Auth)(a.instance).UpdateSelf(
-		json.RawMessage(C.GoString(data)),
-		SetQueryOptions(options))
-
-	return goToCUserResult(a.k, res, err)
-}
-
-//export kuzzle_validate_my_credentials
-func kuzzle_validate_my_credentials(a *C.auth, strategy *C.char, credentials *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*auth.Auth)(a.instance).ValidateMyCredentials(
-		C.GoString(strategy),
-		json.RawMessage(C.GoString(credentials)),
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
diff --git a/internal/wrappers/cgo/kuzzle/c_to_go.go b/internal/wrappers/cgo/kuzzle/c_to_go.go
deleted file mode 100644
index bc9a2294..00000000
--- a/internal/wrappers/cgo/kuzzle/c_to_go.go
+++ /dev/null
@@ -1,169 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-/*
-	#cgo CFLAGS: -I../../headers
-	#include <stdlib.h>
-	#include "kuzzlesdk.h"
-*/
-import "C"
-import (
-	"encoding/json"
-	"unsafe"
-
-	"github.com/kuzzleio/sdk-go/collection"
-	"github.com/kuzzleio/sdk-go/kuzzle"
-	"github.com/kuzzleio/sdk-go/security"
-	"github.com/kuzzleio/sdk-go/types"
-)
-
-// convert a C char** to a go array of string
-func cToGoStrings(arr **C.char, len C.size_t) []string {
-	if len == 0 {
-		return nil
-	}
-
-	tmpslice := (*[1 << 27]*C.char)(unsafe.Pointer(arr))[:len:len]
-	goStrings := make([]string, 0, len)
-
-	for _, s := range tmpslice {
-		goStrings = append(goStrings, C.GoString(s))
-	}
-
-	return goStrings
-}
-
-func cToGoShards(cShards *C.shards) *types.Shards {
-	return &types.Shards{
-		Total:      int(cShards.total),
-		Successful: int(cShards.successful),
-		Failed:     int(cShards.failed),
-	}
-}
-
-func cToGoKuzzleMeta(cMeta *C.meta) *types.Meta {
-	return &types.Meta{
-		Author:    C.GoString(cMeta.author),
-		CreatedAt: int(cMeta.created_at),
-		UpdatedAt: int(cMeta.updated_at),
-		Updater:   C.GoString(cMeta.updater),
-		Active:    bool(cMeta.active),
-		DeletedAt: int(cMeta.deleted_at),
-	}
-}
-
-func cToGoCollection(c *C.collection) *collection.Collection {
-	return collection.NewCollection((*kuzzle.Kuzzle)(c.k.instance))
-}
-
-func cToGoPolicyRestriction(r *C.policy_restriction) *types.PolicyRestriction {
-	restriction := &types.PolicyRestriction{
-		Index: C.GoString(r.index),
-	}
-
-	if r.collections == nil {
-		return restriction
-	}
-
-	slice := (*[1<<28 - 1]*C.char)(unsafe.Pointer(r.collections))[:r.collections_length:r.collections_length]
-	for _, col := range slice {
-		restriction.Collections = append(restriction.Collections, C.GoString(col))
-	}
-
-	return restriction
-}
-
-func cToGoPolicy(p *C.policy) *types.Policy {
-	policy := &types.Policy{
-		RoleId: C.GoString(p.role_id),
-	}
-
-	if p.restricted_to == nil {
-		return policy
-	}
-
-	slice := (*[1<<28 - 1]*C.policy_restriction)(unsafe.Pointer(p.restricted_to))[:p.restricted_to_length]
-	for _, crestriction := range slice {
-		policy.RestrictedTo = append(policy.RestrictedTo, cToGoPolicyRestriction(crestriction))
-	}
-
-	return policy
-}
-
-func cToGoProfile(p *C.profile) *security.Profile {
-	profile := &security.Profile{
-		Id: C.GoString(p.id),
-	}
-
-	if p.policies == nil {
-		return profile
-	}
-
-	slice := (*[1<<28 - 1]*C.policy)(unsafe.Pointer(p.policies))[:p.policies_length]
-	for _, cpolicy := range slice {
-		profile.Policies = append(profile.Policies, cToGoPolicy(cpolicy))
-	}
-
-	return profile
-}
-
-func cToGoUser(u *C.kuzzle_user) *security.User {
-	if u == nil {
-		return nil
-	}
-
-	user := security.NewUser(C.GoString(u.id), nil)
-
-	return user
-}
-
-func cToGoUserRigh(r *C.user_right) *types.UserRights {
-	right := &types.UserRights{
-		Controller: C.GoString(r.controller),
-		Action:     C.GoString(r.action),
-		Index:      C.GoString(r.index),
-		Value:      C.GoString(r.value),
-	}
-
-	return right
-}
-
-func cToGoSearchResult(s *C.search_result) *types.SearchResult {
-	opts := types.NewQueryOptions()
-
-	opts.SetSize(int(s.options.size))
-	opts.SetFrom(int(s.options.from))
-	opts.SetScrollId(C.GoString(s.options.scroll_id))
-
-	c, _ := json.Marshal(s.collection)
-
-	var documents json.RawMessage
-	d, _ := json.Marshal(s.documents)
-	documents = d
-
-	return &types.SearchResult{
-		Collection: string(c),
-		Documents:  documents,
-		Total:      int(s.total),
-		Fetched:    int(s.fetched),
-		Options:    opts,
-		Filters:    json.RawMessage(C.GoString(s.filters)),
-	}
-}
-
-func cToGoKuzzleNotificationChannel(c *C.kuzzle_notification_listener) chan<- types.KuzzleNotification {
-	return make(chan<- types.KuzzleNotification)
-}
diff --git a/internal/wrappers/cgo/kuzzle/collection.go b/internal/wrappers/cgo/kuzzle/collection.go
deleted file mode 100644
index 284411db..00000000
--- a/internal/wrappers/cgo/kuzzle/collection.go
+++ /dev/null
@@ -1,139 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-/*
-	#cgo CFLAGS: -I../../headers
-	#include "kuzzlesdk.h"
-	#include "sdk_wrappers_internal.h"
-*/
-import "C"
-import (
-	"encoding/json"
-	"sync"
-	"unsafe"
-
-	"github.com/kuzzleio/sdk-go/collection"
-	"github.com/kuzzleio/sdk-go/kuzzle"
-)
-
-// map which stores instances to keep references in case the gc passes
-var collectionInstances sync.Map
-
-// register new instance to the instances map
-func registerCollection(instance interface{}, ptr unsafe.Pointer) {
-	collectionInstances.Store(instance, ptr)
-}
-
-// unregister an instance from the instances map
-//export unregisterCollection
-func unregisterCollection(c *C.collection) {
-	collectionInstances.Delete(c)
-}
-
-// Allocates memory
-//export kuzzle_new_collection
-func kuzzle_new_collection(c *C.collection, k *C.kuzzle) {
-	kuz := (*kuzzle.Kuzzle)(k.instance)
-	col := collection.NewCollection(kuz)
-
-	ptr := unsafe.Pointer(col)
-	c.instance = ptr
-	c.k = k
-
-	registerCollection(c, ptr)
-}
-
-//export kuzzle_collection_create
-func kuzzle_collection_create(c *C.collection, index *C.char, col *C.char, body *C.char, options *C.query_options) *C.error_result {
-	var rawBody json.RawMessage
-
-	if body != nil {
-		rawBody = json.RawMessage(C.GoString(body))
-	}
-
-	err := (*collection.Collection)(c.instance).Create(C.GoString(index), C.GoString(col), rawBody, SetQueryOptions(options))
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_collection_truncate
-func kuzzle_collection_truncate(c *C.collection, index *C.char, col *C.char, options *C.query_options) *C.error_result {
-	err := (*collection.Collection)(c.instance).Truncate(C.GoString(index), C.GoString(col), SetQueryOptions(options))
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_collection_exists
-func kuzzle_collection_exists(c *C.collection, index *C.char, col *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*collection.Collection)(c.instance).Exists(C.GoString(index), C.GoString(col), SetQueryOptions(options))
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_collection_list
-func kuzzle_collection_list(c *C.collection, index *C.char, options *C.query_options) *C.string_result {
-	res, err := (*collection.Collection)(c.instance).List(C.GoString(index), SetQueryOptions(options))
-	s := string(res)
-	return goToCStringResult(&s, err)
-}
-
-// Mapping
-
-//export kuzzle_collection_get_mapping
-func kuzzle_collection_get_mapping(c *C.collection, index *C.char, col *C.char, options *C.query_options) *C.string_result {
-	res, err := (*collection.Collection)(c.instance).GetMapping(C.GoString(index), C.GoString(col), SetQueryOptions(options))
-	s := string(res)
-	return goToCStringResult(&s, err)
-}
-
-//export kuzzle_collection_update_mapping
-func kuzzle_collection_update_mapping(c *C.collection, index *C.char, col *C.char, body *C.char, options *C.query_options) *C.error_result {
-	err := (*collection.Collection)(c.instance).UpdateMapping(C.GoString(index), C.GoString(col), json.RawMessage(C.GoString(body)), SetQueryOptions(options))
-	return goToCErrorResult(err)
-}
-
-// Specifications
-
-//export kuzzle_collection_delete_specifications
-func kuzzle_collection_delete_specifications(c *C.collection, index *C.char, col *C.char, options *C.query_options) *C.error_result {
-	err := (*collection.Collection)(c.instance).DeleteSpecifications(C.GoString(index), C.GoString(col), SetQueryOptions(options))
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_collection_get_specifications
-func kuzzle_collection_get_specifications(c *C.collection, index *C.char, col *C.char, options *C.query_options) *C.string_result {
-	res, err := (*collection.Collection)(c.instance).GetSpecifications(C.GoString(index), C.GoString(col), SetQueryOptions(options))
-	var stringResult string
-	stringResult = string(res)
-	return goToCStringResult(&stringResult, err)
-}
-
-//export kuzzle_collection_search_specifications
-func kuzzle_collection_search_specifications(c *C.collection, options *C.query_options) *C.search_result {
-	res, err := (*collection.Collection)(c.instance).SearchSpecifications(SetQueryOptions(options))
-	return goToCSearchResult(res, err)
-}
-
-//export kuzzle_collection_update_specifications
-func kuzzle_collection_update_specifications(c *C.collection, index *C.char, col *C.char, body *C.char, options *C.query_options) *C.string_result {
-	res, err := (*collection.Collection)(c.instance).UpdateSpecifications(C.GoString(index), C.GoString(col), json.RawMessage(C.GoString(body)), SetQueryOptions(options))
-	var stringResult string
-	stringResult = string(res)
-	return goToCStringResult(&stringResult, err)
-}
-
-//export kuzzle_collection_validate_specifications
-func kuzzle_collection_validate_specifications(c *C.collection, body *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*collection.Collection)(c.instance).ValidateSpecifications(json.RawMessage(C.GoString(body)), SetQueryOptions(options))
-	return goToCBoolResult(res, err)
-}
diff --git a/internal/wrappers/cgo/kuzzle/destructors.go b/internal/wrappers/cgo/kuzzle/destructors.go
deleted file mode 100644
index 7244d71b..00000000
--- a/internal/wrappers/cgo/kuzzle/destructors.go
+++ /dev/null
@@ -1,762 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-/*
-  #cgo CFLAGS: -std=c99 -I../../../headers
-
-  #include <stdlib.h>
-  #include "kuzzlesdk.h"
-
-  static void free_char_array(char **arr, size_t length) {
-    if (arr != NULL) {
-      for(int i = 0; i < length; i++) {
-        free(arr[i]);
-      }
-
-      free(arr);
-    }
-  }
-*/
-import "C"
-
-import (
-	"unsafe"
-)
-
-//export kuzzle_free_kuzzle_request
-func kuzzle_free_kuzzle_request(st *C.kuzzle_request) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.request_id))
-		C.free(unsafe.Pointer(st.controller))
-		C.free(unsafe.Pointer(st.action))
-		C.free(unsafe.Pointer(st.index))
-		C.free(unsafe.Pointer(st.collection))
-		C.free(unsafe.Pointer(st.id))
-		C.free(unsafe.Pointer(st.scroll))
-		C.free(unsafe.Pointer(st.scroll_id))
-		C.free(unsafe.Pointer(st.strategy))
-		C.free(unsafe.Pointer(st.scope))
-		C.free(unsafe.Pointer(st.state))
-		C.free(unsafe.Pointer(st.user))
-		C.free(unsafe.Pointer(st.member))
-		C.free(unsafe.Pointer(st.member1))
-		C.free(unsafe.Pointer(st.member2))
-		C.free(unsafe.Pointer(st.unit))
-		C.free(unsafe.Pointer(st.field))
-		C.free(unsafe.Pointer(st.subcommand))
-		C.free(unsafe.Pointer(st.pattern))
-		C.free(unsafe.Pointer(st.min))
-		C.free(unsafe.Pointer(st.max))
-		C.free(unsafe.Pointer(st.limit))
-		C.free(unsafe.Pointer(st.match))
-
-		C.free_char_array(st.members, st.members_length)
-		C.free_char_array(st.keys, st.keys_length)
-		C.free_char_array(st.fields, st.fields_length)
-
-		C.free(unsafe.Pointer(st.body))
-		C.free(unsafe.Pointer(st.volatiles))
-		C.free(unsafe.Pointer(st.options))
-
-		C.free(unsafe.Pointer(st))
-	}
-
-}
-
-//export kuzzle_free_query_object
-func kuzzle_free_query_object(st *C.query_object) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.query))
-		C.free(unsafe.Pointer(st.request_id))
-
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_offline_queue
-func kuzzle_free_offline_queue(st *C.offline_queue) {
-	if st != nil && st.queries != nil {
-		queries := (*[1<<28 - 1]*C.query_object)(unsafe.Pointer(st.queries))[:int(st.queries_length):int(st.queries_length)]
-
-		for _, query := range queries {
-			kuzzle_free_query_object(query)
-		}
-
-		C.free(unsafe.Pointer(st.queries))
-	}
-
-	C.free(unsafe.Pointer(st))
-}
-
-//export kuzzle_free_query_options
-func kuzzle_free_query_options(st *C.query_options) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.scroll))
-		C.free(unsafe.Pointer(st.scroll_id))
-		C.free(unsafe.Pointer(st.refresh))
-		C.free(unsafe.Pointer(st.if_exist))
-		C.free(unsafe.Pointer(st.volatiles))
-
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_room_options
-func kuzzle_free_room_options(st *C.room_options) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.scope))
-		C.free(unsafe.Pointer(st.state))
-		C.free(unsafe.Pointer(st.user))
-		C.free(unsafe.Pointer(st.volatiles))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_options
-func kuzzle_free_options(st *C.options) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.refresh))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_meta
-func kuzzle_free_meta(st *C.meta) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.author))
-		C.free(unsafe.Pointer(st.updater))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-// do not export => used to free the content of a structure
-// and not the structure itself
-func _free_policy_restriction(st *C.policy_restriction) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.index))
-		C.free_char_array(st.collections, st.collections_length)
-	}
-}
-
-//export kuzzle_free_policy_restriction
-func kuzzle_free_policy_restriction(st *C.policy_restriction) {
-	_free_policy_restriction(st)
-	C.free(unsafe.Pointer(st))
-}
-
-// do not export => used to free the content of a structure
-// and not the structure itself
-func _free_policy(st *C.policy) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.role_id))
-
-		if st.restricted_to != nil {
-			restrictions := (*[1<<27 - 1]C.policy_restriction)(unsafe.Pointer(st.restricted_to))[:int(st.restricted_to_length):int(st.restricted_to_length)]
-
-			for _, restriction := range restrictions {
-				_free_policy_restriction(&restriction)
-			}
-
-			C.free(unsafe.Pointer(st.restricted_to))
-		}
-	}
-}
-
-//export kuzzle_free_policy
-func kuzzle_free_policy(st *C.policy) {
-	_free_policy(st)
-	C.free(unsafe.Pointer(st))
-}
-
-// do not export => used to free the content of a structure
-// and not the structure itself
-func _free_profile(st *C.profile) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.id))
-
-		if st.policies != nil {
-			policies := (*[1<<27 - 1]C.policy)(unsafe.Pointer(st.policies))[:int(st.policies_length):int(st.policies_length)]
-
-			for _, policy := range policies {
-				_free_policy(&policy)
-			}
-
-			C.free(unsafe.Pointer(st.policies))
-		}
-	}
-}
-
-//export kuzzle_free_profile
-func kuzzle_free_profile(st *C.profile) {
-	_free_profile(st)
-	C.free(unsafe.Pointer(st))
-}
-
-//do not export
-func _free_role(st *C.role) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.id))
-		C.free(unsafe.Pointer(st.controllers))
-	}
-}
-
-//export kuzzle_free_role
-func kuzzle_free_role(st *C.role) {
-	_free_role(st)
-	C.free(unsafe.Pointer(st))
-}
-
-//do not export
-func _free_user(st *C.kuzzle_user) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.id))
-		C.free(unsafe.Pointer(st.content))
-		C.free_char_array(st.profile_ids, st.profile_ids_length)
-	}
-}
-
-//export kuzzle_free_user
-func kuzzle_free_user(st *C.kuzzle_user) {
-	_free_user(st)
-	C.free(unsafe.Pointer(st))
-}
-
-//export kuzzle_free_user_data
-func kuzzle_free_user_data(st *C.user_data) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.content))
-		C.free_char_array(st.profile_ids, st.profile_ids_length)
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_collection
-func kuzzle_free_collection(st *C.collection) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.instance))
-		C.free(unsafe.Pointer(st.k))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_document
-func kuzzle_free_document(st *C.document) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.instance))
-		C.free(unsafe.Pointer(st.k))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_notification_content
-func kuzzle_free_notification_content(st *C.notification_content) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.id))
-		kuzzle_free_meta(st.m)
-		C.free(unsafe.Pointer(st.content))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_notification_result
-func kuzzle_free_notification_result(st *C.notification_result) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.request_id))
-		C.free(unsafe.Pointer(st.index))
-		C.free(unsafe.Pointer(st.collection))
-		C.free(unsafe.Pointer(st.controller))
-		C.free(unsafe.Pointer(st.action))
-		C.free(unsafe.Pointer(st.protocol))
-		C.free(unsafe.Pointer(st.scope))
-		C.free(unsafe.Pointer(st.state))
-		C.free(unsafe.Pointer(st.user))
-		C.free(unsafe.Pointer(st.n_type))
-		C.free(unsafe.Pointer(st.room_id))
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-
-		C.free(unsafe.Pointer(st.volatiles))
-
-		kuzzle_free_notification_content(st.result)
-
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_profile_result
-func kuzzle_free_profile_result(st *C.profile_result) {
-	if st != nil {
-		kuzzle_free_profile(st.p)
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_profiles_result
-func kuzzle_free_profiles_result(st *C.profiles_result) {
-	if st != nil {
-		if st.profiles != nil {
-			profiles := (*[1<<27 - 1]C.profile)(unsafe.Pointer(st.profiles))[:int(st.profiles_length):int(st.profiles_length)]
-
-			for _, profile := range profiles {
-				_free_profile(&profile)
-			}
-
-			C.free(unsafe.Pointer(st.profiles))
-		}
-
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_role_result
-func kuzzle_free_role_result(st *C.role_result) {
-	if st != nil {
-		kuzzle_free_role(st.r)
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-// do not export => used to free the content of a structure
-// and not the structure itself
-func _free_user_right(st *C.user_right) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.controller))
-		C.free(unsafe.Pointer(st.action))
-		C.free(unsafe.Pointer(st.index))
-		C.free(unsafe.Pointer(st.collection))
-		C.free(unsafe.Pointer(st.value))
-	}
-}
-
-//export kuzzle_free_subscribe_result
-func kuzzle_free_subscribe_result(st *C.subscribe_result) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.room))
-		C.free(unsafe.Pointer(st.channel))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_user_right
-func kuzzle_free_user_right(st *C.user_right) {
-	_free_user_right(st)
-	C.free(unsafe.Pointer(st))
-}
-
-//export kuzzle_free_user_rights_result
-func kuzzle_free_user_rights_result(st *C.user_rights_result) {
-	if st != nil {
-		if st.result != nil {
-			rights := (*[1<<26 - 1]C.user_right)(unsafe.Pointer(st.result))[:int(st.user_rights_length):int(st.user_rights_length)]
-
-			for _, right := range rights {
-				_free_user_right(&right)
-			}
-
-			C.free(unsafe.Pointer(st.result))
-		}
-
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_user_result
-func kuzzle_free_user_result(st *C.user_result) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-// do not export => used to free the content of a structure
-// and not the structure itself
-func _free_statistics(st *C.statistics) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.completed_requests))
-		C.free(unsafe.Pointer(st.connections))
-		C.free(unsafe.Pointer(st.failed_requests))
-		C.free(unsafe.Pointer(st.ongoing_requests))
-	}
-}
-
-//export kuzzle_free_statistics
-func kuzzle_free_statistics(st *C.statistics) {
-	_free_statistics(st)
-	C.free(unsafe.Pointer(st))
-}
-
-//export kuzzle_free_statistics_result
-func kuzzle_free_statistics_result(st *C.statistics_result) {
-	if st != nil {
-		kuzzle_free_statistics(st.result)
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_all_statistics_result
-func kuzzle_free_all_statistics_result(st *C.all_statistics_result) {
-	if st != nil {
-		if st.result != nil {
-			stats := (*[1<<26 - 1]C.statistics)(unsafe.Pointer(st.result))
-
-			for _, stat := range stats {
-				_free_statistics(&stat)
-			}
-
-			C.free(unsafe.Pointer(st.result))
-		}
-
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_geopos_result
-func kuzzle_free_geopos_result(st *C.geopos_result) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.result))
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_token_validity
-func kuzzle_free_token_validity(st *C.token_validity) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.state))
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_kuzzle_response
-func kuzzle_free_kuzzle_response(st *C.kuzzle_response) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.request_id))
-		C.free(unsafe.Pointer(st.index))
-		C.free(unsafe.Pointer(st.collection))
-		C.free(unsafe.Pointer(st.controller))
-		C.free(unsafe.Pointer(st.action))
-		C.free(unsafe.Pointer(st.room_id))
-		C.free(unsafe.Pointer(st.channel))
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-
-		C.free(unsafe.Pointer(st.result))
-		C.free(unsafe.Pointer(st.volatiles))
-
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_json_result
-func kuzzle_free_json_result(st *C.json_result) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.result))
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_bool_result
-func kuzzle_free_bool_result(st *C.bool_result) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_int_result
-func kuzzle_free_int_result(st *C.int_result) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_double_result
-func kuzzle_free_double_result(st *C.double_result) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_int_array_result
-func kuzzle_free_int_array_result(st *C.int_array_result) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.result))
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_string_result
-func kuzzle_free_string_result(st *C.string_result) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.result))
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_string_array_result
-func kuzzle_free_string_array_result(st *C.string_array_result) {
-	if st != nil {
-		C.free_char_array(st.result, st.result_length)
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_profile_search
-func kuzzle_free_profile_search(st *C.profile_search) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.scroll_id))
-
-		if st.hits != nil {
-			hits := (*[1<<27 - 1]C.profile)(unsafe.Pointer(st.hits))[:int(st.hits_length):int(st.hits_length)]
-
-			for _, profile := range hits {
-				_free_profile(&profile)
-			}
-
-			C.free(unsafe.Pointer(st.hits))
-		}
-
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_role_search
-func kuzzle_free_role_search(st *C.role_search) {
-	if st != nil {
-		if st.hits != nil {
-			hits := (*[1<<27 - 1]C.role)(unsafe.Pointer(st.hits))[:int(st.hits_length):int(st.hits_length)]
-
-			for _, role := range hits {
-				_free_role(&role)
-			}
-
-			C.free(unsafe.Pointer(st.hits))
-		}
-
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_ack_result
-func kuzzle_free_ack_result(st *C.ack_result) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_shards_result
-func kuzzle_free_shards_result(st *C.shards_result) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.result))
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_specification
-func kuzzle_free_specification(st *C.specification) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.fields))
-		C.free(unsafe.Pointer(st.validators))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//do not export
-func _free_specification_entry(st *C.specification_entry) {
-	if st != nil {
-		kuzzle_free_specification(st.validation)
-		C.free(unsafe.Pointer(st.index))
-		C.free(unsafe.Pointer(st.collection))
-	}
-}
-
-//export kuzzle_free_specification_entry
-func kuzzle_free_specification_entry(st *C.specification_entry) {
-	_free_specification_entry(st)
-	C.free(unsafe.Pointer(st))
-}
-
-//export kuzzle_free_specification_result
-func kuzzle_free_specification_result(st *C.specification_result) {
-	if st != nil {
-		kuzzle_free_specification(st.result)
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_search_result
-func kuzzle_free_search_result(st *C.search_result) {
-	if st != nil {
-		kuzzle_free_query_options(st.options)
-		C.free(unsafe.Pointer(st.aggregations))
-		C.free(unsafe.Pointer(st.filters))
-
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_search_profiles_result
-func kuzzle_free_search_profiles_result(st *C.search_profiles_result) {
-	if st != nil {
-		kuzzle_free_profile_search(st.result)
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_search_roles_result
-func kuzzle_free_search_roles_result(st *C.search_roles_result) {
-	if st != nil {
-		kuzzle_free_role_search(st.result)
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_specification_search
-func kuzzle_free_specification_search(st *C.specification_search) {
-	if st != nil {
-		if st.hits != nil {
-			hits := (*[1<<27 - 1]C.specification_entry)(unsafe.Pointer(st.hits))[:int(st.hits_length):int(st.hits_length)]
-
-			for _, entry := range hits {
-				_free_specification_entry(&entry)
-			}
-
-			C.free(unsafe.Pointer(st.hits))
-			C.free(unsafe.Pointer(st.scroll_id))
-			C.free(unsafe.Pointer(st))
-		}
-	}
-}
-
-//export kuzzle_free_specification_search_result
-func kuzzle_free_specification_search_result(st *C.specification_search_result) {
-	if st != nil {
-		kuzzle_free_specification_search(st.result)
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_error_result
-func kuzzle_free_error_result(st *C.error_result) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//do not export
-func _free_collection_entry(st *C.collection_entry) {
-	if st != nil {
-		C.free(unsafe.Pointer(st.name))
-	}
-}
-
-//export kuzzle_free_collection_entry
-func kuzzle_free_collection_entry(st *C.collection_entry) {
-	_free_collection_entry(st)
-	C.free(unsafe.Pointer(st))
-}
-
-//export kuzzle_free_collection_entry_result
-func kuzzle_free_collection_entry_result(st *C.collection_entry_result) {
-	if st != nil {
-		if st.result != nil {
-			entries := (*[1<<27 - 1]C.collection_entry)(unsafe.Pointer(st.result))[:int(st.result_length):int(st.result_length)]
-
-			for _, entry := range entries {
-				_free_collection_entry(&entry)
-			}
-
-			C.free(unsafe.Pointer(st.result))
-		}
-
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_user_search
-func kuzzle_free_user_search(st *C.user_search) {
-	if st != nil {
-		if st.hits != nil {
-			hits := (*[1<<26 - 1]C.kuzzle_user)(unsafe.Pointer(st.hits))[:int(st.hits_length):int(st.hits_length)]
-
-			for _, user := range hits {
-				_free_user(&user)
-			}
-
-			C.free(unsafe.Pointer(st.hits))
-		}
-
-		C.free(unsafe.Pointer(st.scroll_id))
-		C.free(unsafe.Pointer(st))
-	}
-}
-
-//export kuzzle_free_search_users_result
-func kuzzle_free_search_users_result(st *C.search_users_result) {
-	if st != nil {
-		kuzzle_free_user_search(st.result)
-		C.free(unsafe.Pointer(st.error))
-		C.free(unsafe.Pointer(st.stack))
-		C.free(unsafe.Pointer(st))
-	}
-}
diff --git a/internal/wrappers/cgo/kuzzle/document.go b/internal/wrappers/cgo/kuzzle/document.go
deleted file mode 100644
index d3342d85..00000000
--- a/internal/wrappers/cgo/kuzzle/document.go
+++ /dev/null
@@ -1,167 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-/*
-	#cgo CFLAGS: -I../../headers
-	#include "kuzzlesdk.h"
-    #include "sdk_wrappers_internal.h"
-*/
-import "C"
-import (
-	"encoding/json"
-	"sync"
-	"unsafe"
-
-	"github.com/kuzzleio/sdk-go/document"
-	"github.com/kuzzleio/sdk-go/kuzzle"
-)
-
-// map which stores instances to keep references in case the gc passes
-var documentInstances sync.Map
-
-// register new instance to the instances map
-func registerDocument(instance interface{}, ptr unsafe.Pointer) {
-	documentInstances.Store(instance, ptr)
-}
-
-// unregister an instance from the instances map
-//export unregisterDocument
-func unregisterDocument(d *C.document) {
-	documentInstances.Delete(d)
-}
-
-//export kuzzle_new_document
-func kuzzle_new_document(d *C.document, k *C.kuzzle) {
-	kuz := (*kuzzle.Kuzzle)(k.instance)
-	doc := document.NewDocument(kuz)
-
-	ptr := unsafe.Pointer(doc)
-	d.instance = ptr
-	d.k = k
-	registerDocument(doc, ptr)
-}
-
-//export kuzzle_document_count
-func kuzzle_document_count(d *C.document, index *C.char, collection *C.char, body *C.char, options *C.query_options) *C.int_result {
-	res, err := (*document.Document)(d.instance).Count(C.GoString(index), C.GoString(collection), json.RawMessage(C.GoString(body)), SetQueryOptions(options))
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_document_exists
-func kuzzle_document_exists(d *C.document, index *C.char, collection *C.char, id *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*document.Document)(d.instance).Exists(C.GoString(index), C.GoString(collection), C.GoString(id), SetQueryOptions(options))
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_document_create
-func kuzzle_document_create(d *C.document, index *C.char, collection *C.char, id *C.char, body *C.char, options *C.query_options) *C.string_result {
-	res, err := (*document.Document)(d.instance).Create(C.GoString(index), C.GoString(collection), C.GoString(id), json.RawMessage(C.GoString(body)), SetQueryOptions(options))
-	s := string(res)
-	return goToCStringResult(&s, err)
-}
-
-//export kuzzle_document_create_or_replace
-func kuzzle_document_create_or_replace(d *C.document, index *C.char, collection *C.char, id *C.char, body *C.char, options *C.query_options) *C.string_result {
-	res, err := (*document.Document)(d.instance).CreateOrReplace(C.GoString(index), C.GoString(collection), C.GoString(id), json.RawMessage(C.GoString(body)), SetQueryOptions(options))
-	s := string(res)
-	return goToCStringResult(&s, err)
-}
-
-//export kuzzle_document_delete
-func kuzzle_document_delete(d *C.document, index *C.char, collection *C.char, id *C.char, options *C.query_options) *C.string_result {
-	res, err := (*document.Document)(d.instance).Delete(C.GoString(index), C.GoString(collection), C.GoString(id), SetQueryOptions(options))
-	return goToCStringResult(&res, err)
-}
-
-//export kuzzle_document_delete_by_query
-func kuzzle_document_delete_by_query(d *C.document, index *C.char, collection *C.char, body *C.char, options *C.query_options) *C.string_array_result {
-	res, err := (*document.Document)(d.instance).DeleteByQuery(C.GoString(index), C.GoString(collection), C.GoString(body), SetQueryOptions(options))
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_document_get
-func kuzzle_document_get(d *C.document, index *C.char, collection *C.char, id *C.char, options *C.query_options) *C.string_result {
-	res, err := (*document.Document)(d.instance).Get(C.GoString(index), C.GoString(collection), C.GoString(id), SetQueryOptions(options))
-	s := string(res)
-	return goToCStringResult(&s, err)
-}
-
-//export kuzzle_document_replace
-func kuzzle_document_replace(d *C.document, index *C.char, collection *C.char, id *C.char, body *C.char, options *C.query_options) *C.string_result {
-	res, err := (*document.Document)(d.instance).Replace(C.GoString(index), C.GoString(collection), C.GoString(id), json.RawMessage(C.GoString(body)), SetQueryOptions(options))
-	s := string(res)
-	return goToCStringResult(&s, err)
-}
-
-//export kuzzle_document_update
-func kuzzle_document_update(d *C.document, index *C.char, collection *C.char, id *C.char, body *C.char, options *C.query_options) *C.string_result {
-	res, err := (*document.Document)(d.instance).Update(C.GoString(index), C.GoString(collection), C.GoString(id), json.RawMessage(C.GoString(body)), SetQueryOptions(options))
-	s := string(res)
-	return goToCStringResult(&s, err)
-}
-
-//export kuzzle_document_validate
-func kuzzle_document_validate(d *C.document, index *C.char, collection *C.char, body *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*document.Document)(d.instance).Validate(C.GoString(index), C.GoString(collection), json.RawMessage(C.GoString(body)), SetQueryOptions(options))
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_document_search
-func kuzzle_document_search(d *C.document, index *C.char, collection *C.char, body *C.char, options *C.query_options) *C.search_result {
-	res, err := (*document.Document)(d.instance).Search(C.GoString(index), C.GoString(collection), json.RawMessage(C.GoString(body)), SetQueryOptions(options))
-	return goToCSearchResult(res, err)
-}
-
-//export kuzzle_document_mcreate
-func kuzzle_document_mcreate(d *C.document, index *C.char, collection *C.char, body *C.char, options *C.query_options) *C.string_result {
-	res, err := (*document.Document)(d.instance).MCreate(C.GoString(index), C.GoString(collection), json.RawMessage(C.GoString(body)), SetQueryOptions(options))
-	s := string(res)
-	return goToCStringResult(&s, err)
-}
-
-//export kuzzle_document_mcreate_or_replace
-func kuzzle_document_mcreate_or_replace(d *C.document, index *C.char, collection *C.char, body *C.char, options *C.query_options) *C.string_result {
-	res, err := (*document.Document)(d.instance).MCreateOrReplace(C.GoString(index), C.GoString(collection), json.RawMessage(C.GoString(body)), SetQueryOptions(options))
-	s := string(res)
-	return goToCStringResult(&s, err)
-}
-
-//export kuzzle_document_mdelete
-func kuzzle_document_mdelete(d *C.document, index *C.char, collection *C.char, ids **C.char, l C.size_t, options *C.query_options) *C.string_array_result {
-	res, err := (*document.Document)(d.instance).MDelete(C.GoString(index), C.GoString(collection), cToGoStrings(ids, l), SetQueryOptions(options))
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_document_mget
-func kuzzle_document_mget(d *C.document, index *C.char, collection *C.char, ids **C.char, l C.size_t, includeTrash C.bool, options *C.query_options) *C.string_result {
-	res, err := (*document.Document)(d.instance).MGet(C.GoString(index), C.GoString(collection), cToGoStrings(ids, l), bool(includeTrash), SetQueryOptions(options))
-	s := string(res)
-	return goToCStringResult(&s, err)
-}
-
-//export kuzzle_document_mreplace
-func kuzzle_document_mreplace(d *C.document, index *C.char, collection *C.char, body *C.char, options *C.query_options) *C.string_result {
-	res, err := (*document.Document)(d.instance).MReplace(C.GoString(index), C.GoString(collection), json.RawMessage(C.GoString(body)), SetQueryOptions(options))
-	s := string(res)
-	return goToCStringResult(&s, err)
-}
-
-//export kuzzle_document_mupdate
-func kuzzle_document_mupdate(d *C.document, index *C.char, collection *C.char, body *C.char, options *C.query_options) *C.string_result {
-	res, err := (*document.Document)(d.instance).MUpdate(C.GoString(index), C.GoString(collection), json.RawMessage(C.GoString(body)), SetQueryOptions(options))
-	s := string(res)
-	return goToCStringResult(&s, err)
-}
diff --git a/internal/wrappers/cgo/kuzzle/errors.go b/internal/wrappers/cgo/kuzzle/errors.go
deleted file mode 100644
index 73c7a08c..00000000
--- a/internal/wrappers/cgo/kuzzle/errors.go
+++ /dev/null
@@ -1,179 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-/*
-  #cgo CFLAGS: -I../../../headers
-
-  #include "kuzzlesdk.h"
-*/
-import "C"
-
-import (
-	"github.com/kuzzleio/sdk-go/types"
-)
-
-// apply a types.KuzzleError on a json_result* C struct
-func Set_json_result_error(s *C.json_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-// apply a types.KuzzleError on a token_validity* C struct
-func Set_token_validity_error(s *C.token_validity, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-// apply a types.KuzzleError on a ack_result* C struct
-func Set_ack_result_error(s *C.ack_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-// apply a types.KuzzleError on a bool_result* C struct
-func Set_bool_result_error(s *C.bool_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-// apply a types.KuzzleError on a kuzzle_response* C struct
-func Set_kuzzle_response_error(s *C.kuzzle_response, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-// apply a types.KuzzleError on a statistics* C struct
-func Set_statistics_error(s *C.statistics_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-// apply a types.KuzzleError on a statistics* C struct
-func Set_subscribe_error(s *C.subscribe_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-// apply a types.KuzzleError on a string_array_result* C struct
-func Set_string_array_result_error(s *C.string_array_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-// apply a types.KuzzleError on a int_result* C struct
-func Set_int_result_error(s *C.int_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-// apply a types.KuzzleError on a int_array_result* C struct
-func Set_int_array_result_error(s *C.int_array_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-// apply a types.KuzzleError on a date_result* C struct
-func Set_date_result_error(s *C.date_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-// apply a types.KuzzleError on a string_result* C struct
-func Set_string_result_error(s *C.string_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-// apply a types.KuzzleError on a shards* C struct
-func Set_shards_result_error(s *C.shards_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-// apply a types.KuzzleError on a search_result* C struct
-func Set_search_result_error(s *C.search_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-// apply a types.KuzzleError on a all_statistics_result* C struct
-func Set_all_statistics_error(s *C.all_statistics_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_specification_result_err(s *C.specification_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_specification_search_result_error(s *C.specification_search_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_double_result_error(s *C.double_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_json_array_result_error(s *C.json_array_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_profile_result_error(s *C.profile_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_role_result_error(s *C.role_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_search_profiles_result_error(s *C.search_profiles_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_search_roles_result_error(s *C.search_roles_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_search_users_result_error(s *C.search_users_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_user_result_error(s *C.user_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_profiles_result_error(s *C.profiles_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_roles_result_error(s *C.roles_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_user_rights_error(s *C.user_rights_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_notification_result_error(s *C.notification_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_collection_entry_error(s *C.collection_entry_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_error_result_error(s *C.error_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func Set_room_result_error(s *C.room_result, err error) {
-	setErr(&s.status, &s.error, &s.stack, err)
-}
-
-func setErr(status *C.int, error **C.char, stack **C.char, err error) {
-	kuzzleError := err.(types.KuzzleError)
-	*status = C.int(kuzzleError.Status)
-	*error = C.CString(kuzzleError.Message)
-
-	if len(kuzzleError.Stack) > 0 {
-		*stack = C.CString(kuzzleError.Stack)
-	}
-}
diff --git a/internal/wrappers/cgo/kuzzle/go_to_c.go b/internal/wrappers/cgo/kuzzle/go_to_c.go
deleted file mode 100644
index c7ac2fd2..00000000
--- a/internal/wrappers/cgo/kuzzle/go_to_c.go
+++ /dev/null
@@ -1,766 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-/*
-	#cgo CFLAGS: -I../../headers
-	#include <string.h>
-	#include <stdlib.h>
-	#include "kuzzlesdk.h"
-	#include "sdk_wrappers_internal.h"
-*/
-import "C"
-import (
-	"encoding/json"
-	"unsafe"
-
-	"github.com/kuzzleio/sdk-go/security"
-	"github.com/kuzzleio/sdk-go/types"
-)
-
-func duplicateCollection(ptr *C.collection) *C.collection {
-	dest := (*C.collection)(C.calloc(1, C.sizeof_collection))
-
-	dest.k = ptr.k
-
-	return dest
-}
-
-// Allocates memory
-func goToCMeta(gMeta *types.Meta) *C.meta {
-	if gMeta == nil {
-		return nil
-	}
-
-	result := (*C.meta)(C.calloc(1, C.sizeof_meta))
-	result.author = C.CString(gMeta.Author)
-	result.created_at = C.ulonglong(gMeta.CreatedAt)
-	result.updated_at = C.ulonglong(gMeta.UpdatedAt)
-	result.deleted_at = C.ulonglong(gMeta.DeletedAt)
-	result.updater = C.CString(gMeta.Updater)
-	result.active = C.bool(gMeta.Active)
-
-	return result
-}
-
-// Allocates memory
-func goToCShards(gShards *types.Shards) *C.shards {
-	if gShards == nil {
-		return nil
-	}
-
-	result := (*C.shards)(C.calloc(1, C.sizeof_shards))
-	result.failed = C.int(gShards.Failed)
-	result.successful = C.int(gShards.Successful)
-	result.total = C.int(gShards.Total)
-
-	return result
-}
-
-// Allocates memory
-func goToCNotificationContent(gNotifContent *types.NotificationResult) *C.notification_content {
-	result := (*C.notification_content)(C.calloc(1, C.sizeof_notification_content))
-	result.id = C.CString(gNotifContent.Id)
-	result.m = goToCMeta(gNotifContent.Meta)
-	result.count = C.int(gNotifContent.Count)
-	marshalled, _ := json.Marshal(gNotifContent)
-	result.content = C.CString(string(marshalled))
-
-	return result
-}
-
-// Allocates memory
-func goToCNotificationResult(gNotif *types.KuzzleNotification) *C.notification_result {
-	result := (*C.notification_result)(C.calloc(1, C.sizeof_notification_result))
-
-	if gNotif.Error.Error() != "" {
-		Set_notification_result_error(result, gNotif.Error)
-		return result
-	}
-
-	result.volatiles = C.CString(string(gNotif.Volatile))
-	result.request_id = C.CString(gNotif.RequestId)
-	result.result = goToCNotificationContent(gNotif.Result)
-	result.index = C.CString(gNotif.Index)
-	result.collection = C.CString(gNotif.Collection)
-	result.controller = C.CString(gNotif.Controller)
-	result.action = C.CString(gNotif.Action)
-	result.protocol = C.CString(gNotif.Protocol)
-	result.scope = C.CString(gNotif.Scope)
-	result.state = C.CString(gNotif.State)
-	result.user = C.CString(gNotif.User)
-	result.n_type = C.CString(gNotif.Type)
-	result.room_id = C.CString(gNotif.RoomId)
-	result.timestamp = C.ulonglong(gNotif.Timestamp)
-	result.status = C.int(gNotif.Status)
-
-	return result
-}
-
-func goToCKuzzleResponse(gRes *types.KuzzleResponse) *C.kuzzle_response {
-	result := (*C.kuzzle_response)(C.calloc(1, C.sizeof_kuzzle_response))
-
-	result.request_id = C.CString(gRes.RequestId)
-
-	bufResult := C.CString(string(gRes.Result))
-	result.result = bufResult
-	C.free(unsafe.Pointer(bufResult))
-
-	result.volatiles = C.CString(string(gRes.Volatile))
-	result.index = C.CString(gRes.Index)
-	result.collection = C.CString(gRes.Collection)
-	result.controller = C.CString(gRes.Controller)
-	result.action = C.CString(gRes.Action)
-	result.room_id = C.CString(gRes.RoomId)
-	result.channel = C.CString(gRes.Channel)
-	result.status = C.int(gRes.Status)
-
-	if gRes.Error.Error() != "" {
-		// The error might be a partial error
-		Set_kuzzle_response_error(result, gRes.Error)
-	}
-
-	return result
-}
-
-func goToCPolicyRestriction(restriction *types.PolicyRestriction, dest *C.policy_restriction) *C.policy_restriction {
-	var crestriction *C.policy_restriction
-	if dest == nil {
-		crestriction = (*C.policy_restriction)(C.calloc(1, C.sizeof_policy_restriction))
-	} else {
-		crestriction = dest
-	}
-	crestriction.index = C.CString(restriction.Index)
-	crestriction.collections_length = C.size_t(len(restriction.Collections))
-
-	if restriction.Collections != nil {
-		crestriction.collections = (**C.char)(C.calloc(C.size_t(len(restriction.Collections)), C.sizeof_char_ptr))
-		collections := (*[1<<28 - 1]*C.char)(unsafe.Pointer(crestriction.collections))[:len(restriction.Collections)]
-
-		for i, col := range restriction.Collections {
-			collections[i] = C.CString(col)
-		}
-	}
-
-	return crestriction
-}
-
-// Allocates memory
-func goToCStringResult(goRes *string, err error) *C.string_result {
-	result := (*C.string_result)(C.calloc(1, C.sizeof_string_result))
-
-	if err != nil {
-		Set_string_result_error(result, err)
-		return result
-	}
-
-	if goRes != nil {
-		result.result = C.CString(*goRes)
-	}
-
-	return result
-}
-
-func goToCSubscribeResult(goRes *types.SubscribeResult, err error) *C.subscribe_result {
-	result := (*C.subscribe_result)(C.calloc(1, C.sizeof_subscribe_result))
-
-	if err != nil {
-		Set_subscribe_error(result, err)
-		return result
-	}
-
-	result.room = C.CString(goRes.Room)
-	result.channel = C.CString(goRes.Channel)
-
-	return result
-}
-
-func goToCStringArrayResult(goRes []string, err error) *C.string_array_result {
-	result := (*C.string_array_result)(C.calloc(1, C.sizeof_string_array_result))
-
-	if err != nil {
-		Set_string_array_result_error(result, err)
-		return result
-	}
-
-	if goRes != nil {
-		result.result = (**C.char)(C.calloc(C.size_t(len(goRes)), C.sizeof_char_ptr))
-		result.result_length = C.size_t(len(goRes))
-
-		cArray := (*[1<<28 - 1]*C.char)(unsafe.Pointer(result.result))[:len(goRes):len(goRes)]
-
-		for i, substring := range goRes {
-			cArray[i] = C.CString(substring)
-		}
-	}
-
-	return result
-}
-
-// Allocates memory
-func goToCIntResult(goRes int, err error) *C.int_result {
-	result := (*C.int_result)(C.calloc(1, C.sizeof_int_result))
-
-	if err != nil {
-		Set_int_result_error(result, err)
-		return result
-	}
-
-	result.result = C.longlong(goRes)
-
-	return result
-}
-
-//Allocates memory
-func goToCIntArrayResult(goRes []int, err error) *C.int_array_result {
-	result := (*C.int_array_result)(C.calloc(1, C.sizeof_int_array_result))
-
-	if err != nil {
-		Set_int_array_result_error(result, err)
-		return result
-	}
-
-	if goRes != nil {
-		result.result = (*C.longlong)(C.calloc(C.size_t(len(goRes)), C.sizeof_longlong))
-		result.result_length = C.size_t(len(goRes))
-
-		cArray := (*[1<<20 - 1]C.longlong)(unsafe.Pointer(result.result))[:len(goRes):len(goRes)]
-
-		for i, num := range goRes {
-			cArray[i] = C.longlong(num)
-		}
-	}
-
-	return result
-}
-
-// Allocates memory
-func goToCDoubleResult(goRes float64, err error) *C.double_result {
-	result := (*C.double_result)(C.calloc(1, C.sizeof_double_result))
-
-	if err != nil {
-		Set_double_result_error(result, err)
-		return result
-	}
-
-	result.result = C.double(goRes)
-
-	return result
-}
-
-func goToCPolicy(policy *types.Policy, dest *C.policy) *C.policy {
-	var cpolicy *C.policy
-	if dest == nil {
-		cpolicy = (*C.policy)(C.calloc(1, C.sizeof_policy))
-	} else {
-		cpolicy = dest
-	}
-
-	cpolicy.role_id = C.CString(policy.RoleId)
-	cpolicy.restricted_to_length = C.size_t(len(policy.RestrictedTo))
-
-	if policy.RestrictedTo != nil {
-		cpolicy.restricted_to = (*C.policy_restriction)(C.calloc(C.size_t(len(policy.RestrictedTo)), C.sizeof_policy_restriction))
-		restrictions := (*[1<<27 - 1]C.policy_restriction)(unsafe.Pointer(cpolicy.restricted_to))[:len(policy.RestrictedTo)]
-
-		for i, restriction := range policy.RestrictedTo {
-			goToCPolicyRestriction(restriction, &restrictions[i])
-		}
-	}
-
-	return cpolicy
-}
-
-func goToCProfile(k *C.kuzzle, profile *security.Profile, dest *C.profile) *C.profile {
-	var cprofile *C.profile
-	if dest == nil {
-		cprofile = (*C.profile)(C.calloc(1, C.sizeof_profile))
-	} else {
-		cprofile = dest
-	}
-
-	cprofile.id = C.CString(profile.Id)
-	cprofile.policies_length = C.size_t(len(profile.Policies))
-	cprofile.k = k
-
-	if profile.Policies != nil {
-		cprofile.policies = (*C.policy)(C.calloc(C.size_t(len(profile.Policies)), C.sizeof_policy))
-		policies := (*[1<<27 - 1]C.policy)(unsafe.Pointer(cprofile.policies))[:len(profile.Policies)]
-		for i, policy := range profile.Policies {
-			goToCPolicy(policy, &policies[i])
-		}
-	}
-
-	return cprofile
-}
-
-func goToCProfileSearchResult(k *C.kuzzle, res *security.ProfileSearchResult, err error) *C.search_profiles_result {
-	result := (*C.search_profiles_result)(C.calloc(1, C.sizeof_search_profiles_result))
-
-	if err != nil {
-		Set_search_profiles_result_error(result, err)
-		return result
-	}
-
-	result.result = (*C.profile_search)(C.calloc(1, C.sizeof_profile_search))
-	result.result.hits_length = C.size_t(len(res.Hits))
-	result.result.total = C.uint(res.Total)
-	if res.ScrollId != "" {
-		result.result.scroll_id = C.CString(res.ScrollId)
-	}
-
-	if len(res.Hits) > 0 {
-		result.result.hits = (*C.profile)(C.calloc(C.size_t(len(res.Hits)), C.sizeof_profile))
-		profiles := (*[1<<27 - 1]C.profile)(unsafe.Pointer(result.result.hits))[:len(res.Hits)]
-
-		for i, profile := range res.Hits {
-			goToCProfile(k, profile, &profiles[i])
-		}
-	}
-
-	return result
-}
-
-func goToCRoleSearchResult(k *C.kuzzle, res *security.RoleSearchResult, err error) *C.search_roles_result {
-	result := (*C.search_roles_result)(C.calloc(1, C.sizeof_search_roles_result))
-
-	if err != nil {
-		Set_search_roles_result_error(result, err)
-		return result
-	}
-
-	result.result = (*C.role_search)(C.calloc(1, C.sizeof_role_search))
-	result.result.hits_length = C.size_t(len(res.Hits))
-	result.result.total = C.uint(res.Total)
-
-	if len(res.Hits) > 0 {
-		result.result.hits = (*C.role)(C.calloc(C.size_t(len(res.Hits)), C.sizeof_role))
-		cArray := (*[1<<27 - 1]C.role)(unsafe.Pointer(result.result.hits))[:len(res.Hits):len(res.Hits)]
-
-		for i, role := range res.Hits {
-			goToCRole(k, role, &cArray[i])
-		}
-	}
-
-	return result
-}
-
-// Allocates memory
-func goToCBoolResult(goRes bool, err error) *C.bool_result {
-	result := (*C.bool_result)(C.calloc(1, C.sizeof_bool_result))
-
-	if err != nil {
-		Set_bool_result_error(result, err)
-		return result
-	}
-
-	result.result = C.bool(goRes)
-
-	return result
-}
-
-// Allocates memory
-func goToCSearchResult(goRes *types.SearchResult, err error) *C.search_result {
-	result := (*C.search_result)(C.calloc(1, C.sizeof_search_result))
-
-	if err != nil {
-		Set_search_result_error(result, err)
-		return result
-	}
-
-	result.collection = C.CString(string(goRes.Collection))
-	result.documents = C.CString(string(goRes.Documents))
-
-	result.fetched = C.uint(goRes.Fetched)
-	result.total = C.uint(goRes.Total)
-
-	if goRes.Filters != nil {
-		result.filters = C.CString(string(goRes.Filters))
-	}
-
-	result.options = (*C.query_options)(C.calloc(1, C.sizeof_query_options))
-	if goRes.Options != nil {
-		result.options.from = C.long(goRes.Options.From())
-		result.options.size = C.long(goRes.Options.Size())
-
-		if goRes.Options.ScrollId() != "" {
-			result.options.scroll_id = C.CString(goRes.Options.ScrollId())
-		}
-	}
-
-	if len(goRes.Aggregations) > 0 {
-		result.aggregations = C.CString(string(goRes.Aggregations))
-	}
-
-	return result
-}
-
-func goToCRole(k *C.kuzzle, role *security.Role, dest *C.role) *C.role {
-	var crole *C.role
-	if dest == nil {
-		crole = (*C.role)(C.calloc(1, C.sizeof_role))
-	} else {
-		crole = dest
-	}
-
-	crole.id = C.CString(role.Id)
-	crole.k = k
-
-	if role.Controllers != nil {
-		ctrls, _ := json.Marshal(role.Controllers)
-		crole.controllers = C.CString(string(ctrls))
-	}
-
-	return crole
-}
-
-// Allocates memory
-func goToCSpecification(goSpec *types.Specification) *C.specification {
-	result := (*C.specification)(C.calloc(1, C.sizeof_specification))
-
-	result.strict = C.bool(goSpec.Strict)
-	flds, _ := json.Marshal(goSpec.Fields)
-	result.fields = C.CString(string(flds))
-	result.validators = C.CString(string(goSpec.Validators))
-	return result
-}
-
-// Allocates memory
-func goToCSpecificationEntry(goEntry *types.SpecificationEntry, dest *C.specification_entry) *C.specification_entry {
-	var result *C.specification_entry
-	if dest == nil {
-		result = (*C.specification_entry)(C.calloc(1, C.sizeof_specification_entry))
-	} else {
-		result = dest
-	}
-
-	result.index = C.CString(goEntry.Index)
-	result.collection = C.CString(goEntry.Collection)
-	result.validation = goToCSpecification(goEntry.Validation)
-
-	return result
-}
-
-// Allocates memory
-func goToCSpecificationResult(goRes *types.Specification, err error) *C.specification_result {
-	result := (*C.specification_result)(C.calloc(1, C.sizeof_specification_result))
-
-	if err != nil {
-		Set_specification_result_err(result, err)
-		return result
-	}
-
-	result.result = goToCSpecification(goRes)
-
-	return result
-}
-
-// Allocates memory
-func goToCSpecificationSearchResult(goRes *types.SpecificationSearchResult, err error) *C.specification_search_result {
-	result := (*C.specification_search_result)(C.calloc(1, C.sizeof_specification_search_result))
-
-	if err != nil {
-		Set_specification_search_result_error(result, err)
-		return result
-	}
-
-	result.result = (*C.specification_search)(C.calloc(1, C.sizeof_specification_search))
-	result.result.hits_length = C.size_t(len(goRes.Hits))
-	result.result.total = C.uint(goRes.Total)
-
-	if goRes.ScrollId != "" {
-		result.result.scroll_id = C.CString(goRes.ScrollId)
-	}
-
-	if len(goRes.Hits) > 0 {
-		result.result.hits = (*C.specification_entry)(C.calloc(C.size_t(len(goRes.Hits)), C.sizeof_specification_entry))
-		cArray := (*[1<<27 - 1]C.specification_entry)(unsafe.Pointer(result.result.hits))[:len(goRes.Hits):len(goRes.Hits)]
-
-		for i, spec := range goRes.Hits {
-			goToCSpecificationEntry(&spec.Source, &cArray[i])
-		}
-	}
-
-	return result
-}
-
-func goToCProfileResult(k *C.kuzzle, res *security.Profile, err error) *C.profile_result {
-	result := (*C.profile_result)(C.calloc(1, C.sizeof_profile_result))
-	if err != nil {
-		Set_profile_result_error(result, err)
-		return result
-	}
-
-	result.p = goToCProfile(k, res, nil)
-	return result
-}
-
-func goToCUserData(data *types.UserData) (*C.user_data, error) {
-	if data == nil {
-		return nil, nil
-	}
-
-	cdata := (*C.user_data)(C.calloc(1, C.sizeof_user_data))
-
-	if data.Content != nil {
-		cnt, err := json.Marshal(data.Content)
-		if err != nil {
-			return nil, err
-		}
-		jsonO := C.CString(string(cnt))
-		cdata.content = jsonO
-	}
-
-	if data.ProfileIds != nil {
-		cdata.profile_ids_length = C.size_t(len(data.ProfileIds))
-		cdata.profile_ids = (**C.char)(C.calloc(C.size_t(len(data.ProfileIds)), C.sizeof_char_ptr))
-		carray := (*[1<<27 - 1]*C.char)(unsafe.Pointer(cdata.profile_ids))[:len(data.ProfileIds):len(data.ProfileIds)]
-
-		for i, profileId := range data.ProfileIds {
-			carray[i] = C.CString(profileId)
-		}
-	}
-
-	return cdata, nil
-}
-
-func goToCUser(k *C.kuzzle, user *security.User, dest *C.kuzzle_user) (*C.kuzzle_user, error) {
-	if user == nil {
-		return nil, nil
-	}
-
-	var cuser *C.kuzzle_user
-	if dest == nil {
-		cuser = (*C.kuzzle_user)(C.calloc(1, C.sizeof_kuzzle_user))
-	} else {
-		cuser = dest
-	}
-
-	cuser.id = C.CString(user.Id)
-	cuser.k = k
-
-	if user.Content != nil {
-		cnt, err := json.Marshal(user.Content)
-		if err != nil {
-			return nil, err
-		}
-
-		cuser.content = C.CString(string(cnt))
-	}
-
-	if user.ProfileIds != nil {
-		cuser.profile_ids_length = C.size_t(len(user.ProfileIds))
-		cuser.profile_ids = (**C.char)(C.calloc(C.size_t(len(user.ProfileIds)), C.sizeof_char_ptr))
-		carray := (*[1<<28 - 1]*C.char)(unsafe.Pointer(cuser.profile_ids))[:len(user.ProfileIds):len(user.ProfileIds)]
-
-		for i, profileId := range user.ProfileIds {
-			carray[i] = C.CString(profileId)
-		}
-	}
-
-	return cuser, nil
-}
-
-func goToCUserResult(k *C.kuzzle, user *security.User, err error) *C.user_result {
-	result := (*C.user_result)(C.calloc(1, C.sizeof_user_result))
-	if err != nil {
-		Set_user_result_error(result, err)
-		return result
-	}
-
-	cuser, err := goToCUser(k, user, nil)
-	if err != nil {
-		Set_user_result_error(result, err)
-		return result
-	}
-
-	result.result = cuser
-
-	return result
-}
-
-func goToCProfilesResult(k *C.kuzzle, profiles []*security.Profile, err error) *C.profiles_result {
-	result := (*C.profiles_result)(C.calloc(1, C.sizeof_profiles_result))
-	if err != nil {
-		Set_profiles_result_error(result, err)
-		return result
-	}
-
-	result.profiles_length = C.size_t(len(profiles))
-
-	if profiles != nil {
-		result.profiles = (*C.profile)(C.calloc(C.size_t(len(profiles)), C.sizeof_profile))
-		carray := (*[1<<27 - 1]C.profile)(unsafe.Pointer(result.profiles))[:len(profiles):len(profiles)]
-
-		for i, profile := range profiles {
-			goToCProfile(k, profile, &carray[i])
-		}
-	}
-
-	return result
-}
-
-func goToCRolesResult(k *C.kuzzle, roles []*security.Role, err error) *C.roles_result {
-	result := (*C.roles_result)(C.calloc(1, C.sizeof_roles_result))
-	if err != nil {
-		Set_roles_result_error(result, err)
-		return result
-	}
-
-	result.roles_length = C.size_t(len(roles))
-
-	if roles != nil {
-		result.roles = (*C.role)(C.calloc(C.size_t(len(roles)), C.sizeof_role))
-		carray := (*[1<<27 - 1]C.role)(unsafe.Pointer(result.roles))[:len(roles):len(roles)]
-
-		for i, role := range roles {
-			goToCRole(k, role, &carray[i])
-		}
-	}
-
-	return result
-}
-
-func goToCUserRight(right *types.UserRights, dest *C.user_right) *C.user_right {
-	if right == nil {
-		return nil
-	}
-
-	var cright *C.user_right
-	if dest == nil {
-		cright = (*C.user_right)(C.calloc(1, C.sizeof_user_right))
-	} else {
-		cright = dest
-	}
-
-	cright.controller = C.CString(right.Controller)
-	cright.action = C.CString(right.Action)
-	cright.index = C.CString(right.Index)
-	cright.collection = C.CString(right.Collection)
-	cright.value = C.CString(right.Value)
-
-	return cright
-}
-
-func goToCUserRightsResult(rights []*types.UserRights, err error) *C.user_rights_result {
-	result := (*C.user_rights_result)(C.calloc(1, C.sizeof_user_rights_result))
-	if err != nil {
-		Set_user_rights_error(result, err)
-		return result
-	}
-
-	result.user_rights_length = C.size_t(len(rights))
-	if rights != nil {
-		result.result = (*C.user_right)(C.calloc(C.size_t(len(rights)), C.sizeof_user_right))
-		carray := (*[1<<26 - 1]C.user_right)(unsafe.Pointer(result.result))[:len(rights):len(rights)]
-
-		for i, right := range rights {
-			goToCUserRight(right, &carray[i])
-		}
-	}
-
-	return result
-}
-
-func goToCUserSearchResult(k *C.kuzzle, res *security.UserSearchResult, err error) *C.search_users_result {
-	result := (*C.search_users_result)(C.calloc(1, C.sizeof_search_users_result))
-
-	if err != nil {
-		Set_search_users_result_error(result, err)
-		return result
-	}
-
-	result.result = (*C.user_search)(C.calloc(1, C.sizeof_user_search))
-	result.result.hits_length = C.size_t(len(res.Hits))
-	result.result.total = C.uint(res.Total)
-	if res.ScrollId != "" {
-		result.result.scroll_id = C.CString(res.ScrollId)
-	}
-
-	if len(res.Hits) > 0 {
-		result.result.hits = (*C.kuzzle_user)(C.calloc(C.size_t(len(res.Hits)), C.sizeof_kuzzle_user))
-		users := (*[1<<26 - 1]C.kuzzle_user)(unsafe.Pointer(result.result.hits))[:len(res.Hits)]
-
-		for i, user := range res.Hits {
-			goToCUser(k, user, &users[i])
-		}
-	}
-
-	return result
-}
-
-func fillCollectionList(collection *types.CollectionsList, entry *C.collection_entry) {
-	if collection == nil {
-		return
-	}
-
-	entry.persisted = collection.Type == "persisted"
-	entry.name = C.CString(collection.Name)
-}
-
-func goToCCollectionListResult(collections []*types.CollectionsList, err error) *C.collection_entry_result {
-	result := (*C.collection_entry_result)(C.calloc(1, C.sizeof_collection_entry_result))
-	if err != nil {
-		Set_collection_entry_error(result, err)
-		return result
-	}
-
-	if collections != nil {
-		result.result = (*C.collection_entry)(C.calloc(C.size_t(len(collections)), C.sizeof_collection_entry))
-		result.result_length = C.size_t(len(collections))
-		carray := (*[1<<27 - 1]C.collection_entry)(unsafe.Pointer(result.result))[:len(collections):len(collections)]
-
-		for i, collection := range collections {
-			fillCollectionList(collection, &carray[i])
-		}
-	}
-
-	return result
-}
-
-// Allocates memory
-func fillStatistics(src *types.Statistics, dest *C.statistics) {
-	dest.ongoing_requests = C.CString(string(src.OngoingRequests))
-	dest.completed_requests = C.CString(string(src.CompletedRequests))
-	dest.connections = C.CString(string(src.Connections))
-	dest.failed_requests = C.CString(string(src.FailedRequests))
-	dest.timestamp = C.ulonglong(src.Timestamp)
-}
-
-// Allocates memory
-func goToCErrorResult(err error) *C.error_result {
-	if err == nil {
-		return nil
-	}
-
-	result := (*C.error_result)(C.calloc(1, C.sizeof_error_result))
-	Set_error_result_error(result, err)
-
-	return result
-}
-
-// Allocates memory
-func goToCDateResult(goRes int, err error) *C.date_result {
-	result := (*C.date_result)(C.calloc(1, C.sizeof_date_result))
-
-	if err != nil {
-		Set_date_result_error(result, err)
-		return result
-	}
-
-	result.result = C.longlong(goRes)
-
-	return result
-}
diff --git a/internal/wrappers/cgo/kuzzle/index.go b/internal/wrappers/cgo/kuzzle/index.go
deleted file mode 100644
index 4209b6a3..00000000
--- a/internal/wrappers/cgo/kuzzle/index.go
+++ /dev/null
@@ -1,112 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-/*
-	#cgo CFLAGS: -I../../headers
-	#include <errno.h>
-	#include <stdlib.h>
-	#include "kuzzlesdk.h"
-	#include "sdk_wrappers_internal.h"
-*/
-import "C"
-import (
-	"sync"
-	"unsafe"
-
-	indexPkg "github.com/kuzzleio/sdk-go/index"
-	"github.com/kuzzleio/sdk-go/kuzzle"
-)
-
-// map which stores instances to keep references in case the gc passes
-var indexInstances sync.Map
-
-//register new instance of index
-func registerIndex(instance interface{}, ptr unsafe.Pointer) {
-	indexInstances.Store(instance, ptr)
-}
-
-// unregister an instance from the instances map
-//export unregisterIndex
-func unregisterIndex(i *C.kuzzle_index) {
-	indexInstances.Delete(i)
-}
-
-// Allocates memory
-//export kuzzle_new_index
-func kuzzle_new_index(i *C.kuzzle_index, k *C.kuzzle) {
-	kuz := (*kuzzle.Kuzzle)(k.instance)
-	index := indexPkg.NewIndex(kuz)
-
-	ptr := unsafe.Pointer(index)
-	i.instance = ptr
-	i.k = k
-
-	registerIndex(i, ptr)
-}
-
-//export kuzzle_index_create
-func kuzzle_index_create(i *C.kuzzle_index, index *C.char, options *C.query_options) *C.error_result {
-	err := (*indexPkg.Index)(i.instance).Create(C.GoString(index), SetQueryOptions(options))
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_index_delete
-func kuzzle_index_delete(i *C.kuzzle_index, index *C.char, options *C.query_options) *C.error_result {
-	err := (*indexPkg.Index)(i.instance).Delete(C.GoString(index), SetQueryOptions(options))
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_index_mdelete
-func kuzzle_index_mdelete(i *C.kuzzle_index, indexes **C.char, l C.size_t, options *C.query_options) *C.string_array_result {
-	res, err := (*indexPkg.Index)(i.instance).MDelete(cToGoStrings(indexes, l), SetQueryOptions(options))
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_index_exists
-func kuzzle_index_exists(i *C.kuzzle_index, index *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*indexPkg.Index)(i.instance).Exists(C.GoString(index), SetQueryOptions(options))
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_index_refresh
-func kuzzle_index_refresh(i *C.kuzzle_index, index *C.char, options *C.query_options) *C.error_result {
-	err := (*indexPkg.Index)(i.instance).Refresh(C.GoString(index), SetQueryOptions(options))
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_index_refresh_internal
-func kuzzle_index_refresh_internal(i *C.kuzzle_index, options *C.query_options) *C.error_result {
-	err := (*indexPkg.Index)(i.instance).RefreshInternal(SetQueryOptions(options))
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_index_set_auto_refresh
-func kuzzle_index_set_auto_refresh(i *C.kuzzle_index, index *C.char, autoRefresh C.bool, options *C.query_options) *C.error_result {
-	err := (*indexPkg.Index)(i.instance).SetAutoRefresh(C.GoString(index), bool(autoRefresh), SetQueryOptions(options))
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_index_get_auto_refresh
-func kuzzle_index_get_auto_refresh(i *C.kuzzle_index, index *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*indexPkg.Index)(i.instance).GetAutoRefresh(C.GoString(index), SetQueryOptions(options))
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_index_list
-func kuzzle_index_list(i *C.kuzzle_index, options *C.query_options) *C.string_array_result {
-	res, err := (*indexPkg.Index)(i.instance).List(SetQueryOptions(options))
-	return goToCStringArrayResult(res, err)
-}
diff --git a/internal/wrappers/cgo/kuzzle/kuzzle.go b/internal/wrappers/cgo/kuzzle/kuzzle.go
deleted file mode 100644
index 0f583b21..00000000
--- a/internal/wrappers/cgo/kuzzle/kuzzle.go
+++ /dev/null
@@ -1,386 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-/*
-	#cgo CFLAGS: -I../../headers
-	#include <stdlib.h>
-	#include <string.h>
-	#include "kuzzlesdk.h"
-	#include "sdk_wrappers_internal.h"
-*/
-import "C"
-import (
-	"encoding/json"
-	"sync"
-	"time"
-	"unsafe"
-
-	"github.com/kuzzleio/sdk-go/connection"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
-	"github.com/kuzzleio/sdk-go/kuzzle"
-	"github.com/kuzzleio/sdk-go/types"
-)
-
-// map which stores instances to keep references in case the gc passes
-var instances sync.Map
-
-// map which stores channel and function's pointers adresses for listeners
-var listeners_list map[uintptr]chan<- interface{}
-
-// register new instance to the instances map
-func registerKuzzle(instance interface{}, ptr unsafe.Pointer) {
-	instances.Store(instance, ptr)
-}
-
-// unregister an instance from the instances map
-//export unregisterKuzzle
-func unregisterKuzzle(k *C.kuzzle) {
-	instances.Delete(k)
-}
-
-//export kuzzle_new_kuzzle
-func kuzzle_new_kuzzle(k *C.kuzzle, host, protocol *C.char, options *C.options) {
-	var c connection.Connection
-
-	if listeners_list == nil {
-		listeners_list = make(map[uintptr]chan<- interface{})
-	}
-
-	opts := SetOptions(options)
-
-	if C.GoString(protocol) == "websocket" {
-		c = websocket.NewWebSocket(C.GoString(host), opts)
-	}
-
-	inst, err := kuzzle.NewKuzzle(c, opts)
-
-	if err != nil {
-		panic(err.Error())
-	}
-
-	ptr := unsafe.Pointer(inst)
-	k.instance = ptr
-	k.loader = nil
-
-	registerKuzzle(inst, ptr)
-}
-
-//export kuzzle_get_document_controller
-func kuzzle_get_document_controller(k *C.kuzzle) *C.document {
-	d := (*C.document)(C.calloc(1, C.sizeof_document))
-
-	d.instance = unsafe.Pointer(unsafe.Pointer((*kuzzle.Kuzzle)(k.instance).Document))
-	d.k = k
-	return d
-}
-
-//export kuzzle_get_auth_controller
-func kuzzle_get_auth_controller(k *C.kuzzle) *C.auth {
-	a := (*C.auth)(C.calloc(1, C.sizeof_auth))
-
-	a.instance = unsafe.Pointer(unsafe.Pointer((*kuzzle.Kuzzle)(k.instance).Auth))
-	a.k = k
-	return a
-}
-
-//export kuzzle_get_index_controller
-func kuzzle_get_index_controller(k *C.kuzzle) *C.kuzzle_index {
-	i := (*C.kuzzle_index)(C.calloc(1, C.sizeof_kuzzle_index))
-
-	i.instance = unsafe.Pointer(unsafe.Pointer((*kuzzle.Kuzzle)(k.instance).Index))
-	i.k = k
-	return i
-}
-
-//export kuzzle_get_jwt
-func kuzzle_get_jwt(k *C.kuzzle) *C.char {
-	return C.CString((*kuzzle.Kuzzle)(k.instance).Jwt())
-}
-
-//export kuzzle_set_jwt
-func kuzzle_set_jwt(k *C.kuzzle, jwt *C.char) {
-	(*kuzzle.Kuzzle)(k.instance).SetJwt(C.GoString(jwt))
-}
-
-//export kuzzle_get_server_controller
-func kuzzle_get_server_controller(k *C.kuzzle) *C.server {
-	s := (*C.server)(C.calloc(1, C.sizeof_server))
-
-	s.instance = unsafe.Pointer(unsafe.Pointer((*kuzzle.Kuzzle)(k.instance).Server))
-	s.k = k
-	return s
-}
-
-//export kuzzle_get_collection_controller
-func kuzzle_get_collection_controller(k *C.kuzzle) *C.collection {
-	c := (*C.collection)(C.calloc(1, C.sizeof_collection))
-
-	c.instance = unsafe.Pointer(unsafe.Pointer((*kuzzle.Kuzzle)(k.instance).Collection))
-	c.k = k
-	return c
-}
-
-//export kuzzle_get_realtime_controller
-func kuzzle_get_realtime_controller(k *C.kuzzle) *C.realtime {
-	rt := (*C.realtime)(C.calloc(1, C.sizeof_realtime))
-
-	rt.instance = unsafe.Pointer(unsafe.Pointer((*kuzzle.Kuzzle)(k.instance).Realtime))
-	rt.k = k
-	return rt
-}
-
-// Allocates memory
-//export kuzzle_connect
-func kuzzle_connect(k *C.kuzzle) *C.char {
-	err := (*kuzzle.Kuzzle)(k.instance).Connect()
-	if err != nil {
-		return C.CString(err.Error())
-	}
-
-	return nil
-}
-
-//export kuzzle_disconnect
-func kuzzle_disconnect(k *C.kuzzle) {
-	(*kuzzle.Kuzzle)(k.instance).Disconnect()
-}
-
-//export kuzzle_emit_event
-func kuzzle_emit_event(k *C.kuzzle, event C.int, body *C.char) {
-	(*kuzzle.Kuzzle)(k.instance).EmitEvent(int(event), C.GoString(body))
-}
-
-//export kuzzle_get_offline_queue
-func kuzzle_get_offline_queue(k *C.kuzzle) *C.offline_queue {
-	result := (*C.offline_queue)(C.calloc(1, C.sizeof_offline_queue))
-
-	offlineQueue := (*kuzzle.Kuzzle)(k.instance).OfflineQueue()
-	result.queries_length = C.size_t(len(offlineQueue))
-
-	result.queries = (**C.query_object)(C.calloc(result.queries_length, C.sizeof_query_object_ptr))
-	queryObjects := (*[1<<28 - 1]*C.query_object)(unsafe.Pointer(result.queries))[:result.queries_length:result.queries_length]
-
-	idx := 0
-	for _, queryObject := range offlineQueue {
-		queryObjects[idx] = (*C.query_object)(C.calloc(1, C.sizeof_query_object))
-		queryObjects[idx].timestamp = C.ulonglong(queryObject.Timestamp.Unix())
-		queryObjects[idx].request_id = C.CString(queryObject.RequestId)
-		mquery, _ := json.Marshal(queryObject.Query)
-
-		buffer := C.CString(string(mquery))
-		queryObjects[idx].query = C.CString(C.GoString(buffer))
-		C.free(unsafe.Pointer(buffer))
-
-		idx++
-	}
-
-	return result
-}
-
-//export kuzzle_flush_queue
-func kuzzle_flush_queue(k *C.kuzzle) {
-	(*kuzzle.Kuzzle)(k.instance).FlushQueue()
-}
-
-//export kuzzle_play_queue
-func kuzzle_play_queue(k *C.kuzzle) {
-	(*kuzzle.Kuzzle)(k.instance).PlayQueue()
-}
-
-//export kuzzle_start_queuing
-func kuzzle_start_queuing(k *C.kuzzle) {
-	(*kuzzle.Kuzzle)(k.instance).StartQueuing()
-}
-
-//export kuzzle_stop_queuing
-func kuzzle_stop_queuing(k *C.kuzzle) {
-	(*kuzzle.Kuzzle)(k.instance).StopQueuing()
-}
-
-//export kuzzle_add_listener
-// TODO loop and close on Unsubscribe
-func kuzzle_add_listener(k *C.kuzzle, e C.int, cb C.kuzzle_event_listener, data unsafe.Pointer) {
-	c := make(chan interface{})
-
-	listeners_list[uintptr(unsafe.Pointer(cb))] = c
-	(*kuzzle.Kuzzle)(k.instance).AddListener(int(e), c)
-	go func() {
-		for {
-			res, ok := <-c
-			if ok == false {
-				break
-			}
-			r, _ := json.Marshal(res)
-
-			C.kuzzle_trigger_event(e, cb, C.CString(string(r)), data)
-		}
-	}()
-}
-
-//export kuzzle_once
-func kuzzle_once(k *C.kuzzle, e C.int, cb C.kuzzle_event_listener, data unsafe.Pointer) {
-	c := make(chan interface{})
-
-	listeners_list[uintptr(unsafe.Pointer(cb))] = c
-	(*kuzzle.Kuzzle)(k.instance).Once(int(e), c)
-	go func() {
-		res := <-c
-
-		r, _ := json.Marshal(res)
-
-		C.kuzzle_trigger_event(e, cb, C.CString(string(r)), data)
-	}()
-}
-
-//export kuzzle_listener_count
-func kuzzle_listener_count(k *C.kuzzle, event C.int) int {
-	return (*kuzzle.Kuzzle)(k.instance).ListenerCount(int(event))
-}
-
-//export kuzzle_remove_listener
-func kuzzle_remove_listener(k *C.kuzzle, event C.int, cb unsafe.Pointer) {
-	(*kuzzle.Kuzzle)(k.instance).RemoveListener(int(event), listeners_list[uintptr(cb)])
-}
-
-//export kuzzle_remove_all_listeners
-func kuzzle_remove_all_listeners(k *C.kuzzle, event C.int) {
-	(*kuzzle.Kuzzle)(k.instance).RemoveAllListeners(int(event))
-}
-
-//export kuzzle_get_auto_queue
-func kuzzle_get_auto_queue(k *C.kuzzle) C.bool {
-	return C.bool((*kuzzle.Kuzzle)(k.instance).AutoQueue())
-}
-
-//export kuzzle_set_auto_queue
-func kuzzle_set_auto_queue(k *C.kuzzle, value C.bool) {
-	(*kuzzle.Kuzzle)(k.instance).SetAutoQueue(bool(value))
-}
-
-//export kuzzle_get_auto_reconnect
-func kuzzle_get_auto_reconnect(k *C.kuzzle) C.bool {
-	return C.bool((*kuzzle.Kuzzle)(k.instance).AutoReconnect())
-}
-
-//export kuzzle_get_auto_resubscribe
-func kuzzle_get_auto_resubscribe(k *C.kuzzle) C.bool {
-	return C.bool((*kuzzle.Kuzzle)(k.instance).AutoResubscribe())
-}
-
-//export kuzzle_get_auto_replay
-func kuzzle_get_auto_replay(k *C.kuzzle) C.bool {
-	return C.bool((*kuzzle.Kuzzle)(k.instance).AutoReplay())
-}
-
-//export kuzzle_set_auto_replay
-func kuzzle_set_auto_replay(k *C.kuzzle, value C.bool) {
-	(*kuzzle.Kuzzle)(k.instance).SetAutoReplay(bool(value))
-}
-
-//export kuzzle_get_host
-func kuzzle_get_host(k *C.kuzzle) *C.char {
-	return C.CString((*kuzzle.Kuzzle)(k.instance).Host())
-}
-
-//export kuzzle_get_offline_queue_loader
-func kuzzle_get_offline_queue_loader(k *C.kuzzle) C.kuzzle_offline_queue_loader {
-	return k.loader
-}
-
-//export kuzzle_set_offline_queue_loader
-func kuzzle_set_offline_queue_loader(k *C.kuzzle, loader C.kuzzle_offline_queue_loader) {
-	k.loader = loader
-}
-
-//export kuzzle_get_port
-func kuzzle_get_port(k *C.kuzzle) C.int {
-	return C.int((*kuzzle.Kuzzle)(k.instance).Port())
-}
-
-//export kuzzle_get_queue_filter
-func kuzzle_get_queue_filter(k *C.kuzzle) C.kuzzle_queue_filter {
-	return k.filter
-}
-
-//export kuzzle_set_queue_filter
-func kuzzle_set_queue_filter(k *C.kuzzle, f C.kuzzle_queue_filter) {
-	k.filter = f
-
-	if f != nil {
-		filter := func(q []byte) bool {
-			return bool(C.kuzzle_filter_query(f, (*C.char)(unsafe.Pointer(&q[0]))))
-		}
-
-		(*kuzzle.Kuzzle)(k.instance).SetQueueFilter(filter)
-	} else {
-		(*kuzzle.Kuzzle)(k.instance).SetQueueFilter(nil)
-	}
-}
-
-//export kuzzle_get_queue_max_size
-func kuzzle_get_queue_max_size(k *C.kuzzle) C.int {
-	return C.int((*kuzzle.Kuzzle)(k.instance).QueueMaxSize())
-}
-
-//export kuzzle_set_queue_max_size
-func kuzzle_set_queue_max_size(k *C.kuzzle, size C.int) {
-	(*kuzzle.Kuzzle)(k.instance).SetQueueMaxSize(int(size))
-}
-
-//export kuzzle_get_queue_ttl
-func kuzzle_get_queue_ttl(k *C.kuzzle) C.int {
-	return C.int((*kuzzle.Kuzzle)(k.instance).QueueTTL())
-}
-
-//export kuzzle_set_queue_ttl
-func kuzzle_set_queue_ttl(k *C.kuzzle, ttl C.int) {
-	(*kuzzle.Kuzzle)(k.instance).SetQueueTTL(time.Duration(ttl))
-}
-
-//export kuzzle_get_replay_interval
-func kuzzle_get_replay_interval(k *C.kuzzle) C.int {
-	return C.int((*kuzzle.Kuzzle)(k.instance).ReplayInterval())
-}
-
-//export kuzzle_set_replay_interval
-func kuzzle_set_replay_interval(k *C.kuzzle, interval C.int) {
-	(*kuzzle.Kuzzle)(k.instance).SetReplayInterval(time.Duration(interval))
-}
-
-//export kuzzle_get_reconnection_delay
-func kuzzle_get_reconnection_delay(k *C.kuzzle) C.int {
-	return C.int((*kuzzle.Kuzzle)(k.instance).ReconnectionDelay())
-}
-
-//export kuzzle_get_ssl_connection
-func kuzzle_get_ssl_connection(k *C.kuzzle) C.bool {
-	return C.bool((*kuzzle.Kuzzle)(k.instance).SslConnection())
-}
-
-//export kuzzle_get_volatile
-func kuzzle_get_volatile(k *C.kuzzle) *C.char {
-	r := C.CString(string((*kuzzle.Kuzzle)(k.instance).Volatile()))
-	return r
-}
-
-//export kuzzle_set_volatile
-func kuzzle_set_volatile(k *C.kuzzle, v *C.char) {
-	(*kuzzle.Kuzzle)(k.instance).SetVolatile(types.VolatileData(C.GoString(v)))
-}
-
-func main() {
-
-}
diff --git a/internal/wrappers/cgo/kuzzle/memory_storage.go b/internal/wrappers/cgo/kuzzle/memory_storage.go
deleted file mode 100644
index d3d6990e..00000000
--- a/internal/wrappers/cgo/kuzzle/memory_storage.go
+++ /dev/null
@@ -1,1309 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-/*
-  #cgo CFLAGS: -I../../headers
-
-  #include <stdlib.h>
-  #include <string.h>
-  #include "kuzzlesdk.h"
-  #include "sdk_wrappers_internal.h"
-
-  static void assign_geopos(double (*ptr)[2], int idx, double lon, double lat) {
-    ptr[idx][0] = lon;
-    ptr[idx][1] = lat;
-  }
-*/
-import "C"
-import (
-	"encoding/json"
-	"unsafe"
-
-	"github.com/kuzzleio/sdk-go/kuzzle"
-	"github.com/kuzzleio/sdk-go/types"
-)
-
-//export kuzzle_ms_append
-func kuzzle_ms_append(k *C.kuzzle, key *C.char, value *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Append(
-		C.GoString(key),
-		C.GoString(value),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_bitcount
-func kuzzle_ms_bitcount(k *C.kuzzle, key *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Bitcount(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_bitop
-func kuzzle_ms_bitop(k *C.kuzzle, key *C.char, operation *C.char, keys **C.char, klen C.size_t, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Bitop(
-		C.GoString(key),
-		C.GoString(operation),
-		cToGoStrings(keys, klen),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_bitpos
-func kuzzle_ms_bitpos(k *C.kuzzle, key *C.char, bit C.uchar, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Bitpos(
-		C.GoString(key),
-		int(bit),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_dbsize
-func kuzzle_ms_dbsize(k *C.kuzzle, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Dbsize(SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_decr
-func kuzzle_ms_decr(k *C.kuzzle, key *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Decr(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_decrby
-func kuzzle_ms_decrby(k *C.kuzzle, key *C.char, value C.int, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Decrby(
-		C.GoString(key),
-		int(value),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_del
-func kuzzle_ms_del(k *C.kuzzle, keys **C.char, klen C.size_t, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Del(
-		cToGoStrings(keys, klen),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_exists
-func kuzzle_ms_exists(k *C.kuzzle, keys **C.char, klen C.size_t, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Exists(
-		cToGoStrings(keys, klen),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_expire
-func kuzzle_ms_expire(k *C.kuzzle, key *C.char, seconds C.ulong, options *C.query_options) *C.bool_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Expire(
-		C.GoString(key),
-		int(seconds),
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_ms_expireat
-func kuzzle_ms_expireat(k *C.kuzzle, key *C.char, ts C.ulonglong, options *C.query_options) *C.bool_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Expireat(
-		C.GoString(key),
-		int(ts),
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_ms_flushdb
-func kuzzle_ms_flushdb(k *C.kuzzle, options *C.query_options) *C.error_result {
-	err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Flushdb(SetQueryOptions(options))
-
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_ms_geoadd
-func kuzzle_ms_geoadd(k *C.kuzzle, key *C.char, points **C.point, plen C.size_t, options *C.query_options) *C.int_result {
-	wrapped := (*[1 << 20]*C.point)(unsafe.Pointer(points))[:plen:plen]
-	gopoints := make([]*types.GeoPoint, int(plen))
-
-	for i, jobj := range wrapped {
-		stringified, _ := json.Marshal(jobj)
-		gobytes := C.GoBytes(unsafe.Pointer(&stringified), C.int(C.strlen(C.CString(string(stringified)))))
-		json.Unmarshal(gobytes, gopoints[i])
-	}
-
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Geoadd(
-		C.GoString(key),
-		gopoints,
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_geodist
-func kuzzle_ms_geodist(k *C.kuzzle, key *C.char, member1 *C.char, member2 *C.char, options *C.query_options) *C.double_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Geodist(
-		C.GoString(key),
-		C.GoString(member1),
-		C.GoString(member2),
-		SetQueryOptions(options))
-
-	return goToCDoubleResult(res, err)
-}
-
-//export kuzzle_ms_geohash
-func kuzzle_ms_geohash(k *C.kuzzle, key *C.char, members **C.char, mlen C.size_t, options *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Geohash(
-		C.GoString(key),
-		cToGoStrings(members, mlen),
-		SetQueryOptions(options))
-
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_ms_geopos
-func kuzzle_ms_geopos(k *C.kuzzle, key *C.char, members **C.char, mlen C.size_t, options *C.query_options) *C.geopos_result {
-	result := (*C.geopos_result)(C.calloc(1, C.sizeof_geopos_result))
-
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Geopos(
-		C.GoString(key),
-		cToGoStrings(members, mlen),
-		SetQueryOptions(options))
-
-	if err != nil {
-		kuzzleError := err.(types.KuzzleError)
-		result.status = C.int(kuzzleError.Status)
-		result.error = C.CString(kuzzleError.Message)
-
-		if len(kuzzleError.Stack) > 0 {
-			result.stack = C.CString(kuzzleError.Stack)
-		}
-		return result
-	}
-
-	result.result_length = C.size_t(len(res))
-	result.result = (*[2]C.double)(C.calloc(result.result_length, C.sizeof_geopos_arr))
-
-	for i, pos := range res {
-		C.assign_geopos(result.result, C.int(i), C.double(pos.Lon), C.double(pos.Lat))
-	}
-
-	return result
-}
-
-//export kuzzle_ms_georadius
-func kuzzle_ms_georadius(k *C.kuzzle, key *C.char, lon C.double, lat C.double, dist C.double, unit *C.char, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Georadius(
-		C.GoString(key),
-		float64(lon),
-		float64(lat),
-		float64(dist),
-		C.GoString(unit),
-		SetQueryOptions(options))
-
-	json0, _ := json.Marshal(res)
-
-	str := string(json0)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_ms_georadiusbymember
-func kuzzle_ms_georadiusbymember(k *C.kuzzle, key *C.char, member *C.char, dist C.double, unit *C.char, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Georadiusbymember(
-		C.GoString(key),
-		C.GoString(member),
-		float64(dist),
-		C.GoString(unit),
-		SetQueryOptions(options))
-
-	json0, _ := json.Marshal(res)
-
-	str := string(json0)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_ms_get
-func kuzzle_ms_get(k *C.kuzzle, key *C.char, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Get(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCStringResult(res, err)
-}
-
-//export kuzzle_ms_getbit
-func kuzzle_ms_getbit(k *C.kuzzle, key *C.char, offset C.int, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Getbit(
-		C.GoString(key),
-		int(offset),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_getrange
-func kuzzle_ms_getrange(k *C.kuzzle, key *C.char, start C.int, end C.int, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Getrange(
-		C.GoString(key),
-		int(start),
-		int(end),
-		SetQueryOptions(options))
-
-	return goToCStringResult(&res, err)
-}
-
-//export kuzzle_ms_getset
-func kuzzle_ms_getset(k *C.kuzzle, key *C.char, value *C.char, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Getset(
-		C.GoString(key),
-		C.GoString(value),
-		SetQueryOptions(options))
-
-	return goToCStringResult(res, err)
-}
-
-//export kuzzle_ms_hdel
-func kuzzle_ms_hdel(k *C.kuzzle, key *C.char, fields **C.char, flen C.size_t, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Hdel(
-		C.GoString(key),
-		cToGoStrings(fields, flen),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_hexists
-func kuzzle_ms_hexists(k *C.kuzzle, key *C.char, field *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Hexists(
-		C.GoString(key),
-		C.GoString(field),
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_ms_hget
-func kuzzle_ms_hget(k *C.kuzzle, key *C.char, field *C.char, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Hget(
-		C.GoString(key),
-		C.GoString(field),
-		SetQueryOptions(options))
-
-	return goToCStringResult(res, err)
-}
-
-//export kuzzle_ms_hgetall
-func kuzzle_ms_hgetall(k *C.kuzzle, key *C.char, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Hgetall(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	json0, _ := json.Marshal(res)
-
-	str := string(json0)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_ms_hincrby
-func kuzzle_ms_hincrby(k *C.kuzzle, key *C.char, field *C.char, value C.long, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Hincrby(
-		C.GoString(key),
-		C.GoString(field),
-		int(value),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_hincrbyfloat
-func kuzzle_ms_hincrbyfloat(k *C.kuzzle, key *C.char, field *C.char, value C.double, options *C.query_options) *C.double_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Hincrbyfloat(
-		C.GoString(key),
-		C.GoString(field),
-		float64(value),
-		SetQueryOptions(options))
-
-	return goToCDoubleResult(res, err)
-}
-
-//export kuzzle_ms_hkeys
-func kuzzle_ms_hkeys(k *C.kuzzle, key *C.char, options *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Hkeys(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_ms_hlen
-func kuzzle_ms_hlen(k *C.kuzzle, key *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Hlen(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_hmget
-func kuzzle_ms_hmget(k *C.kuzzle, key *C.char, fields **C.char, flen C.size_t, options *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Hmget(
-		C.GoString(key),
-		cToGoStrings(fields, flen),
-		SetQueryOptions(options))
-
-	// Ms.Hmget returns a []*string value and goToCStringArrayResult
-	// only accept a []string one
-	var converted []string
-
-	if err == nil {
-		converted = make([]string, len(res), len(res))
-
-		for i, val := range res {
-			converted[i] = *val
-		}
-	}
-
-	return goToCStringArrayResult(converted, err)
-}
-
-//export kuzzle_ms_hmset
-func kuzzle_ms_hmset(k *C.kuzzle, key *C.char, entries **C.ms_hash_field, elen C.size_t, options *C.query_options) *C.error_result {
-	wrapped := (*[1 << 20]*C.ms_hash_field)(unsafe.Pointer(entries))[:elen:elen]
-	goentries := make([]*types.MsHashField, int(elen))
-
-	for i, jobj := range wrapped {
-		stringified, _ := json.Marshal(jobj)
-		gobytes := C.GoBytes(unsafe.Pointer(&stringified), C.int(C.strlen(C.CString(string(stringified)))))
-		json.Unmarshal(gobytes, goentries[i])
-	}
-
-	err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Hmset(
-		C.GoString(key),
-		goentries,
-		SetQueryOptions(options))
-
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_ms_hscan
-func kuzzle_ms_hscan(k *C.kuzzle, key *C.char, cursor C.int, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Hscan(
-		C.GoString(key),
-		int(cursor),
-		SetQueryOptions(options))
-
-	json0, _ := json.Marshal(res)
-
-	str := string(json0)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_ms_hset
-func kuzzle_ms_hset(k *C.kuzzle, key *C.char, field *C.char, value *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Hset(
-		C.GoString(key),
-		C.GoString(field),
-		C.GoString(value),
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_ms_hsetnx
-func kuzzle_ms_hsetnx(k *C.kuzzle, key *C.char, field *C.char, value *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Hsetnx(
-		C.GoString(key),
-		C.GoString(field),
-		C.GoString(value),
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_ms_hstrlen
-func kuzzle_ms_hstrlen(k *C.kuzzle, key *C.char, field *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Hstrlen(
-		C.GoString(key),
-		C.GoString(field),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_hvals
-func kuzzle_ms_hvals(k *C.kuzzle, key *C.char, options *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Hvals(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_ms_incr
-func kuzzle_ms_incr(k *C.kuzzle, key *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Incr(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_incrby
-func kuzzle_ms_incrby(k *C.kuzzle, key *C.char, value C.long, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Incrby(
-		C.GoString(key),
-		int(value),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_incrbyfloat
-func kuzzle_ms_incrbyfloat(k *C.kuzzle, key *C.char, value C.double, options *C.query_options) *C.double_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Incrbyfloat(
-		C.GoString(key),
-		float64(value),
-		SetQueryOptions(options))
-
-	return goToCDoubleResult(res, err)
-}
-
-//export kuzzle_ms_keys
-func kuzzle_ms_keys(k *C.kuzzle, pattern *C.char, options *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Keys(
-		C.GoString(pattern),
-		SetQueryOptions(options))
-
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_ms_lindex
-func kuzzle_ms_lindex(k *C.kuzzle, key *C.char, index C.long, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Lindex(
-		C.GoString(key),
-		int(index),
-		SetQueryOptions(options))
-
-	return goToCStringResult(res, err)
-}
-
-//export kuzzle_ms_linsert
-func kuzzle_ms_linsert(k *C.kuzzle, key *C.char, position *C.char, pivot *C.char, value *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Linsert(
-		C.GoString(key),
-		C.GoString(position),
-		C.GoString(pivot),
-		C.GoString(value),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_llen
-func kuzzle_ms_llen(k *C.kuzzle, key *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Llen(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_lpop
-func kuzzle_ms_lpop(k *C.kuzzle, key *C.char, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Lpop(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCStringResult(res, err)
-}
-
-//export kuzzle_ms_lpush
-func kuzzle_ms_lpush(k *C.kuzzle, key *C.char, values **C.char, vlen C.size_t, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Lpush(
-		C.GoString(key),
-		cToGoStrings(values, vlen),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_lpushx
-func kuzzle_ms_lpushx(k *C.kuzzle, key *C.char, value *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Lpushx(
-		C.GoString(key),
-		C.GoString(value),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_lrange
-func kuzzle_ms_lrange(k *C.kuzzle, key *C.char, start C.long, stop C.long, options *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Lrange(
-		C.GoString(key),
-		int(start),
-		int(stop),
-		SetQueryOptions(options))
-
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_ms_lrem
-func kuzzle_ms_lrem(k *C.kuzzle, key *C.char, count C.long, value *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Lrem(
-		C.GoString(key),
-		int(count),
-		C.GoString(value),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_lset
-func kuzzle_ms_lset(k *C.kuzzle, key *C.char, index C.long, value *C.char, options *C.query_options) *C.error_result {
-	err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Lset(
-		C.GoString(key),
-		int(index),
-		C.GoString(value),
-		SetQueryOptions(options))
-
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_ms_ltrim
-func kuzzle_ms_ltrim(k *C.kuzzle, key *C.char, start C.long, stop C.long, options *C.query_options) *C.error_result {
-	err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Ltrim(
-		C.GoString(key),
-		int(start),
-		int(stop),
-		SetQueryOptions(options))
-
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_ms_mget
-func kuzzle_ms_mget(k *C.kuzzle, keys **C.char, klen C.size_t, options *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Mget(
-		cToGoStrings(keys, klen),
-		SetQueryOptions(options))
-
-	var converted []string
-
-	if err == nil {
-		converted = make([]string, len(res), len(res))
-
-		for i, val := range res {
-			converted[i] = *val
-		}
-	}
-
-	return goToCStringArrayResult(converted, err)
-}
-
-//export kuzzle_ms_mset
-func kuzzle_ms_mset(k *C.kuzzle, entries **C.ms_key_value, elen C.size_t, options *C.query_options) *C.error_result {
-	wrapped := (*[1 << 20]*C.ms_key_value)(unsafe.Pointer(entries))[:elen:elen]
-	goentries := make([]*types.MSKeyValue, int(elen))
-
-	for i, jobj := range wrapped {
-		stringified, _ := json.Marshal(jobj)
-		gobytes := C.GoBytes(unsafe.Pointer(&stringified), C.int(C.strlen(C.CString(string(stringified)))))
-		json.Unmarshal(gobytes, goentries[i])
-	}
-
-	err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Mset(
-		goentries,
-		SetQueryOptions(options))
-
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_ms_msetnx
-func kuzzle_ms_msetnx(k *C.kuzzle, entries **C.ms_key_value, elen C.size_t, options *C.query_options) *C.bool_result {
-	wrapped := (*[1 << 20]*C.ms_key_value)(unsafe.Pointer(entries))[:elen:elen]
-	goentries := make([]*types.MSKeyValue, int(elen))
-
-	for i, jobj := range wrapped {
-		stringified, _ := json.Marshal(jobj)
-		gobytes := C.GoBytes(unsafe.Pointer(&stringified), C.int(C.strlen(C.CString(string(stringified)))))
-		json.Unmarshal(gobytes, goentries[i])
-	}
-
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Msetnx(
-		goentries,
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_ms_object
-func kuzzle_ms_object(k *C.kuzzle, key *C.char, subcommand *C.char, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Object(
-		C.GoString(key),
-		C.GoString(subcommand),
-		SetQueryOptions(options))
-
-	return goToCStringResult(res, err)
-}
-
-//export kuzzle_ms_persist
-func kuzzle_ms_persist(k *C.kuzzle, key *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Persist(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_ms_pexpire
-func kuzzle_ms_pexpire(k *C.kuzzle, key *C.char, ttl C.ulong, options *C.query_options) *C.bool_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Pexpire(
-		C.GoString(key),
-		int(ttl),
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_ms_pexpireat
-func kuzzle_ms_pexpireat(k *C.kuzzle, key *C.char, ts C.ulonglong, options *C.query_options) *C.bool_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Pexpireat(
-		C.GoString(key),
-		uint64(ts),
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_ms_pfadd
-func kuzzle_ms_pfadd(k *C.kuzzle, key *C.char, elements **C.char, elen C.size_t, options *C.query_options) *C.bool_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Pfadd(
-		C.GoString(key),
-		cToGoStrings(elements, elen),
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_ms_pfcount
-func kuzzle_ms_pfcount(k *C.kuzzle, keys **C.char, klen C.size_t, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Pfcount(
-		cToGoStrings(keys, klen),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_pfmerge
-func kuzzle_ms_pfmerge(k *C.kuzzle, key *C.char, sources **C.char, slen C.size_t, options *C.query_options) *C.error_result {
-	err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Pfmerge(
-		C.GoString(key),
-		cToGoStrings(sources, slen),
-		SetQueryOptions(options))
-
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_ms_ping
-func kuzzle_ms_ping(k *C.kuzzle, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Ping(
-		SetQueryOptions(options))
-
-	return goToCStringResult(&res, err)
-}
-
-//export kuzzle_ms_psetex
-func kuzzle_ms_psetex(k *C.kuzzle, key *C.char, value *C.char, ttl C.ulong, options *C.query_options) *C.error_result {
-	err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Psetex(
-		C.GoString(key),
-		C.GoString(value),
-		int(ttl),
-		SetQueryOptions(options))
-
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_ms_pttl
-func kuzzle_ms_pttl(k *C.kuzzle, key *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Pttl(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_randomkey
-func kuzzle_ms_randomkey(k *C.kuzzle, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Randomkey(
-		SetQueryOptions(options))
-
-	return goToCStringResult(res, err)
-}
-
-//export kuzzle_ms_rename
-func kuzzle_ms_rename(k *C.kuzzle, key *C.char, newkey *C.char, options *C.query_options) *C.error_result {
-	err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Rename(
-		C.GoString(key),
-		C.GoString(newkey),
-		SetQueryOptions(options))
-
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_ms_renamenx
-func kuzzle_ms_renamenx(k *C.kuzzle, key *C.char, newkey *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Renamenx(
-		C.GoString(key),
-		C.GoString(newkey),
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_ms_rpop
-func kuzzle_ms_rpop(k *C.kuzzle, key *C.char, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Rpop(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCStringResult(res, err)
-}
-
-//export kuzzle_ms_rpoplpush
-func kuzzle_ms_rpoplpush(k *C.kuzzle, key *C.char, dest *C.char, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Rpoplpush(
-		C.GoString(key),
-		C.GoString(dest),
-		SetQueryOptions(options))
-
-	return goToCStringResult(res, err)
-}
-
-//export kuzzle_ms_rpush
-func kuzzle_ms_rpush(k *C.kuzzle, key *C.char, values **C.char, vlen C.size_t, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Rpush(
-		C.GoString(key),
-		cToGoStrings(values, vlen),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_rpushx
-func kuzzle_ms_rpushx(k *C.kuzzle, key *C.char, value *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Rpushx(
-		C.GoString(key),
-		C.GoString(value),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_sadd
-func kuzzle_ms_sadd(k *C.kuzzle, key *C.char, members **C.char, mlen C.size_t, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Sadd(
-		C.GoString(key),
-		cToGoStrings(members, mlen),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_scan
-func kuzzle_ms_scan(k *C.kuzzle, cursor C.int, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Scan(
-		int(cursor),
-		SetQueryOptions(options))
-
-	json0, _ := json.Marshal(res)
-
-	str := string(json0)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_ms_scard
-func kuzzle_ms_scard(k *C.kuzzle, key *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Scard(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_sdiff
-func kuzzle_ms_sdiff(k *C.kuzzle, key *C.char, keys **C.char, klen C.size_t, options *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Sdiff(
-		C.GoString(key),
-		cToGoStrings(keys, klen),
-		SetQueryOptions(options))
-
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_ms_sdiffstore
-func kuzzle_ms_sdiffstore(k *C.kuzzle, key *C.char, keys **C.char, klen C.size_t, dest *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Sdiffstore(
-		C.GoString(key),
-		cToGoStrings(keys, klen),
-		C.GoString(dest),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_set
-func kuzzle_ms_set(k *C.kuzzle, key *C.char, value *C.char, options *C.query_options) *C.error_result {
-	err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Set(
-		C.GoString(key),
-		C.GoString(value),
-		SetQueryOptions(options))
-
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_ms_setex
-func kuzzle_ms_setex(k *C.kuzzle, key *C.char, value *C.char, ttl C.ulong, options *C.query_options) *C.error_result {
-	err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Setex(
-		C.GoString(key),
-		C.GoString(value),
-		int(ttl),
-		SetQueryOptions(options))
-
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_ms_setnx
-func kuzzle_ms_setnx(k *C.kuzzle, key *C.char, value *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Setnx(
-		C.GoString(key),
-		C.GoString(value),
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_ms_sinter
-func kuzzle_ms_sinter(k *C.kuzzle, keys **C.char, klen C.size_t, options *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Sinter(
-		cToGoStrings(keys, klen),
-		SetQueryOptions(options))
-
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_ms_sinterstore
-func kuzzle_ms_sinterstore(k *C.kuzzle, dest *C.char, keys **C.char, klen C.size_t, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Sinterstore(
-		C.GoString(dest),
-		cToGoStrings(keys, klen),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_sismember
-func kuzzle_ms_sismember(k *C.kuzzle, key *C.char, member *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Sismember(
-		C.GoString(key),
-		C.GoString(member),
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_ms_smembers
-func kuzzle_ms_smembers(k *C.kuzzle, key *C.char, options *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Smembers(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_ms_smove
-func kuzzle_ms_smove(k *C.kuzzle, key *C.char, dest *C.char, member *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Smove(
-		C.GoString(key),
-		C.GoString(dest),
-		C.GoString(member),
-		SetQueryOptions(options))
-
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_ms_sort
-func kuzzle_ms_sort(k *C.kuzzle, key *C.char, options *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Sort(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_ms_spop
-func kuzzle_ms_spop(k *C.kuzzle, key *C.char, options *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Spop(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_ms_srandmember
-func kuzzle_ms_srandmember(k *C.kuzzle, key *C.char, options *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Srandmember(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_ms_srem
-func kuzzle_ms_srem(k *C.kuzzle, key *C.char, members **C.char, mlen C.size_t, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Srem(
-		C.GoString(key),
-		cToGoStrings(members, mlen),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_sscan
-func kuzzle_ms_sscan(k *C.kuzzle, key *C.char, cursor C.int, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Sscan(
-		C.GoString(key),
-		int(cursor),
-		SetQueryOptions(options))
-
-	json0, _ := json.Marshal(res)
-
-	str := string(json0)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_ms_strlen
-func kuzzle_ms_strlen(k *C.kuzzle, key *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Strlen(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_sunion
-func kuzzle_ms_sunion(k *C.kuzzle, keys **C.char, klen C.size_t, options *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Sunion(
-		cToGoStrings(keys, klen),
-		SetQueryOptions(options))
-
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_ms_sunionstore
-func kuzzle_ms_sunionstore(k *C.kuzzle, dest *C.char, keys **C.char, klen C.size_t, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Sunionstore(
-		C.GoString(dest),
-		cToGoStrings(keys, klen),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_time
-func kuzzle_ms_time(k *C.kuzzle, options *C.query_options) *C.int_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Time(
-		SetQueryOptions(options))
-
-	return goToCIntArrayResult(res, err)
-}
-
-//export kuzzle_ms_touch
-func kuzzle_ms_touch(k *C.kuzzle, keys **C.char, klen C.size_t, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Touch(
-		cToGoStrings(keys, klen),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_ttl
-func kuzzle_ms_ttl(k *C.kuzzle, key *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Ttl(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_type
-func kuzzle_ms_type(k *C.kuzzle, key *C.char, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Type(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCStringResult(&res, err)
-}
-
-//export kuzzle_ms_zadd
-func kuzzle_ms_zadd(k *C.kuzzle, key *C.char, elements **C.ms_sorted_set, elen C.size_t, options *C.query_options) *C.int_result {
-	wrapped := (*[1 << 20]*C.ms_sorted_set)(unsafe.Pointer(elements))[:elen:elen]
-	goelements := make([]*types.MSSortedSet, int(elen))
-
-	for i, jobj := range wrapped {
-		stringified, _ := json.Marshal(jobj)
-		gobytes := C.GoBytes(unsafe.Pointer(&stringified), C.int(C.strlen(C.CString(string(stringified)))))
-		json.Unmarshal(gobytes, goelements[i])
-	}
-
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zadd(
-		C.GoString(key),
-		goelements,
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_zcard
-func kuzzle_ms_zcard(k *C.kuzzle, key *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zcard(
-		C.GoString(key),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_zcount
-func kuzzle_ms_zcount(k *C.kuzzle, key *C.char, min C.long, max C.long, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zcount(
-		C.GoString(key),
-		int(min),
-		int(max),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_zincrby
-func kuzzle_ms_zincrby(k *C.kuzzle, key *C.char, member *C.char, incr C.double, options *C.query_options) *C.double_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zincrby(
-		C.GoString(key),
-		C.GoString(member),
-		float64(incr),
-		SetQueryOptions(options))
-
-	return goToCDoubleResult(res, err)
-}
-
-//export kuzzle_ms_zinterstore
-func kuzzle_ms_zinterstore(k *C.kuzzle, dest *C.char, keys **C.char, klen C.size_t, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zinterstore(
-		C.GoString(dest),
-		cToGoStrings(keys, klen),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_zlexcount
-func kuzzle_ms_zlexcount(k *C.kuzzle, key *C.char, min *C.char, max *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zlexcount(
-		C.GoString(key),
-		C.GoString(min),
-		C.GoString(max),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_zrange
-func kuzzle_ms_zrange(k *C.kuzzle, key *C.char, start C.long, stop C.long, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zrange(
-		C.GoString(key),
-		int(start),
-		int(stop),
-		SetQueryOptions(options))
-
-	json0, _ := json.Marshal(res)
-
-	str := string(json0)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_ms_zrangebylex
-func kuzzle_ms_zrangebylex(k *C.kuzzle, key *C.char, min *C.char, max *C.char, options *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zrangebylex(
-		C.GoString(key),
-		C.GoString(min),
-		C.GoString(max),
-		SetQueryOptions(options))
-
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_ms_zrangebyscore
-func kuzzle_ms_zrangebyscore(k *C.kuzzle, key *C.char, min C.double, max C.double, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zrangebyscore(
-		C.GoString(key),
-		float64(min),
-		float64(max),
-		SetQueryOptions(options))
-
-	json0, _ := json.Marshal(res)
-
-	str := string(json0)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_ms_zrank
-func kuzzle_ms_zrank(k *C.kuzzle, key *C.char, member *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zrank(
-		C.GoString(key),
-		C.GoString(member),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_zrem
-func kuzzle_ms_zrem(k *C.kuzzle, key *C.char, members **C.char, mlen C.size_t, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zrem(
-		C.GoString(key),
-		cToGoStrings(members, mlen),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_zremrangebylex
-func kuzzle_ms_zremrangebylex(k *C.kuzzle, key *C.char, min *C.char, max *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zremrangebylex(
-		C.GoString(key),
-		C.GoString(min),
-		C.GoString(max),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_zremrangebyrank
-func kuzzle_ms_zremrangebyrank(k *C.kuzzle, key *C.char, min C.long, max C.long, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zremrangebyrank(
-		C.GoString(key),
-		int(min),
-		int(max),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_zremrangebyscore
-func kuzzle_ms_zremrangebyscore(k *C.kuzzle, key *C.char, min C.double, max C.double, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zremrangebyscore(
-		C.GoString(key),
-		float64(min),
-		float64(max),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_zrevrange
-func kuzzle_ms_zrevrange(k *C.kuzzle, key *C.char, start C.long, stop C.long, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zrevrange(
-		C.GoString(key),
-		int(start),
-		int(stop),
-		SetQueryOptions(options))
-
-	json0, _ := json.Marshal(res)
-
-	str := string(json0)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_ms_zrevrangebylex
-func kuzzle_ms_zrevrangebylex(k *C.kuzzle, key *C.char, min *C.char, max *C.char, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zrevrangebylex(
-		C.GoString(key),
-		C.GoString(min),
-		C.GoString(max),
-		SetQueryOptions(options))
-
-	json0, _ := json.Marshal(res)
-
-	str := string(json0)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_ms_zrevrangebyscore
-func kuzzle_ms_zrevrangebyscore(k *C.kuzzle, key *C.char, min C.double, max C.double, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zrevrangebyscore(
-		C.GoString(key),
-		float64(min),
-		float64(max),
-		SetQueryOptions(options))
-
-	json0, _ := json.Marshal(res)
-
-	str := string(json0)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_ms_zrevrank
-func kuzzle_ms_zrevrank(k *C.kuzzle, key *C.char, member *C.char, options *C.query_options) *C.int_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zrevrank(
-		C.GoString(key),
-		C.GoString(member),
-		SetQueryOptions(options))
-
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_ms_zscan
-func kuzzle_ms_zscan(k *C.kuzzle, key *C.char, cursor C.int, options *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zscan(
-		C.GoString(key),
-		int(cursor),
-		SetQueryOptions(options))
-
-	json0, _ := json.Marshal(res)
-
-	str := string(json0)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_ms_zscore
-func kuzzle_ms_zscore(k *C.kuzzle, key *C.char, member *C.char, options *C.query_options) *C.double_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).MemoryStorage.Zscore(
-		C.GoString(key),
-		C.GoString(member),
-		SetQueryOptions(options))
-
-	return goToCDoubleResult(res, err)
-}
diff --git a/internal/wrappers/cgo/kuzzle/options.go b/internal/wrappers/cgo/kuzzle/options.go
deleted file mode 100644
index 93a2a43c..00000000
--- a/internal/wrappers/cgo/kuzzle/options.go
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-/*
-	#cgo CFLAGS: -I../../headers
-	#include <stdlib.h>
-	#include "kuzzlesdk.h"
-*/
-import "C"
-import (
-	"time"
-
-	"github.com/kuzzleio/sdk-go/types"
-)
-
-//export kuzzle_new_options
-func kuzzle_new_options() *C.options {
-	copts := (*C.options)(C.calloc(1, C.sizeof_options))
-	opts := types.NewOptions()
-
-	copts.queue_ttl = C.uint(opts.QueueTTL())
-	copts.queue_max_size = C.ulong(opts.QueueMaxSize())
-	copts.auto_queue = C.bool(opts.AutoQueue())
-	copts.auto_reconnect = C.bool(opts.AutoReconnect())
-	copts.auto_replay = C.bool(opts.AutoReplay())
-	copts.auto_resubscribe = C.bool(opts.AutoResubscribe())
-	copts.reconnection_delay = C.ulong(opts.ReconnectionDelay())
-	copts.replay_interval = C.ulong(opts.ReplayInterval())
-
-	if opts.OfflineMode() == 1 {
-		copts.offline_mode = C.MANUAL
-	} else {
-		copts.offline_mode = C.AUTO
-	}
-
-	refresh := opts.Refresh()
-	if len(refresh) > 0 {
-		copts.refresh = C.CString(refresh)
-	}
-
-	return copts
-}
-
-func SetQueryOptions(options *C.query_options) (opts types.QueryOptions) {
-	if options == nil {
-		return
-	}
-
-	opts = types.NewQueryOptions()
-
-	opts.SetQueuable(bool(options.queuable))
-	opts.SetWithdist(bool(options.withdist))
-	opts.SetWithcoord(bool(options.withcoord))
-	opts.SetFrom(int(options.from))
-	opts.SetSize(int(options.size))
-	opts.SetScroll(C.GoString(options.scroll))
-	opts.SetScrollId(C.GoString(options.scroll_id))
-	opts.SetRefresh(C.GoString(options.refresh))
-	opts.SetIfExist(C.GoString(options.if_exist))
-	opts.SetRetryOnConflict(int(options.retry_on_conflict))
-	volatiles := types.VolatileData(C.GoString(options.volatiles))
-	if volatiles != nil {
-		opts.SetVolatile(volatiles)
-	}
-
-	return
-}
-
-func SetOptions(options *C.options) (opts types.Options) {
-	if options == nil {
-		return
-	}
-
-	opts = types.NewOptions()
-
-	opts.SetQueueTTL(time.Duration(uint16(options.queue_ttl)))
-	opts.SetQueueMaxSize(int(options.queue_max_size))
-	opts.SetOfflineMode(int(options.offline_mode))
-
-	opts.SetAutoQueue(bool(options.auto_queue))
-	opts.SetAutoReconnect(bool(options.auto_reconnect))
-	opts.SetAutoReplay(bool(options.auto_replay))
-	opts.SetAutoResubscribe(bool(options.auto_resubscribe))
-	opts.SetReconnectionDelay(time.Duration(int(options.reconnection_delay)))
-	opts.SetReplayInterval(time.Duration(int(options.replay_interval)))
-	opts.SetRefresh(C.GoString(options.refresh))
-
-	return
-}
-
-func SetRoomOptions(options *C.room_options) (opts types.RoomOptions) {
-	opts = types.NewRoomOptions()
-
-	if options != nil {
-		opts.SetScope(C.GoString(options.scope))
-		opts.SetState(C.GoString(options.state))
-		opts.SetUsers(C.GoString(options.user))
-
-		opts.SetSubscribeToSelf(bool(options.subscribe_to_self))
-
-		if options.volatiles != nil {
-			opts.SetVolatile(types.VolatileData(C.GoString(options.volatiles)))
-		}
-	}
-	return
-}
diff --git a/internal/wrappers/cgo/kuzzle/query.go b/internal/wrappers/cgo/kuzzle/query.go
deleted file mode 100644
index 85b28a29..00000000
--- a/internal/wrappers/cgo/kuzzle/query.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-/*
-	#cgo CFLAGS: -I../../headers
-	#include <stdlib.h>
-	#include "kuzzlesdk.h"
-*/
-import "C"
-import (
-	"encoding/json"
-
-	"github.com/kuzzleio/sdk-go/kuzzle"
-	"github.com/kuzzleio/sdk-go/types"
-)
-
-//export kuzzle_query
-func kuzzle_query(k *C.kuzzle, request *C.kuzzle_request, options *C.query_options) *C.kuzzle_response {
-	opts := SetQueryOptions(options)
-
-	req := types.KuzzleRequest{
-		RequestId:  C.GoString(request.request_id),
-		Controller: C.GoString(request.controller),
-		Action:     C.GoString(request.action),
-		Index:      C.GoString(request.index),
-		Collection: C.GoString(request.collection),
-		Id:         C.GoString(request.id),
-		From:       int(request.from),
-		Size:       int(request.size),
-		Scroll:     C.GoString(request.scroll),
-		ScrollId:   C.GoString(request.scroll_id),
-		Strategy:   C.GoString(request.strategy),
-		ExpiresIn:  int(request.expires_in),
-		Scope:      C.GoString(request.scope),
-		State:      C.GoString(request.state),
-		Users:      C.GoString(request.user),
-		Start:      int(request.start),
-		Stop:       int(request.stop),
-		End:        int(request.end),
-		Bit:        int(request.bit),
-		Member:     C.GoString(request.member),
-		Member1:    C.GoString(request.member1),
-		Member2:    C.GoString(request.member2),
-		Lon:        float64(request.lon),
-		Lat:        float64(request.lat),
-		Distance:   float64(request.distance),
-		Unit:       C.GoString(request.unit),
-		Cursor:     int(request.cursor),
-		Offset:     int(request.offset),
-		Field:      C.GoString(request.field),
-		Subcommand: C.GoString(request.subcommand),
-		Pattern:    C.GoString(request.pattern),
-		Idx:        int(request.idx),
-		Min:        C.GoString(request.min),
-		Max:        C.GoString(request.max),
-		Limit:      C.GoString(request.limit),
-		Count:      int(request.count),
-		Match:      C.GoString(request.match),
-	}
-
-	if request.body != nil {
-		req.Body = json.RawMessage(C.GoString(request.body))
-	}
-
-	if request.volatiles != nil {
-		req.Volatile = types.VolatileData(C.GoString(request.volatiles))
-	}
-
-	start := int(request.start)
-	req.Start = start
-	req.Members = cToGoStrings(request.members, request.members_length)
-	req.Keys = cToGoStrings(request.keys, request.keys_length)
-	req.Fields = cToGoStrings(request.fields, request.fields_length)
-
-	resC := make(chan *types.KuzzleResponse)
-	(*kuzzle.Kuzzle)(k.instance).Query(&req, opts, resC)
-
-	res := <-resC
-
-	return goToCKuzzleResponse(res)
-}
diff --git a/internal/wrappers/cgo/kuzzle/realtime.go b/internal/wrappers/cgo/kuzzle/realtime.go
deleted file mode 100644
index 6c5e917f..00000000
--- a/internal/wrappers/cgo/kuzzle/realtime.go
+++ /dev/null
@@ -1,113 +0,0 @@
-// Copyright 2015-2017 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-/*
-	#cgo CFLAGS: -I../../headers
-	#include "kuzzlesdk.h"
-    #include "sdk_wrappers_internal.h"
-*/
-import "C"
-
-import (
-	"encoding/json"
-	"sync"
-	"unsafe"
-
-	"github.com/kuzzleio/sdk-go/kuzzle"
-	"github.com/kuzzleio/sdk-go/realtime"
-	"github.com/kuzzleio/sdk-go/types"
-)
-
-// map which stores instances to keep references in case the gc passes
-var realtimeInstances sync.Map
-
-// register new instance to the instances map
-func registerRealtime(instance interface{}, ptr unsafe.Pointer) {
-	realtimeInstances.Store(instance, ptr)
-}
-
-// unregister an instance from the instances map
-//export unregisterRealtime
-func unregisterRealtime(rt *C.realtime) {
-	realtimeInstances.Delete(rt)
-}
-
-// Allocates memory
-//export kuzzle_new_realtime
-func kuzzle_new_realtime(rt *C.realtime, k *C.kuzzle) {
-	kuz := (*kuzzle.Kuzzle)(k.instance)
-	gort := realtime.NewRealtime(kuz)
-
-	ptr := unsafe.Pointer(gort)
-	rt.instance = ptr
-	rt.k = k
-
-	registerRealtime(rt, ptr)
-}
-
-//export kuzzle_realtime_count
-func kuzzle_realtime_count(rt *C.realtime, index, collection, roomId *C.char, options *C.query_options) *C.int_result {
-	res, err := (*realtime.Realtime)(rt.instance).Count(C.GoString(index), C.GoString(collection), C.GoString(roomId), SetQueryOptions(options))
-	return goToCIntResult(res, err)
-}
-
-//export kuzzle_realtime_list
-func kuzzle_realtime_list(rt *C.realtime, index, collection *C.char, options *C.query_options) *C.string_result {
-	res, err := (*realtime.Realtime)(rt.instance).List(C.GoString(index), C.GoString(collection), SetQueryOptions(options))
-	var stringResult string
-	json.Unmarshal(res, &stringResult)
-	return goToCStringResult(&stringResult, err)
-}
-
-//export kuzzle_realtime_publish
-func kuzzle_realtime_publish(rt *C.realtime, index, collection, body *C.char, options *C.query_options) *C.error_result {
-	err := (*realtime.Realtime)(rt.instance).Publish(C.GoString(index), C.GoString(collection), json.RawMessage(C.GoString(body)), SetQueryOptions(options))
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_realtime_unsubscribe
-func kuzzle_realtime_unsubscribe(rt *C.realtime, roomId *C.char, options *C.query_options) *C.error_result {
-	err := (*realtime.Realtime)(rt.instance).Unsubscribe(C.GoString(roomId), SetQueryOptions(options))
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_realtime_subscribe
-func kuzzle_realtime_subscribe(rt *C.realtime, index, collection, body *C.char, callback C.kuzzle_notification_listener, data unsafe.Pointer, options *C.room_options) *C.subscribe_result {
-	c := make(chan types.KuzzleNotification)
-	subRes, err := (*realtime.Realtime)(rt.instance).Subscribe(C.GoString(index), C.GoString(collection), json.RawMessage(C.GoString(body)), c, SetRoomOptions(options))
-
-	if err != nil {
-		return goToCSubscribeResult(subRes, err)
-	}
-
-	go func() {
-		for {
-			res, ok := <-c
-			if ok == false {
-				break
-			}
-			C.kuzzle_notify(callback, goToCNotificationResult(&res), data)
-		}
-	}()
-
-	return goToCSubscribeResult(subRes, err)
-}
-
-//export kuzzle_realtime_validate
-func kuzzle_realtime_validate(rt *C.realtime, index, collection, body *C.char, options *C.query_options) *C.bool_result {
-	res, err := (*realtime.Realtime)(rt.instance).Validate(C.GoString(index), C.GoString(collection), C.GoString(body), SetQueryOptions(options))
-	return goToCBoolResult(res, err)
-}
diff --git a/internal/wrappers/cgo/kuzzle/security.go b/internal/wrappers/cgo/kuzzle/security.go
deleted file mode 100644
index 41c66011..00000000
--- a/internal/wrappers/cgo/kuzzle/security.go
+++ /dev/null
@@ -1,495 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-/*
-	#cgo CFLAGS: -I../../headers
-	#include <errno.h>
-	#include <stdlib.h>
-	#include "kuzzlesdk.h"
-	#include "sdk_wrappers_internal.h"
-*/
-import "C"
-
-import (
-	"encoding/json"
-	"unsafe"
-
-	"github.com/kuzzleio/sdk-go/kuzzle"
-	"github.com/kuzzleio/sdk-go/security"
-	"github.com/kuzzleio/sdk-go/types"
-)
-
-// --- profile
-
-//export kuzzle_security_new_profile
-func kuzzle_security_new_profile(k *C.kuzzle, id *C.char, policies *C.policy, policies_length C.size_t) *C.profile {
-	cprofile := (*C.profile)(C.calloc(1, C.sizeof_profile))
-	cprofile.id = id
-	cprofile.policies = policies
-	cprofile.policies_length = policies_length
-	cprofile.k = k
-
-	return cprofile
-}
-
-//export kuzzle_security_destroy_profile
-func kuzzle_security_destroy_profile(p *C.profile) {
-	if p == nil {
-		return
-	}
-
-	if p.policies != nil {
-		size := int(p.policies_length)
-		policies := (*[1<<28 - 1]*C.policy)(unsafe.Pointer(p.policies))[:size:size]
-		for _, policy := range policies {
-			C.free(unsafe.Pointer(policy.role_id))
-			size = int(policy.restricted_to_length)
-			restrictions := (*[1<<28 - 1]*C.policy_restriction)(unsafe.Pointer(policy.restricted_to))[:size:size]
-			for _, restriction := range restrictions {
-				C.free(unsafe.Pointer(restriction.index))
-				size = int(restriction.collections_length)
-				collections := (*[1<<28 - 1]*C.char)(unsafe.Pointer(restriction.collections))[:size:size]
-				for _, collection := range collections {
-					C.free(unsafe.Pointer(collection))
-				}
-				C.free(unsafe.Pointer(restriction.collections))
-			}
-			C.free(unsafe.Pointer(policy.restricted_to))
-		}
-		C.free(unsafe.Pointer(p.policies))
-	}
-
-	C.free(unsafe.Pointer(p))
-}
-
-// --- user
-
-//export kuzzle_security_new_user
-func kuzzle_security_new_user(k *C.kuzzle, id *C.char, d *C.user_data) *C.kuzzle_user {
-	cuser := (*C.kuzzle_user)(C.calloc(1, C.sizeof_kuzzle_user))
-
-	cuser.id = id
-	cuser.k = k
-
-	if d != nil {
-		cuser.content = d.content
-		cuser.profile_ids = d.profile_ids
-		cuser.profile_ids_length = d.profile_ids_length
-	}
-
-	return cuser
-}
-
-//export kuzzle_security_destroy_user
-func kuzzle_security_destroy_user(u *C.kuzzle_user) {
-	if u == nil {
-		return
-	}
-
-	if u.id != nil {
-		C.free(unsafe.Pointer(u.id))
-	}
-	if u.content != nil {
-		C.free(unsafe.Pointer(u.content))
-	}
-	if u.profile_ids != nil {
-		size := int(u.profile_ids_length)
-		carray := (*[1<<28 - 1]*C.char)(unsafe.Pointer(u.profile_ids))[:size:size]
-
-		for i := 0; i < size; i++ {
-			C.free(unsafe.Pointer(carray[i]))
-		}
-		C.free(unsafe.Pointer(u.profile_ids))
-	}
-
-	C.free(unsafe.Pointer(u))
-}
-
-// --- role
-
-//export kuzzle_security_new_role
-func kuzzle_security_new_role(k *C.kuzzle, id *C.char, c C.controllers) *C.role {
-	crole := (*C.role)(C.calloc(1, C.sizeof_role))
-	crole.id = id
-	crole.controllers = C.CString(C.GoString(c))
-	crole.k = k
-
-	return crole
-}
-
-//export kuzzle_security_destroy_role
-func kuzzle_security_destroy_role(r *C.role) {
-	if r == nil {
-		return
-	}
-
-	C.free(unsafe.Pointer(r.controllers))
-	C.free(unsafe.Pointer(r))
-}
-
-//export kuzzle_security_get_profile
-func kuzzle_security_get_profile(k *C.kuzzle, id *C.char, o *C.query_options) *C.profile_result {
-	result := (*C.profile_result)(C.calloc(1, C.sizeof_profile_result))
-	options := SetQueryOptions(o)
-
-	profile, err := (*kuzzle.Kuzzle)(k.instance).Security.GetProfile(C.GoString(id), options)
-	if err != nil {
-		Set_profile_result_error(result, err)
-		return result
-	}
-
-	result.p = goToCProfile(k, profile, nil)
-
-	return result
-}
-
-//export kuzzle_security_get_profile_rights
-func kuzzle_security_get_profile_rights(k *C.kuzzle, id *C.char, o *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.GetProfileRights(C.GoString(id), SetQueryOptions(o))
-	var result string
-	json.Unmarshal(res, result)
-	return goToCStringResult(&result, err)
-}
-
-//export kuzzle_security_get_profile_mapping
-func kuzzle_security_get_profile_mapping(k *C.kuzzle, o *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.GetProfileMapping(SetQueryOptions(o))
-	var result string
-	json.Unmarshal(res, result)
-	return goToCStringResult(&result, err)
-}
-
-//export kuzzle_security_get_role
-func kuzzle_security_get_role(k *C.kuzzle, id *C.char, o *C.query_options) *C.role_result {
-	result := (*C.role_result)(C.calloc(1, C.sizeof_role_result))
-	options := SetQueryOptions(o)
-
-	role, err := (*kuzzle.Kuzzle)(k.instance).Security.GetRole(C.GoString(id), options)
-	if err != nil {
-		Set_role_result_error(result, err)
-		return result
-	}
-
-	result.r = goToCRole(k, role, nil)
-
-	return result
-}
-
-//export kuzzle_security_get_role_mapping
-func kuzzle_security_get_role_mapping(k *C.kuzzle, o *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.GetRoleMapping(SetQueryOptions(o))
-	var result string
-	json.Unmarshal(res, result)
-	return goToCStringResult(&result, err)
-}
-
-//export kuzzle_security_get_user
-func kuzzle_security_get_user(k *C.kuzzle, id *C.char, o *C.query_options) *C.user_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.GetUser(C.GoString(id), SetQueryOptions(o))
-	return goToCUserResult(k, res, err)
-}
-
-//export kuzzle_security_get_user_rights
-func kuzzle_security_get_user_rights(k *C.kuzzle, id *C.char, o *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.GetUserRights(C.GoString(id), SetQueryOptions(o))
-	var result string
-	json.Unmarshal(res, result)
-	return goToCStringResult(&result, err)
-}
-
-//export kuzzle_security_get_user_mapping
-func kuzzle_security_get_user_mapping(k *C.kuzzle, o *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.GetUserMapping(SetQueryOptions(o))
-	var result string
-	json.Unmarshal(res, result)
-	return goToCStringResult(&result, err)
-}
-
-//export kuzzle_security_get_credential_fields
-func kuzzle_security_get_credential_fields(k *C.kuzzle, strategy *C.char, o *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.GetCredentialFields(C.GoString(strategy), SetQueryOptions(o))
-	var result string
-	json.Unmarshal(res, result)
-	return goToCStringResult(&result, err)
-}
-
-//export kuzzle_security_get_all_credential_fields
-func kuzzle_security_get_all_credential_fields(k *C.kuzzle, o *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.GetAllCredentialFields(SetQueryOptions(o))
-	var result string
-	json.Unmarshal(res, result)
-	return goToCStringResult(&result, err)
-}
-
-//export kuzzle_security_get_credential
-func kuzzle_security_get_credential(k *C.kuzzle, strategy, id *C.char, o *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.GetCredentials(C.GoString(strategy), C.GoString(id), SetQueryOptions(o))
-	var result string
-	json.Unmarshal(res, result)
-	return goToCStringResult(&result, err)
-}
-
-//export kuzzle_security_get_credential_by_id
-func kuzzle_security_get_credential_by_id(k *C.kuzzle, strategy, id *C.char, o *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.GetCredentialsByID(C.GoString(strategy), C.GoString(id), SetQueryOptions(o))
-	var result string
-	json.Unmarshal(res, result)
-	return goToCStringResult(&result, err)
-}
-
-//export kuzzle_security_search_profiles
-func kuzzle_security_search_profiles(k *C.kuzzle, body *C.char, o *C.query_options) *C.search_profiles_result {
-	options := SetQueryOptions(o)
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.SearchProfiles(json.RawMessage(C.GoString(body)), options)
-
-	return goToCProfileSearchResult(k, res, err)
-}
-
-//export kuzzle_security_search_roles
-func kuzzle_security_search_roles(k *C.kuzzle, body *C.char, o *C.query_options) *C.search_roles_result {
-	options := SetQueryOptions(o)
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.SearchRoles(json.RawMessage(C.GoString(body)), options)
-
-	return goToCRoleSearchResult(k, res, err)
-}
-
-//export kuzzle_security_search_users
-func kuzzle_security_search_users(k *C.kuzzle, body *C.char, o *C.query_options) *C.search_users_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.SearchUsers(json.RawMessage(C.GoString(body)), SetQueryOptions(o))
-	return goToCUserSearchResult(k, res, err)
-}
-
-//export kuzzle_security_delete_role
-func kuzzle_security_delete_role(k *C.kuzzle, id *C.char, o *C.query_options) *C.string_result {
-	options := SetQueryOptions(o)
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.DeleteRole(C.GoString(id), options)
-	return goToCStringResult(&res, err)
-}
-
-//export kuzzle_security_delete_profile
-func kuzzle_security_delete_profile(k *C.kuzzle, id *C.char, o *C.query_options) *C.string_result {
-	options := SetQueryOptions(o)
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.DeleteProfile(C.GoString(id), options)
-	return goToCStringResult(&res, err)
-}
-
-//export kuzzle_security_delete_user
-func kuzzle_security_delete_user(k *C.kuzzle, id *C.char, o *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.DeleteUser(C.GoString(id), SetQueryOptions(o))
-	return goToCStringResult(&res, err)
-}
-
-//export kuzzle_security_delete_credentials
-func kuzzle_security_delete_credentials(k *C.kuzzle, strategy, id *C.char, o *C.query_options) *C.error_result {
-	err := (*kuzzle.Kuzzle)(k.instance).Security.DeleteCredentials(C.GoString(strategy), C.GoString(id), SetQueryOptions(o))
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_security_create_profile
-func kuzzle_security_create_profile(k *C.kuzzle, id, body *C.char, o *C.query_options) *C.profile_result {
-	options := SetQueryOptions(o)
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.CreateProfile(C.GoString(id), json.RawMessage(C.GoString(body)), options)
-
-	return goToCProfileResult(k, res, err)
-}
-
-//export kuzzle_security_create_role
-func kuzzle_security_create_role(k *C.kuzzle, id, body *C.char, o *C.query_options) *C.role_result {
-	result := (*C.role_result)(C.calloc(1, C.sizeof_role_result))
-	options := SetQueryOptions(o)
-
-	role, err := (*kuzzle.Kuzzle)(k.instance).Security.CreateRole(C.GoString(id), json.RawMessage(C.GoString(body)), options)
-	if err != nil {
-		Set_role_result_error(result, err)
-		return result
-	}
-
-	result.r = goToCRole(k, role, nil)
-
-	return result
-}
-
-//export kuzzle_security_create_user
-func kuzzle_security_create_user(k *C.kuzzle, body *C.char, o *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.CreateUser(json.RawMessage(C.GoString(body)), SetQueryOptions(o))
-	var result string
-	json.Unmarshal(res, result)
-	return goToCStringResult(&result, err)
-}
-
-//export kuzzle_security_create_credentials
-func kuzzle_security_create_credentials(k *C.kuzzle, cstrategy, id, body *C.char, o *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.CreateCredentials(C.GoString(cstrategy), C.GoString(id), json.RawMessage(C.GoString(body)), SetQueryOptions(o))
-	var result string
-	json.Unmarshal(res, result)
-	return goToCStringResult(&result, err)
-}
-
-//export kuzzle_security_create_restricted_user
-func kuzzle_security_create_restricted_user(k *C.kuzzle, body *C.char, o *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.CreateRestrictedUser(json.RawMessage(C.GoString(body)), SetQueryOptions(o))
-	var result string
-	json.Unmarshal(res, result)
-	return goToCStringResult(&result, err)
-}
-
-//export kuzzle_security_create_first_admin
-func kuzzle_security_create_first_admin(k *C.kuzzle, body *C.char, o *C.query_options) *C.string_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.CreateFirstAdmin(json.RawMessage(C.GoString(body)), SetQueryOptions(o))
-	var result string
-	json.Unmarshal(res, result)
-	return goToCStringResult(&result, err)
-}
-
-//export kuzzle_security_create_or_replace_profile
-func kuzzle_security_create_or_replace_profile(k *C.kuzzle, id, body *C.char, o *C.query_options) *C.profile_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.CreateOrReplaceProfile(C.GoString(id), json.RawMessage(C.GoString(body)), SetQueryOptions(o))
-	return goToCProfileResult(k, res, err)
-}
-
-//export kuzzle_security_create_or_replace_role
-func kuzzle_security_create_or_replace_role(k *C.kuzzle, id, body *C.char, o *C.query_options) *C.role_result {
-	result := (*C.role_result)(C.calloc(1, C.sizeof_role_result))
-	role, err := (*kuzzle.Kuzzle)(k.instance).Security.CreateOrReplaceRole(C.GoString(id), json.RawMessage(C.GoString(body)), SetQueryOptions(o))
-	if err != nil {
-		Set_role_result_error(result, err)
-		return result
-	}
-
-	result.r = goToCRole(k, role, nil)
-
-	return result
-}
-
-//export kuzzle_security_has_credentials
-func kuzzle_security_has_credentials(k *C.kuzzle, strategy *C.char, id *C.char, o *C.query_options) *C.bool_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.HasCredentials(C.GoString(strategy), C.GoString(id), SetQueryOptions(o))
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_security_replace_user
-func kuzzle_security_replace_user(k *C.kuzzle, id, content *C.char, o *C.query_options) *C.user_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.ReplaceUser(C.GoString(id), json.RawMessage(C.GoString(content)), SetQueryOptions(o))
-	return goToCUserResult(k, res, err)
-}
-
-//export kuzzle_security_update_credentials
-func kuzzle_security_update_credentials(k *C.kuzzle, strategy *C.char, id *C.char, body *C.char, o *C.query_options) *C.error_result {
-	err := (*kuzzle.Kuzzle)(k.instance).Security.UpdateCredentials(C.GoString(strategy), C.GoString(id), json.RawMessage(C.GoString(body)), SetQueryOptions(o))
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_security_update_profile
-func kuzzle_security_update_profile(k *C.kuzzle, id *C.char, body *C.char, o *C.query_options) *C.profile_result {
-	result := (*C.profile_result)(C.calloc(1, C.sizeof_profile_result))
-	options := SetQueryOptions(o)
-
-	profile, err := (*kuzzle.Kuzzle)(k.instance).Security.UpdateProfile(C.GoString(id), json.RawMessage(C.GoString(body)), options)
-	if err != nil {
-		Set_profile_result_error(result, err)
-		return result
-	}
-
-	result.p = goToCProfile(k, profile, nil)
-
-	return result
-}
-
-//export kuzzle_security_update_profile_mapping
-func kuzzle_security_update_profile_mapping(k *C.kuzzle, body *C.char, o *C.query_options) *C.error_result {
-	options := SetQueryOptions(o)
-	err := (*kuzzle.Kuzzle)(k.instance).Security.UpdateProfileMapping(json.RawMessage(C.GoString(body)), options)
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_security_update_role
-func kuzzle_security_update_role(k *C.kuzzle, id *C.char, body *C.char, o *C.query_options) *C.role_result {
-	result := (*C.role_result)(C.calloc(1, C.sizeof_role_result))
-	options := SetQueryOptions(o)
-
-	role, err := (*kuzzle.Kuzzle)(k.instance).Security.UpdateRole(C.GoString(id), json.RawMessage(C.GoString(body)), options)
-	if err != nil {
-		Set_role_result_error(result, err)
-		return result
-	}
-
-	result.r = goToCRole(k, role, nil)
-
-	return result
-}
-
-//export kuzzle_security_update_role_mapping
-func kuzzle_security_update_role_mapping(k *C.kuzzle, body *C.char, o *C.query_options) *C.error_result {
-	options := SetQueryOptions(o)
-	err := (*kuzzle.Kuzzle)(k.instance).Security.UpdateRoleMapping(json.RawMessage(C.GoString(body)), options)
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_security_update_user
-func kuzzle_security_update_user(k *C.kuzzle, id *C.char, body *C.char, o *C.query_options) *C.user_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.UpdateUser(C.GoString(id), json.RawMessage(C.GoString(body)), SetQueryOptions(o))
-	return goToCUserResult(k, res, err)
-}
-
-//export kuzzle_security_update_user_mapping
-func kuzzle_security_update_user_mapping(k *C.kuzzle, body *C.char, o *C.query_options) *C.error_result {
-	options := SetQueryOptions(o)
-	err := (*kuzzle.Kuzzle)(k.instance).Security.UpdateUserMapping(json.RawMessage(C.GoString(body)), options)
-	return goToCErrorResult(err)
-}
-
-//export kuzzle_security_is_action_allowed
-func kuzzle_security_is_action_allowed(crights **C.user_right, crlength C.uint, controller *C.char, action *C.char, index *C.char, collection *C.char) C.uint {
-	rights := make([]*types.UserRights, int(crlength))
-
-	carray := (*[1<<28 - 1]*C.user_right)(unsafe.Pointer(crights))[:int(crlength):int(crlength)]
-	for i := 0; i < int(crlength); i++ {
-		rights[i] = cToGoUserRigh(carray[i])
-	}
-
-	res := security.IsActionAllowed(rights, C.GoString(controller), C.GoString(action), C.GoString(index), C.GoString(collection))
-	return C.uint(res)
-}
-
-//export kuzzle_security_mdelete_credentials
-func kuzzle_security_mdelete_credentials(k *C.kuzzle, ids **C.char, idsSize C.size_t, o *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.MDeleteCredentials(cToGoStrings(ids, idsSize), SetQueryOptions(o))
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_security_mdelete_roles
-func kuzzle_security_mdelete_roles(k *C.kuzzle, ids **C.char, idsSize C.size_t, o *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.MDeleteRoles(cToGoStrings(ids, idsSize), SetQueryOptions(o))
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_security_mdelete_users
-func kuzzle_security_mdelete_users(k *C.kuzzle, ids **C.char, idsSize C.size_t, o *C.query_options) *C.string_array_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.MDeleteUsers(cToGoStrings(ids, idsSize), SetQueryOptions(o))
-	return goToCStringArrayResult(res, err)
-}
-
-//export kuzzle_security_mget_profiles
-func kuzzle_security_mget_profiles(k *C.kuzzle, ids **C.char, idsSize C.size_t, o *C.query_options) *C.profiles_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.MGetProfiles(cToGoStrings(ids, idsSize), SetQueryOptions(o))
-	return goToCProfilesResult(k, res, err)
-}
-
-//export kuzzle_security_mget_roles
-func kuzzle_security_mget_roles(k *C.kuzzle, ids **C.char, idsSize C.size_t, o *C.query_options) *C.roles_result {
-	res, err := (*kuzzle.Kuzzle)(k.instance).Security.MGetRoles(cToGoStrings(ids, idsSize), SetQueryOptions(o))
-	return goToCRolesResult(k, res, err)
-}
diff --git a/internal/wrappers/cgo/kuzzle/server.go b/internal/wrappers/cgo/kuzzle/server.go
deleted file mode 100644
index 95810352..00000000
--- a/internal/wrappers/cgo/kuzzle/server.go
+++ /dev/null
@@ -1,126 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-/*
-	#cgo CFLAGS: -I../../headers
-	#include <errno.h>
-	#include <stdlib.h>
-	#include "kuzzlesdk.h"
-	#include "sdk_wrappers_internal.h"
-*/
-import "C"
-import (
-	"strconv"
-	"sync"
-	"time"
-	"unsafe"
-
-	"github.com/kuzzleio/sdk-go/kuzzle"
-	"github.com/kuzzleio/sdk-go/server"
-)
-
-// map which stores instances to keep references in case the gc passes
-var serverInstances sync.Map
-
-//register new instance of server
-func registerServer(instance interface{}, ptr unsafe.Pointer) {
-	serverInstances.Store(instance, ptr)
-}
-
-// unregister an instance from the instances map
-//export unregisterServer
-func unregisterServer(s *C.server) {
-	serverInstances.Delete(s)
-}
-
-// Allocates memory
-//export kuzzle_new_server
-func kuzzle_new_server(s *C.server, k *C.kuzzle) {
-	kuz := (*kuzzle.Kuzzle)(k.instance)
-	server := server.NewServer(kuz)
-
-	ptr := unsafe.Pointer(server)
-	s.instance = ptr
-	s.k = k
-
-	registerServer(s, ptr)
-}
-
-//export kuzzle_admin_exists
-func kuzzle_admin_exists(s *C.server, options *C.query_options) *C.bool_result {
-	opts := SetQueryOptions(options)
-
-	res, err := (*server.Server)(s.instance).AdminExists(opts)
-	return goToCBoolResult(res, err)
-}
-
-//export kuzzle_get_all_stats
-func kuzzle_get_all_stats(s *C.server, options *C.query_options) *C.string_result {
-	opts := SetQueryOptions(options)
-
-	stats, err := (*server.Server)(s.instance).GetAllStats(opts)
-
-	str := string(stats)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_get_stats
-func kuzzle_get_stats(s *C.server, start_time C.time_t, stop_time C.time_t, options *C.query_options) *C.string_result {
-	opts := SetQueryOptions(options)
-
-	t, _ := strconv.ParseInt(C.GoString(C.ctime(&start_time)), 10, 64)
-	start := time.Unix(t, 0)
-	t, _ = strconv.ParseInt(C.GoString(C.ctime(&stop_time)), 10, 64)
-	stop := time.Unix(t, 0)
-
-	res, err := (*server.Server)(s.instance).GetStats(&start, &stop, opts)
-
-	str := string(res)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_get_last_stats
-func kuzzle_get_last_stats(s *C.server, options *C.query_options) *C.string_result {
-	opts := SetQueryOptions(options)
-
-	res, err := (*server.Server)(s.instance).GetLastStats(opts)
-
-	str := string(res)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_get_config
-func kuzzle_get_config(s *C.server, options *C.query_options) *C.string_result {
-	res, err := (*server.Server)(s.instance).GetConfig(SetQueryOptions(options))
-
-	str := string(res)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_info
-func kuzzle_info(s *C.server, options *C.query_options) *C.string_result {
-	res, err := (*server.Server)(s.instance).Info(SetQueryOptions(options))
-
-	str := string(res)
-	return goToCStringResult(&str, err)
-}
-
-//export kuzzle_now
-func kuzzle_now(s *C.server, options *C.query_options) *C.date_result {
-	time, err := (*server.Server)(s.instance).Now(SetQueryOptions(options))
-
-	return goToCDateResult(int(time), err)
-}
diff --git a/internal/wrappers/cpp/auth.cpp b/internal/wrappers/cpp/auth.cpp
deleted file mode 100644
index 8c520aea..00000000
--- a/internal/wrappers/cpp/auth.cpp
+++ /dev/null
@@ -1,159 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "kuzzle.hpp"
-#include "auth.hpp"
-
-namespace kuzzleio {
-  Auth::Auth(Kuzzle *kuzzle) {
-      _auth = new auth();
-      _kuzzle = kuzzle;
-      kuzzle_new_auth(_auth, kuzzle->_kuzzle);
-  }
-
-  Auth::Auth(Kuzzle *kuzzle, auth *auth) {
-    _auth = auth;
-    _kuzzle = kuzzle;
-    kuzzle_new_auth(_auth, kuzzle->_kuzzle);
-  }
-
-  Auth::~Auth() {
-      unregisterAuth(_auth);
-      delete(_auth);
-  }
-
-  token_validity* Auth::checkToken(const std::string& token) {
-    return kuzzle_check_token(_auth, const_cast<char*>(token.c_str()));
-  }
-
-  std::string Auth::createMyCredentials(const std::string& strategy, const std::string& credentials, query_options* options) {
-    string_result* r = kuzzle_create_my_credentials(_auth, const_cast<char*>(strategy.c_str()), const_cast<char*>(credentials.c_str()), options);
-    if (r->error)
-        throwExceptionFromStatus(r);
-    std::string ret = r->result;
-    delete(r);
-    return ret;
-  }
-
-  bool Auth::credentialsExist(const std::string& strategy, query_options *options) {
-    bool_result* r = kuzzle_credentials_exist(_auth, const_cast<char*>(strategy.c_str()), options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    bool ret = r->result;
-    delete(r);
-    return ret;
-  }
-
-  void Auth::deleteMyCredentials(const std::string& strategy, query_options *options) {
-    error_result *r = kuzzle_delete_my_credentials(_auth, const_cast<char*>(strategy.c_str()), options);
-    if (r != nullptr)
-        throwExceptionFromStatus(r);
-    delete(r);
-  }
-
-  kuzzle_user* Auth::getCurrentUser() {
-    user_result *r = kuzzle_get_current_user(_auth);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-
-    kuzzle_user *u = r->result;
-    kuzzle_free_user_result(r);
-    return u;
-  }
-
-  std::string Auth::getMyCredentials(const std::string& strategy, query_options *options) {
-    string_result *r = kuzzle_get_my_credentials(_auth, const_cast<char*>(strategy.c_str()), options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    std::string ret = r->result;
-    kuzzle_free_string_result(r);
-    return ret;
-  }
-
-  user_right* Auth::getMyRights(query_options* options) {
-    user_rights_result *r = kuzzle_get_my_rights(_auth, options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    user_right *ret = r->result;
-    kuzzle_free_user_rights_result(r);
-    return ret;
-  }
-
-  std::vector<std::string> Auth::getStrategies(query_options *options) {
-    string_array_result *r = kuzzle_get_strategies(_auth, options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-
-    std::vector<std::string> v;
-    for (int i = 0; r->result[i]; i++)
-        v.push_back(r->result[i]);
-
-    kuzzle_free_string_array_result(r);
-    return v;
-  }
-
-  std::string Auth::login(const std::string& strategy, const std::string& credentials) {
-    string_result* r = kuzzle_login(_auth, const_cast<char*>(strategy.c_str()), const_cast<char*>(credentials.c_str()), nullptr);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    std::string ret = r->result;
-    kuzzle_free_string_result(r);
-    return ret;
-  }
-
-  std::string Auth::login(const std::string& strategy, const std::string& credentials, int expires_in) {
-    string_result* r = kuzzle_login(_auth, const_cast<char*>(strategy.c_str()), const_cast<char*>(credentials.c_str()), &expires_in);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    std::string ret = r->result;
-    kuzzle_free_string_result(r);
-    return ret;
-  }
-
-  void Auth::logout() noexcept {
-    kuzzle_logout(_auth);
-  }
-
-  void Auth::setJwt(const std::string& jwt) noexcept {
-    kuzzle_set_jwt(_kuzzle->_kuzzle, const_cast<char*>(jwt.c_str()));
-  }
-
-  std::string Auth::updateMyCredentials(const std::string& strategy, const std::string& credentials, query_options *options) {
-    string_result *r = kuzzle_update_my_credentials(_auth, const_cast<char*>(strategy.c_str()), const_cast<char*>(credentials.c_str()), options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    std::string ret = r->result;
-    kuzzle_free_string_result(r);
-    return ret;
-  }
-
-  kuzzle_user* Auth::updateSelf(const std::string& content, query_options* options) {
-    user_result *r = kuzzle_update_self(_auth, const_cast<char*>(content.c_str()), options);
-    if (r->error != nullptr)
-      throwExceptionFromStatus(r);
-    kuzzle_user *ret = r->result;
-    kuzzle_free_user_result(r);
-    return ret;
-  }
-
-  bool Auth::validateMyCredentials(const std::string& strategy, const std::string& credentials, query_options* options) {
-    bool_result *r = kuzzle_validate_my_credentials(_auth, const_cast<char*>(strategy.c_str()), const_cast<char*>(credentials.c_str()), options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    bool ret = r->result;
-    kuzzle_free_bool_result(r);
-    return ret;
-  }
-
-}
diff --git a/internal/wrappers/cpp/collection.cpp b/internal/wrappers/cpp/collection.cpp
deleted file mode 100644
index 2156ca9b..00000000
--- a/internal/wrappers/cpp/collection.cpp
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "kuzzle.hpp"
-#include "collection.hpp"
-
-namespace kuzzleio {
-    Collection::Collection(Kuzzle* kuzzle) {
-        _collection = new collection();
-        kuzzle_new_collection(_collection, kuzzle->_kuzzle);
-    }
-
-    Collection::Collection(Kuzzle* kuzzle, collection *collection) {
-        _collection = collection;
-        kuzzle_new_collection(collection, kuzzle->_kuzzle);
-    }
-
-    Collection::~Collection() {
-        unregisterCollection(_collection);
-        delete(_collection);
-    }
-
-    void Collection::create(const std::string& index, const std::string& collection, const std::string* body, query_options *options) {
-        error_result *r = kuzzle_collection_create(
-            _collection,
-            const_cast<char*>(index.c_str()),
-            const_cast<char*>(collection.c_str()),
-            body != nullptr ? const_cast<char*>(body->c_str()) : nullptr,
-            options);
-
-        if (r != nullptr)
-            throwExceptionFromStatus(r);
-
-        kuzzle_free_error_result(r);
-    }
-
-    bool Collection::exists(const std::string& index, const std::string& collection, query_options *options) {
-        bool_result *r = kuzzle_collection_exists(_collection, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        bool ret = r->result;
-        kuzzle_free_bool_result(r);
-        return ret;
-    }
-
-    std::string Collection::list(const std::string& index, query_options *options) {
-        string_result *r = kuzzle_collection_list(_collection, const_cast<char*>(index.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        std::string ret = r->result;
-        kuzzle_free_string_result(r);
-        return ret;
-    }
-
-    void Collection::truncate(const std::string& index, const std::string& collection, query_options *options) {
-        error_result *r = kuzzle_collection_truncate(_collection, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), options);
-        if (r != nullptr)
-            throwExceptionFromStatus(r);
-
-        kuzzle_free_error_result(r);
-    }
-
-    std::string Collection::getMapping(const std::string& index, const std::string& collection, query_options *options) {
-        string_result *r = kuzzle_collection_get_mapping(_collection, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        std::string ret = r->result;
-        kuzzle_free_string_result(r);
-
-        return ret;
-    }
-
-    void Collection::updateMapping(const std::string& index, const std::string& collection, const std::string& body, query_options *options) {
-        error_result *r = kuzzle_collection_update_mapping(_collection, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(body.c_str()), options);
-        if (r != nullptr)
-            throwExceptionFromStatus(r);
-
-        kuzzle_free_error_result(r);
-    }
-
-    std::string Collection::getSpecifications(const std::string& index, const std::string& collection, query_options *options) {
-        string_result *r = kuzzle_collection_get_specifications(_collection, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        std::string ret = r->result;
-        kuzzle_free_string_result(r);
-
-        return ret;
-    }
-
-    search_result* Collection::searchSpecifications(query_options *options) {
-        search_result *r = kuzzle_collection_search_specifications(_collection, options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        search_result *ret = r;
-        kuzzle_free_search_result(r);
-
-        return ret;
-    }
-
-    std::string Collection::updateSpecifications(const std::string& index, const std::string& collection, const std::string& body, query_options *options) {
-        string_result *r = kuzzle_collection_update_specifications(_collection, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(body.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-        std::string ret = r->result;
-        kuzzle_free_string_result(r);
-
-        return ret;
-    }
-
-    bool Collection::validateSpecifications(const std::string& body, query_options *options) {
-        bool_result *r = kuzzle_collection_validate_specifications(_collection, const_cast<char*>(body.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        bool ret = r->result;
-        kuzzle_free_bool_result(r);
-
-        return ret;
-    }
-
-    void Collection::deleteSpecifications(const std::string& index, const std::string& collection, query_options *options) {
-        error_result *r = kuzzle_collection_delete_specifications(_collection, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), options);
-        if (r != nullptr)
-            throwExceptionFromStatus(r);
-
-        kuzzle_free_error_result(r);
-    }
-}
diff --git a/internal/wrappers/cpp/document.cpp b/internal/wrappers/cpp/document.cpp
deleted file mode 100644
index 440018c2..00000000
--- a/internal/wrappers/cpp/document.cpp
+++ /dev/null
@@ -1,224 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "kuzzle.hpp"
-#include "document.hpp"
-
-namespace kuzzleio {
-    Document::Document(Kuzzle* kuzzle) {
-        _document = new document();
-        kuzzle_new_document(_document, kuzzle->_kuzzle);
-    }
-
-    Document::Document(Kuzzle* kuzzle, document *document) {
-        _document = document;
-        kuzzle_new_document(_document, kuzzle->_kuzzle);
-    }
-
-    Document::~Document() {
-        unregisterDocument(_document);
-        delete(_document);
-    }
-
-    int Document::count(const std::string& index, const std::string& collection, const std::string& body, query_options *options) {
-      int_result *r = kuzzle_document_count(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(body.c_str()), options);
-      if (r->error != nullptr)
-          throwExceptionFromStatus(r);
-      int ret = r->result;
-      kuzzle_free_int_result(r);
-      return ret;
-    }
-
-    bool Document::exists(const std::string& index, const std::string& collection, const std::string& id, query_options *options) {
-        bool_result *r = kuzzle_document_exists(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(id.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        bool ret = r->result;
-        kuzzle_free_bool_result(r);
-        return ret;
-    }
-
-    std::string Document::create(const std::string& index, const std::string& collection, const std::string& id, const std::string& body, query_options *options) {
-        string_result *r = kuzzle_document_create(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(id.c_str()), const_cast<char*>(body.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        std::string ret = r->result;
-        kuzzle_free_string_result(r);
-        return ret;
-    }
-
-    std::string Document::createOrReplace(const std::string& index, const std::string& collection, const std::string& id, const std::string& body, query_options *options) {
-        string_result *r = kuzzle_document_create_or_replace(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(id.c_str()), const_cast<char*>(body.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        std::string ret = r->result;
-        kuzzle_free_string_result(r);
-        return ret;
-    }
-
-    std::string Document::delete_(const std::string& index, const std::string& collection, const std::string& id, query_options *options) {
-        string_result *r = kuzzle_document_delete(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(id.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        std::string ret = r->result;
-        kuzzle_free_string_result(r);
-        return ret;
-    }
-
-    std::vector<std::string> Document::deleteByQuery(const std::string& index, const std::string& collection, const std::string& body, query_options *options) {
-        string_array_result *r = kuzzle_document_delete_by_query(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(body.c_str()), options);
-
-        if (r->error != nullptr)
-          throwExceptionFromStatus(r);
-
-        std::vector<std::string> v;
-        for (int i = 0; i < r->result_length; i++)
-          v.push_back(r->result[i]);
-
-        kuzzle_free_string_array_result(r);
-        return v;
-    }
-
-    std::string Document::get(const std::string& index, const std::string& collection, const std::string& id, query_options *options) {
-        string_result *r = kuzzle_document_get(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(id.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        std::string ret = r->result;
-        kuzzle_free_string_result(r);
-        return ret;
-    }
-
-    std::string Document::replace(const std::string& index, const std::string& collection, const std::string& id, const std::string& body, query_options *options) {
-        string_result *r = kuzzle_document_replace(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(id.c_str()), const_cast<char*>(body.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        std::string ret = r->result;
-        kuzzle_free_string_result(r);
-        return ret;
-    }
-
-    std::string Document::update(const std::string& index, const std::string& collection, const std::string& id, const std::string& body, query_options *options) {
-        string_result *r = kuzzle_document_update(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(id.c_str()), const_cast<char*>(body.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        std::string ret = r->result;
-        kuzzle_free_string_result(r);
-        return ret;
-    }
-
-    bool Document::validate(const std::string& index, const std::string& collection, const std::string& body, query_options *options) {
-        bool_result *r = kuzzle_document_validate(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(body.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        bool ret = r->result;
-        kuzzle_free_bool_result(r);
-        return ret;
-    }
-
-    search_result* Document::search(const std::string& index, const std::string& collection, const std::string& body, query_options *options) {
-        search_result *r = kuzzle_document_search(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(body.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        return r;
-    }
-
-    std::string Document::mCreate(const std::string& index, const std::string& collection, const std::string& body, query_options *options) {
-        string_result *r = kuzzle_document_mcreate(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(body.c_str()), options);
-        if (r->error != nullptr)
-          throwExceptionFromStatus(r);
-
-        std::string ret = r->result;
-        kuzzle_free_string_result(r);
-        return ret;
-    }
-
-    std::string Document::mCreateOrReplace(const std::string& index, const std::string& collection, const std::string& body, query_options *options) {
-        string_result *r = kuzzle_document_mcreate_or_replace(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(body.c_str()), options);
-        if (r->error != nullptr)
-          throwExceptionFromStatus(r);
-
-        std::string ret = r->result;
-        kuzzle_free_string_result(r);
-        return ret;
-    }
-
-    std::vector<std::string> Document::mDelete(const std::string& index, const std::string& collection, const std::vector<std::string>& ids, query_options *options) {
-        char **idsArray = new char *[ids.size()];
-        int i = 0;
-        for (auto& id : ids) {
-          idsArray[i] = const_cast<char*>(id.c_str());
-          i++;
-        }
-
-        string_array_result *r = kuzzle_document_mdelete(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), idsArray, ids.size(), options);
-        delete[] idsArray;
-        if (r->error != nullptr)
-          throwExceptionFromStatus(r);
-
-        std::vector<std::string> v;
-        for (int i = 0; i < r->result_length; i++)
-          v.push_back(r->result[i]);
-
-        kuzzle_free_string_array_result(r);
-        return v;
-    }
-
-    std::string Document::mGet(const std::string& index, const std::string& collection, const std::vector<std::string>& ids, bool includeTrash, query_options *options) {
-        char **idsArray = new char *[ids.size()];
-        int i = 0;
-        for (auto& id : ids) {
-          idsArray[i] = const_cast<char*>(id.c_str());
-          i++;
-        }
-
-        string_result *r = kuzzle_document_mget(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), idsArray, ids.size(), includeTrash, options);
-        delete[] idsArray;
-        if (r->error != nullptr)
-          throwExceptionFromStatus(r);
-
-        std::string ret = r->result;
-        kuzzle_free_string_result(r);
-        return ret;
-
-    }
-    std::string Document::mReplace(const std::string& index, const std::string& collection, const std::string& body, query_options *options) {
-        string_result *r = kuzzle_document_mreplace(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(body.c_str()), options);
-        if (r->error != nullptr)
-          throwExceptionFromStatus(r);
-
-        std::string ret = r->result;
-        kuzzle_free_string_result(r);
-        return ret;
-    }
-
-    std::string Document::mUpdate(const std::string& index, const std::string& collection, const std::string& body, query_options *options) {
-        string_result *r = kuzzle_document_mupdate(_document, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(body.c_str()), options);
-        if (r->error != nullptr)
-          throwExceptionFromStatus(r);
-
-        std::string ret = r->result;
-        kuzzle_free_string_result(r);
-        return ret;
-    }
-
-}
diff --git a/internal/wrappers/cpp/index.cpp b/internal/wrappers/cpp/index.cpp
deleted file mode 100644
index cd20c99f..00000000
--- a/internal/wrappers/cpp/index.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "kuzzle.hpp"
-#include "index.hpp"
-#include <string>
-
-namespace kuzzleio {
-
-    Index::Index(Kuzzle* kuzzle) {
-        _index = new kuzzle_index();
-        kuzzle_new_index(_index, kuzzle->_kuzzle);
-    }
-
-    Index::Index(Kuzzle* kuzzle, kuzzle_index *index) {
-      _index = index;
-      kuzzle_new_index(index, kuzzle->_kuzzle);
-    }
-
-    Index::~Index() {
-        unregisterIndex(_index);
-        delete(_index);
-    }
-
-    void Index::create(const std::string& index, query_options *options) {
-        error_result *r = kuzzle_index_create(_index, const_cast<char*>(index.c_str()), options);
-        if (r != nullptr)
-            throwExceptionFromStatus(r);
-        kuzzle_free_error_result(r);
-    }
-
-    void Index::delete_(const std::string& index, query_options *options) {
-        error_result *r = kuzzle_index_delete(_index, const_cast<char*>(index.c_str()), options);
-        if (r != nullptr)
-            throwExceptionFromStatus(r);
-        kuzzle_free_error_result(r);
-    }
-
-    std::vector<std::string> Index::mDelete(const std::vector<std::string>& indexes, query_options *options) {
-        char **indexesArray = new char *[indexes.size()];
-        int i = 0;
-        for (auto& index : indexes) {
-          indexesArray[i] = const_cast<char*>(index.c_str());
-          i++;
-        }
-        string_array_result *r = kuzzle_index_mdelete(_index, indexesArray, indexes.size(), options);
-
-        delete[] indexesArray;
-        if (r->error != nullptr)
-          throwExceptionFromStatus(r);
-
-        std::vector<std::string> v;
-        for (int i = 0; i < r->result_length; i++)
-          v.push_back(r->result[i]);
-
-        kuzzle_free_string_array_result(r);
-        return v;
-    }
-
-    bool Index::exists(const std::string& index, query_options *options) {
-        bool_result *r = kuzzle_index_exists(_index, const_cast<char*>(index.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-        bool ret = r->result;
-        kuzzle_free_bool_result(r);
-        return ret;
-    }
-
-    void Index::refresh(const std::string& index, query_options *options) {
-        error_result *r = kuzzle_index_refresh(_index, const_cast<char*>(index.c_str()), options);
-        if (r != nullptr)
-            throwExceptionFromStatus(r);
-        kuzzle_free_error_result(r);
-    }
-
-    void Index::refreshInternal(query_options *options) {
-        error_result *r = kuzzle_index_refresh_internal(_index, options);
-        if (r != nullptr)
-            throwExceptionFromStatus(r);
-        kuzzle_free_error_result(r);
-    }
-
-    void Index::setAutoRefresh(const std::string& index, bool autoRefresh, query_options *options) {
-      error_result *r = kuzzle_index_set_auto_refresh(_index, const_cast<char*>(index.c_str()), autoRefresh, options);
-      if (r != nullptr)
-          throwExceptionFromStatus(r);
-        kuzzle_free_error_result(r);
-    }
-
-    bool Index::getAutoRefresh(const std::string& index, query_options *options) {
-        bool_result *r = kuzzle_index_get_auto_refresh(_index, const_cast<char*>(index.c_str()), options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-        bool ret = r->result;
-        kuzzle_free_bool_result(r);
-        return ret;
-    }
-
-    std::vector<std::string> Index::list(query_options *options) {
-        string_array_result *r = kuzzle_index_list(_index, options);
-        if (r->error != nullptr)
-            throwExceptionFromStatus(r);
-
-        std::vector<std::string> v;
-        for (int i = 0; i < r->result_length; i++)
-          v.push_back(r->result[i]);
-
-        kuzzle_free_string_array_result(r);
-        return v;
-    }
-}
diff --git a/internal/wrappers/cpp/kuzzle.cpp b/internal/wrappers/cpp/kuzzle.cpp
deleted file mode 100644
index 3345b38f..00000000
--- a/internal/wrappers/cpp/kuzzle.cpp
+++ /dev/null
@@ -1,155 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <exception>
-#include <stdexcept>
-#include "kuzzle.hpp"
-#include "auth.hpp"
-#include "index.hpp"
-#include "server.hpp"
-#include "collection.hpp"
-#include "document.hpp"
-#include "realtime.hpp"
-#include <iostream>
-#include <vector>
-
-namespace kuzzleio {
-
-  KuzzleException::KuzzleException(int status, const std::string& error)
-    : std::runtime_error(error), status(status) {}
-
-  std::string KuzzleException::getMessage() const {
-    return what();
-  }
-
-  Kuzzle::Kuzzle(const std::string& host, options *opts) {
-    this->_kuzzle = new kuzzle();
-    kuzzle_new_kuzzle(this->_kuzzle, const_cast<char*>(host.c_str()), (char*)"websocket", opts);
-
-    this->document = new Document(this, kuzzle_get_document_controller(_kuzzle));
-    this->auth = new Auth(this, kuzzle_get_auth_controller(_kuzzle));
-    this->index = new Index(this, kuzzle_get_index_controller(_kuzzle));
-    this->server = new Server(this, kuzzle_get_server_controller(_kuzzle));
-    this->collection = new Collection(this, kuzzle_get_collection_controller(_kuzzle));
-    this->realtime = new Realtime(this, kuzzle_get_realtime_controller(_kuzzle));
-  }
-
-  Kuzzle::~Kuzzle() {
-    unregisterKuzzle(this->_kuzzle);
-    delete(this->_kuzzle);
-    delete(this->document);
-    delete(this->auth);
-    delete(this->index);
-    delete(this->server);
-    delete(this->collection);
-    delete(this->realtime);
-  }
-
-  char* Kuzzle::connect() noexcept {
-    return kuzzle_connect(_kuzzle);
-  }
-
-  void Kuzzle::disconnect() noexcept {
-    kuzzle_disconnect(_kuzzle);
-  }
-
-  kuzzle_response* Kuzzle::query(kuzzle_request* query, query_options* options) {
-    kuzzle_response *r = kuzzle_query(_kuzzle, query, options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    return r;
-  }
-
-  Kuzzle* Kuzzle::playQueue() noexcept {
-    kuzzle_play_queue(_kuzzle);
-    return this;
-  }
-
-  Kuzzle* Kuzzle::setAutoReplay(bool autoReplay) noexcept {
-    kuzzle_set_auto_replay(_kuzzle, autoReplay);
-    return this;
-  }
-
-  Kuzzle* Kuzzle::startQueuing() noexcept {
-    kuzzle_start_queuing(_kuzzle);
-    return this;
-  }
-
-  Kuzzle* Kuzzle::stopQueuing() noexcept {
-    kuzzle_stop_queuing(_kuzzle);
-    return this;
-  }
-
-  Kuzzle* Kuzzle::flushQueue() noexcept {
-    kuzzle_flush_queue(_kuzzle);
-    return this;
-  }
-
-  Kuzzle* Kuzzle::setVolatile(const std::string& volatiles) noexcept {
-    kuzzle_set_volatile(_kuzzle, const_cast<char*>(volatiles.c_str()));
-    return this;
-  }
-
-  std::string Kuzzle::getVolatile() noexcept {
-    return std::string(kuzzle_get_volatile(_kuzzle));
-  }
-
-  std::string Kuzzle::getJwt() noexcept {
-    return std::string(kuzzle_get_jwt(_kuzzle));
-  }
-
-  void trigger_event_listener(int event, char* res, void* data) {
-    EventListener* listener = static_cast<Kuzzle*>(data)->getListeners()[event];
-    if (listener) {
-      (*listener)(res);
-    }
-  }
-
-  std::map<int, EventListener*> Kuzzle::getListeners() noexcept {
-    return _listener_instances;
-  }
-
-  void Kuzzle::emitEvent(Event& event, const std::string& body) noexcept {
-    kuzzle_emit_event(_kuzzle, event, const_cast<char*>(body.c_str()));
-  }
-
-  KuzzleEventEmitter* Kuzzle::addListener(Event event, EventListener* listener) {
-    kuzzle_add_listener(_kuzzle, event, &trigger_event_listener, this);
-    _listener_instances[event] = listener;
-
-    return this;
-  }
-
-  KuzzleEventEmitter* Kuzzle::removeListener(Event event, EventListener* listener) {
-    kuzzle_remove_listener(_kuzzle, event, (void*)&trigger_event_listener);
-    _listener_instances[event] = nullptr;
-
-    return this;
-  }
-
-  KuzzleEventEmitter* Kuzzle::removeAllListeners(Event event) {
-    kuzzle_remove_all_listeners(_kuzzle, event);
-
-    return this;
-  }
-
-  KuzzleEventEmitter* Kuzzle::once(Event event, EventListener* listener) {
-    kuzzle_once(_kuzzle, event, &trigger_event_listener, this);
-  }
-
-  int Kuzzle::listenerCount(Event event) {
-    return kuzzle_listener_count(_kuzzle, event);
-  }
-
-}
diff --git a/internal/wrappers/cpp/realtime.cpp b/internal/wrappers/cpp/realtime.cpp
deleted file mode 100644
index d4f71ac5..00000000
--- a/internal/wrappers/cpp/realtime.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#include "kuzzle.hpp"
-#include "realtime.hpp"
-
-namespace kuzzleio {
-  Realtime::Realtime(Kuzzle *kuzzle) {
-    _realtime = new realtime();
-    kuzzle_new_realtime(_realtime, kuzzle->_kuzzle);
-  }
-
-  Realtime::Realtime(Kuzzle *kuzzle, realtime *realtime) {
-    _realtime = realtime;
-    kuzzle_new_realtime(_realtime, kuzzle->_kuzzle);
-  }
-
-  Realtime::~Realtime() {
-    unregisterRealtime(_realtime);
-    delete(_realtime);
-  }
-
-  int Realtime::count(const std::string& index, const std::string& collection, const std::string& roomId, query_options *options) {
-    int_result *r = kuzzle_realtime_count(_realtime, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(roomId.c_str()), options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    int ret = r->result;
-    kuzzle_free_int_result(r);
-    return ret;
-  }
-
-  NotificationListener* Realtime::getListener(const std::string& roomId) {
-    return _listener_instances[roomId];
-  }
-
-  void call_subscribe_cb(notification_result* res, void* data) {
-    if (data) {
-      NotificationListener* listener = static_cast<Realtime*>(data)->getListener(res->room_id);
-
-      if (listener) {
-        (*listener)(res);
-      }
-    }
-  }
-
-  std::string Realtime::list(const std::string& index, const std::string& collection, query_options *options) {
-    string_result *r = kuzzle_realtime_list(_realtime, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    std::string ret = r->result;
-    kuzzle_free_string_result(r);
-    return ret;
-  }
-
-  void Realtime::publish(const std::string& index, const std::string& collection, const std::string& body, query_options *options) {
-    error_result *r = kuzzle_realtime_publish(_realtime, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()), const_cast<char*>(body.c_str()), options);
-    if (r != nullptr)
-        throwExceptionFromStatus(r);
-    kuzzle_free_error_result(r);
-  }
-
-  std::string Realtime::subscribe(const std::string& index, const std::string& collection, const std::string& body, NotificationListener* cb, room_options* options) {
-    subscribe_result *r = kuzzle_realtime_subscribe(_realtime, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()),  const_cast<char*>(body.c_str()), call_subscribe_cb, this, options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-
-    std::string roomId = r->room;
-    std::string channel = r->channel;
-
-    _listener_instances[channel] = cb;
-    kuzzle_free_subscribe_result(r);
-    return roomId;
-  }
-
-  void Realtime::unsubscribe(const std::string& roomId, query_options *options) {
-    error_result *r = kuzzle_realtime_unsubscribe(_realtime, const_cast<char*>(roomId.c_str()), options);
-    if (r != nullptr)
-        throwExceptionFromStatus(r);
-
-    _listener_instances[roomId] = nullptr;
-    kuzzle_free_error_result(r);
-  }
-
-  bool Realtime::validate(const std::string& index, const std::string& collection, const std::string& body, query_options *options) {
-    bool_result *r = kuzzle_realtime_validate(_realtime, const_cast<char*>(index.c_str()), const_cast<char*>(collection.c_str()),  const_cast<char*>(body.c_str()), options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    bool ret = r->result;
-    kuzzle_free_bool_result(r);
-    return ret;
-  }
-}
diff --git a/internal/wrappers/cpp/server.cpp b/internal/wrappers/cpp/server.cpp
deleted file mode 100644
index b3ed158b..00000000
--- a/internal/wrappers/cpp/server.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "kuzzle.hpp"
-#include "server.hpp"
-
-namespace kuzzleio {
-  Server::Server(Kuzzle* kuzzle) {
-      _server = new server();
-      kuzzle_new_server(_server, kuzzle->_kuzzle);
-  }
-
-  Server::Server(Kuzzle* kuzzle, server *server) {
-      _server = server;
-      kuzzle_new_server(_server, kuzzle->_kuzzle);
-  }
-
-  Server::~Server() {
-      unregisterServer(_server);
-      delete(_server);
-  }
-
-  bool Server::adminExists(query_options *options) {
-    bool_result* r = kuzzle_admin_exists(_server, options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    bool ret = r->result;
-    delete(r);
-    return ret;
-  }
-
-  std::string Server::getAllStats(query_options* options) {
-    string_result* r = kuzzle_get_all_stats(_server, options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    std::string ret = r->result;
-    delete(r);
-    return ret;
-  }
-
-  std::string Server::getStats(time_t start, time_t end, query_options* options) {
-    string_result* r = kuzzle_get_stats(_server, start, end, options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    std::string ret = r->result;
-    delete(r);
-    return ret;
-  }
-
-  std::string Server::getLastStats(query_options* options) {
-    string_result* r = kuzzle_get_last_stats(_server, options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    std::string ret = r->result;
-    delete(r);
-    return ret;
-  }
-
-  std::string Server::getConfig(query_options* options) {
-    string_result* r = kuzzle_get_config(_server, options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    std::string ret = r->result;
-    delete(r);
-    return ret;
-  }
-
-  std::string Server::info(query_options* options) {
-    string_result* r = kuzzle_info(_server, options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    std::string ret = r->result;
-    delete(r);
-    return ret;
-  }
-
-  // java wrapper for this method is in typemap.i
-  long long Server::now(query_options* options) {
-    date_result *r = kuzzle_now(_server, options);
-    if (r->error != nullptr)
-        throwExceptionFromStatus(r);
-    long long ret = r->result;
-    delete(r);
-    return ret;
-  }
-
-}
diff --git a/internal/wrappers/features/auth.feature b/internal/wrappers/features/auth.feature
deleted file mode 100644
index 116cce89..00000000
--- a/internal/wrappers/features/auth.feature
+++ /dev/null
@@ -1,35 +0,0 @@
-Feature: User management
-
-  Scenario Outline: Get a valid JWT when login
-    Given Kuzzle Server is running
-    And there is an user with id 'my-user-id'
-    And the user has 'local' credentials with name 'my-user-name' and password 'my-user-pwd'
-    When I log in as <user-name>:<user-pwd>
-    Then the JWT is <jwt_validity>
-    Examples:
-      | user-name        | user-pwd        | jwt_validity |
-      | 'my-user-name'   | 'my-user-pwd'   | valid        |
-      | 'my-user-name-w' | 'my-user-pwd'   | invalid      |
-      | 'my-user-name'   | 'my-user-pwd-w' | invalid      |
-      | 'my-user-name-w' | 'my-user-pwd-w' | invalid      |
-
-  Scenario Outline: Set user custom data (updateSelf)
-    Given Kuzzle Server is running
-    And there is an user with id 'my-user-id'
-    And the user has 'local' credentials with name 'my-user-name' and password 'my-user-pwd'
-    And I log in as 'my-user-name':'my-user-pwd'
-    And I update my user custom data with the pair <field-name>:<field-value>
-    When I get my user info
-    Then the response '_source' field contains the pair <field-name>:<field-value>
-    Examples:
-      | field-name | field-value |
-      | 'my_data' | 'mystringvalue' |
-
-  Scenario: Login out shall revoke the JWT
-    Given Kuzzle Server is running
-    And there is an user with id 'my-user-id'
-    And the user has 'local' credentials with name 'my-user-name' and password 'my-user-pwd'
-    And I log in as 'my-user-name':'my-user-pwd'
-    And the JWT is valid
-    When I logout
-    Then the JWT is invalid
diff --git a/internal/wrappers/features/collection.feature b/internal/wrappers/features/collection.feature
deleted file mode 100644
index 96594688..00000000
--- a/internal/wrappers/features/collection.feature
+++ /dev/null
@@ -1,68 +0,0 @@
-Feature: Collection management
-
-  Scenario: Create a collection
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    When I create a collection 'collection-test-collection'
-    Then the collection 'collection-test-collection' should exist
-
-  Scenario: Check if a collection exists
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    When I check if the collection 'test-collection' exists
-    Then the collection should exist
-
-  Scenario: List existing collections
-    Given Kuzzle Server is running
-    And there is an index 'list-test-index'
-    And it has a collection 'test-collection1'
-    And it has a collection 'test-collection2'
-    When I list the collections of 'list-test-index'
-    Then the result contains 2 hits
-    And the content should not be null
-
-  Scenario: Truncate a collection
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    And the collection has a document with id 'my-document-id'
-    And the collection has a document with id 'my-document-id2'
-    When I truncate the collection 'test-collection'
-    Then the collection 'test-collection' should be empty
-
-  Scenario: Create a collection with a custom mapping
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    When I create a collection 'test-create-with-mapping' with a mapping
-    Then the collection 'test-create-with-mapping' should exist
-    And the mapping of 'test-create-with-mapping' should be updated
-
-  Scenario: Update a collection with a custom mapping
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    When I update the mapping of collection 'test-collection'
-    Then the mapping of 'test-collection' should be updated
-
-  Scenario: Update specifications
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    When I update the specifications of the collection 'test-collection'
-    Then the specifications of 'test-collection' should be updated
-
-  Scenario: Validate specifications
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    When I validate the specifications of 'test-collection'
-    Then they should be validated
-
-  Scenario: Delete specifications
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    And has specifications
-    When I delete the specifications of 'test-collection'
-    Then the specifications of 'test-collection' must not exist
diff --git a/internal/wrappers/features/documents.feature b/internal/wrappers/features/documents.feature
deleted file mode 100644
index 6baefc6c..00000000
--- a/internal/wrappers/features/documents.feature
+++ /dev/null
@@ -1,206 +0,0 @@
-Feature: Document management
-
-  Scenario: Do not allow creating a document with an _id that already exist in the same collection
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    And the collection has a document with id 'my-document-id'
-    When I create a document with id 'my-document-id'
-    Then I get an error with message 'Document already exists'
-
-  Scenario: Create a document with create
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    And the collection doesn't have a document with id 'my-document-id'
-    When I create a document with id 'my-document-id'
-    Then the document is successfully created
-
-  Scenario: Create a document with createOrReplace if it does not exists
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    And the collection doesn't have a document with id 'my-document-id'
-    When I createOrReplace a document with id 'my-document-id'
-    Then the document is successfully created
-
-  Scenario: Replace a document if it exists
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    When I createOrReplace a document with id 'my-document-id'
-    Then the document is successfully replaced
-
-  Scenario: Replace a document
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    And the collection has a document with id 'replace-my-document-id'
-    When I replace a document with id 'replace-my-document-id'
-    Then the document is successfully replaced
-
-  Scenario: Delete a document
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    And the collection has a document with id 'delete-my-document-id'
-    When I delete the document with id 'delete-my-document-id'
-    Then the document is successfully deleted
-
-  Scenario: Update a document
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    And the collection has a document with id 'update-my-document-id'
-    When I update a document with id 'update-my-document-id'
-    Then the document is successfully updated
-
-  Scenario: Search a document by id and find it
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    And the collection has a document with id 'search-my-document-id'
-    When I search a document with id 'search-my-document-id'
-    Then the document is successfully found
-
-  Scenario: Search a document by id and don't find it
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    And the collection has a document with id 'search-my-document-id'
-    When I search a document with id 'fake-id'
-    Then the document is not found
-
-  Scenario: Count documents in a collection
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'count-test-collection'
-    And the collection has a document with id 'count-my-document-id'
-    And the collection has a document with id 'count-my-document-id2'
-    And the collection has a document with id 'count-my-document-id3'
-    When I count how many documents there is in the collection
-    Then I shall receive 3
-
-  Scenario: Delete multiple documents with no error
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'delete-test-collection'
-    And the collection has a document with id 'mdelete-my-document-id'
-    And the collection has a document with id 'mdelete-my-document-id2'
-    When I delete the documents ['mdelete-my-document-id', 'mdelete-my-document-id2']
-    Then I must have 0 documents in the collection
-
-  Scenario: Delete multiple documents with partial error
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'mdelete-test-collection'
-    And the collection has a document with id 'mdelete-my-document-id'
-    And the collection has a document with id 'mdelete-my-document-id2'
-    When I delete the documents ['mdelete-my-document-id', 'mdelete-my-document-unknown']
-    Then I must have 1 documents in the collection
-    And I get a partial error
-
-  Scenario: Create multiple documents with no error
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'mcreate-test-collection'
-    And the collection doesn't have a document with id 'mcreate-my-document-id'
-    And the collection doesn't have a document with id 'mcreate-my-document-id2'
-    When I create the documents ['mcreate-my-document-id', 'mcreate-my-document-id2']
-    Then I must have 2 documents in the collection
-    And I should have no partial error
-
-  Scenario: Create multiple documents with partial error
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'mcreate-test-collection'
-    When I create the documents ['mcreate-my-document-id', 'mcreate-my-document-id2']
-    Then I must have 2 documents in the collection
-    And I get a partial error
-
-  Scenario: Replace multiple documents with no error
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'mreplace-test-collection'
-    And the collection has a document with id 'mreplace-my-document-id'
-    And the collection has a document with id 'mreplace-my-document-id2'
-    When I replace the documents ['mreplace-my-document-id', 'mreplace-my-document-id2']
-    Then I should have no partial error
-    And the document 'mreplace-my-document-id' should be replaced
-    And the document 'mreplace-my-document-id2' should be replaced
-
-  Scenario: Replace multiple documents with partial error
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'mreplace-test-collection'
-    And the collection has a document with id 'mreplace-my-document-id'
-    And the collection has a document with id 'mreplace-my-document-id2'
-    When I replace the documents ['unknown', 'mreplace-my-document-id2']
-    And the document 'mreplace-my-document-id2' should be replaced
-    And I get a partial error
-
-  Scenario: Update multiple documents with no error
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'mreplace-test-collection'
-    And the collection has a document with id 'mreplace-my-document-id'
-    And the collection has a document with id 'mreplace-my-document-id2'
-    When I update the documents ['mreplace-my-document-id', 'mreplace-my-document-id2']
-    Then I should have no partial error
-    And the document 'mreplace-my-document-id' should be replaced
-    And the document 'mreplace-my-document-id2' should be replaced
-
-  Scenario: Update multiple documents with partial error
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'mupdate-test-collection'
-    And the collection has a document with id 'mupdate-my-document-id'
-    And the collection has a document with id 'mupdate-my-document-id2'
-    When I update the documents ['unknown', 'mupdate-my-document-id2']
-    Then the document 'mupdate-my-document-id2' should be updated
-    And I get a partial error
-
-  Scenario: CreateOrReplace (create) multiple documents with no error
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'mcreateorreplace-test-collection'
-    When I createOrReplace the documents ['mcreateorreplace-my-document-id', 'mcreateorreplace-my-document-id2']
-    Then I should have no partial error
-    And the document 'mcreateorreplace-my-document-id' should be created
-    And the document 'mcreateorreplace-my-document-id2' should be created
-
-  Scenario: CreateOrReplace (replace) multiple documents with no error
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'mcreateorreplace-test-collection'
-    And the collection has a document with id 'mcreateorreplace-my-document-id'
-    And the collection has a document with id 'mcreateorreplace-my-document-id2'
-    When I createOrReplace the documents ['mcreateorreplace-my-document-id', 'mcreateorreplace-my-document-id2']
-    Then I should have no partial error
-    And the document 'mcreateorreplace-my-document-id' should be replaced
-    And the document 'mcreateorreplace-my-document-id2' should be replaced
-
-  Scenario: Check if a document exists
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'exist-test-collection'
-    And the collection has a document with id 'exist-my-document-id'
-    When I check if 'exist-my-document-id' exists
-    Then the document should exist
-
-  Scenario: Check if a document does not exists
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'exist-test-collection'
-    And the collection has a document with id 'exist-my-document-id'
-    When I check if 'exist-my-document-unknown' exists
-    Then the document should not exist
-
-  Scenario: Get multiple document
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'mget-test-collection'
-    And the collection has a document with id 'mget-my-document-id'
-    And the collection has a document with id 'mget-my-document-id2'
-    When I get documents ['mget-my-document-id', 'mget-my-document-id2']
-    Then the documents should be retrieved
diff --git a/internal/wrappers/features/fixtures/mapping.json b/internal/wrappers/features/fixtures/mapping.json
deleted file mode 100644
index 7ac15fa6..00000000
--- a/internal/wrappers/features/fixtures/mapping.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-  "properties": {
-    "position": {
-      "type": "geo_point"
-    }
-  }
-}
\ No newline at end of file
diff --git a/internal/wrappers/features/fixtures/rights.json b/internal/wrappers/features/fixtures/rights.json
deleted file mode 100644
index c9bac576..00000000
--- a/internal/wrappers/features/fixtures/rights.json
+++ /dev/null
@@ -1,29 +0,0 @@
-{
-  "controllers": {
-    "auth": {
-      "actions": {
-        "*": true
-      }
-    },
-    "security": {
-      "actions": {
-        "*": true
-      }
-    },
-    "collection": {
-      "actions": {
-        "*": true
-      }
-    },
-    "index": {
-      "actions": {
-        "*": true
-      }
-    },
-    "document": {
-      "actions": {
-        "*": false
-      }
-    }
-  }
-}
\ No newline at end of file
diff --git a/internal/wrappers/features/fixtures/run.sh b/internal/wrappers/features/fixtures/run.sh
deleted file mode 100755
index 52c90843..00000000
--- a/internal/wrappers/features/fixtures/run.sh
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/bin/bash
-set -e
-CONTENT_TYPE="Content-Type: application/json"
-
-KUZZLE_HOST=http://localhost:7512
-
-# update rights for anonymous user
-curl -X PUT -H "$CONTENT_TYPE" -d @rights.json $KUZZLE_HOST/roles/anonymous/_update
-
-# create index
-curl -X POST -H "$CONTENT_TYPE" $KUZZLE_HOST/index/_create
-
-# create collection
-curl -X PUT -H "$CONTENT_TYPE" $KUZZLE_HOST/index/collection
-
-# create geofence collection
-curl -X PUT -H "$CONTENT_TYPE" $KUZZLE_HOST/index/geofence
-
-#update mapping for geofence collection
-curl -X PUT -H "$CONTENT_TYPE" -d @mapping.json $KUZZLE_HOST/index/geofence/_mapping
diff --git a/internal/wrappers/features/index.feature b/internal/wrappers/features/index.feature
deleted file mode 100644
index 62630cad..00000000
--- a/internal/wrappers/features/index.feature
+++ /dev/null
@@ -1,25 +0,0 @@
-Feature: Index controller
-
-  Scenario: Create should create an index
-    Given Kuzzle Server is running
-    And there is no index called 'test-index'
-    When I create an index called 'test-index'
-    Then the index should exist
-
-  Scenario: Create should return an error when the index already exist
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    When I create an index called 'test-index'
-    Then I get an error
-
-  Scenario: Delete multiple indexes
-    Given Kuzzle Server is running
-    And there is the indexes 'test-index1' and 'test-index2'
-    When I delete the indexes 'test-index1' and 'test-index2'
-    Then indexes 'test-index1' and 'test-index2' don't exist
-
-  Scenario: List indexes
-    Given Kuzzle Server is running
-    And there is the indexes 'test-index1' and 'test-index2'
-    When I list indexes
-    Then I get 'test-index1' and 'test-index2'
diff --git a/internal/wrappers/features/java/build.gradle b/internal/wrappers/features/java/build.gradle
deleted file mode 100644
index 4301227a..00000000
--- a/internal/wrappers/features/java/build.gradle
+++ /dev/null
@@ -1,34 +0,0 @@
-apply plugin: 'java'
-
-configurations {
-    cucumberRuntime {
-        extendsFrom testRuntime
-    }
-}
-
-compileTestJava {
-    classpath += files("../../build/java")
-}
-
-task cucumber() {
-    dependsOn assemble, compileTestJava
-    doLast {
-        javaexec {
-            jvmArgs = ["-Djava.library.path=../../build/io/kuzzle/sdk/resources"]
-            main = "cucumber.api.cli.Main"
-            classpath = configurations.cucumberRuntime + sourceSets.main.output + sourceSets.test.output + files('../../build/java')
-            args = ['--plugin', 'pretty', '--glue', 'gradle.cucumber', '../']
-        }
-    }
-}
-
-dependencies {
-    testCompile 'io.cucumber:cucumber-java:2.3.1'
-    testCompile 'io.cucumber:cucumber-junit:2.3.1'
-
-    testCompile 'junit:junit:4.12'
-}
-
-repositories {
-    mavenCentral()
-}
diff --git a/internal/wrappers/features/java/src/test/java/gradle/cucumber/Collectiondefs.java b/internal/wrappers/features/java/src/test/java/gradle/cucumber/Collectiondefs.java
deleted file mode 100644
index c4841050..00000000
--- a/internal/wrappers/features/java/src/test/java/gradle/cucumber/Collectiondefs.java
+++ /dev/null
@@ -1,157 +0,0 @@
-package gradle.cucumber;
-
-import cucumber.api.java.Before;
-import cucumber.api.java.en.Given;
-import cucumber.api.java.en.Then;
-import cucumber.api.java.en.When;
-import gherkin.deps.com.google.gson.Gson;
-import gherkin.deps.com.google.gson.JsonArray;
-import io.kuzzle.sdk.Kuzzle;
-import io.kuzzle.sdk.NotFoundException;
-import io.kuzzle.sdk.QueryOptions;
-import io.kuzzle.sdk.SearchResult;
-import org.junit.Assert;
-
-import javax.management.remote.NotificationResult;
-
-public class Collectiondefs {
-    private Kuzzle k;
-    private World world;
-    private boolean exists = false;
-    String listCollections;
-    private boolean validateSpecs = false;
-
-    @Before
-    public void before() {
-        k = KuzzleSingleton.getInstance();
-    }
-
-    @When("^I create a collection \'([^\"]*)\'$")
-    public void i_create_a_collection_test_collection(String collection) throws Exception {
-        k.getCollection().create(world.index, collection);
-        world.collection = collection;
-    }
-
-    @Then("^the collection \'([^\"]*)\' should exist$")
-    public void the_collection_should_exists(String collection) throws Exception {
-        Assert.assertTrue(k.getCollection().exists(world.index, collection));
-    }
-
-    @When("^I check if the collection \'([^\"]*)\' exists$")
-    public void i_check_if_the_collection_exists(String collection) throws Exception {
-        exists = k.getCollection().exists(world.index, collection);
-    }
-
-    @Then("^the collection should exist$")
-    public void it_should_exists() throws Exception {
-        Assert.assertTrue(exists);
-    }
-
-    @When("^I list the collections of \'([^\"]*)\'$")
-    public void i_list_the_collections(String index) throws Exception {
-        listCollections = k.getCollection().list(index);
-    }
-
-    class Col {
-        JsonArray collections;
-    }
-
-    @Then("^the result contains (\\d+) hits$")
-    public void the_result_contains_hits(int nb) throws Exception {
-        Gson gson = new Gson();
-        Col c = gson.fromJson(listCollections, Collectiondefs.Col.class);
-
-        Assert.assertEquals(nb, c.collections.size());
-
-    }
-
-    @Then("^the content should not be null$")
-    public void i() {
-        Assert.assertNotNull(this.listCollections);
-        Assert.assertEquals("{\"type\":\"all\",\"collections\":[{\"name\":\"test-collection1\",\"type\":\"stored\"},{\"name\":\"test-collection2\",\"type\":\"stored\"}],\"from\":0,\"size\":10}", this.listCollections);
-    }
-
-    @When("^I truncate the collection \'([^\"]*)\'$")
-    public void i_truncate_the_collection(String collection) throws Exception {
-        QueryOptions o = new QueryOptions();
-        o.setRefresh("wait_for");
-
-        k.getCollection().truncate(world.index, collection, o);
-    }
-
-    @Then("^the collection \'([^\"]*)\' should be empty$")
-    public void it_should_be_empty(String collection) throws Exception {
-        SearchResult res = k.getDocument().search(world.index, collection, "{}");
-        Assert.assertEquals("[]", res.getDocuments());
-    }
-
-    @When("^I update the mapping of collection \'([^\"]*)\'$")
-    public void i_update_the_mapping(String collection) throws Exception {
-        k.getCollection().updateMapping(world.index, collection, "{" +
-                "\"properties\": {" +
-                "    \"foo\": {" +
-                "      \"type\": \"string\"," +
-                "      \"fields\": {\"keyword\":{\"type\":\"keyword\",\"ignore_above\":256}}" +
-                "    }" +
-                "}" +
-                "}");
-    }
-
-    @Then("^the mapping of \'([^\"]*)\' should be updated$")
-    public void the_mapping_should_be_updated(String collection) throws Exception {
-        String mapping = k.getCollection().getMapping(world.index, collection);
-        Assert.assertEquals(
-            "{\"" + world.index + "\":{\"mappings\":{\"" + collection + "\":{\"properties\":{\"foo\":{\"type\":\"text\",\"fields\":{\"keyword\":{\"type\":\"keyword\",\"ignore_above\":256}}}}}}}}", mapping);
-    }
-
-    @When("^I update the specifications of the collection \'([^\"]*)\'$")
-    public void i_update_the_specifications(String collection) throws Exception {
-        k.getCollection().updateSpecifications(world.index, world.collection, "{\"" + world.index + "\":{\""+ collection +"\":{\"strict\":true}}}");
-    }
-
-    @Then("^the specifications of \'([^\"]*)\' should be updated$")
-    public void the_specifications_of_collection_should_be_updated(String collection) throws Exception {
-        Assert.assertEquals("{\"validation\":{\"strict\":true},\"index\":\"test-index\",\"collection\":\"test-collection\"}", k.getCollection().getSpecifications(world.index, collection));
-    }
-
-    @When("^I validate the specifications of \'([^\"]*)\'$")
-    public void i_validate_the_specifications(String collection) throws Exception {
-        this.validateSpecs = k.getCollection().validateSpecifications("{\""+world.index+"\":{\""+collection+"\":{\"strict\":true}}}");
-    }
-
-    @Then("^they should be validated$")
-    public void they_should_be_validated() throws Exception {
-        Assert.assertTrue(this.validateSpecs);
-    }
-
-    @Given("^has specifications$")
-    public void has_specifications() throws Exception {
-        k.getCollection().updateSpecifications(world.index, world.collection, "{\""+world.index+"\":{\""+world.collection+"\":{\"strict\":true}}}");
-    }
-
-    @When("^I delete the specifications of \'([^\"]*)\'$")
-    public void i_delete_the_specifications(String collection) throws Exception {
-        k.getCollection().deleteSpecifications(world.index, collection);
-    }
-
-    @Then("^the specifications of \'([^\"]*)\' must not exist$")
-    public void the_specifications_must_not_exist(String collection) throws Exception {
-        boolean notFound = false;
-        try {
-            k.getCollection().getSpecifications(world.index, collection);
-        } catch (NotFoundException e) {
-            notFound = true;
-        }
-        Assert.assertTrue(notFound);
-    }
-
-    @When("^I create a collection \'([^\"]*)\' with a mapping$")
-    public void i_create_a_collection_test_collection_with_mapping(String collection) throws Exception {
-        String mapping = "{\"properties\": {\"foo\": {"
-            + "\"type\": \"string\", \"fields\": {"
-            + "\"keyword\":{\"type\":\"keyword\",\"ignore_above\":256}}"
-            + "}}}";
-        k.getCollection().create(world.index, collection, mapping);
-        world.collection = collection;
-    }
-}
diff --git a/internal/wrappers/features/java/src/test/java/gradle/cucumber/Documentdefs.java b/internal/wrappers/features/java/src/test/java/gradle/cucumber/Documentdefs.java
deleted file mode 100644
index 5254265f..00000000
--- a/internal/wrappers/features/java/src/test/java/gradle/cucumber/Documentdefs.java
+++ /dev/null
@@ -1,381 +0,0 @@
-package gradle.cucumber;
-
-import cucumber.api.java.en.And;
-import cucumber.api.java.en.Given;
-import cucumber.api.java.en.Then;
-import cucumber.api.java.en.When;
-import gherkin.deps.com.google.gson.Gson;
-import gherkin.deps.com.google.gson.JsonObject;
-import io.kuzzle.sdk.*;
-import org.junit.Assert;
-
-import java.util.List;
-
-public class Documentdefs {
-    private Kuzzle k;
-    private String errorMessage;
-    private World world;
-    private String documentId;
-    private SearchResult documents;
-    private int nbDocuments;
-    private boolean partialException = false;
-    private boolean documentExists = false;
-    private String jsonDocuments;
-
-    class Source {
-        JsonObject _source;
-    }
-
-    @Given("^Kuzzle Server is running$")
-    public void kuzzle_Server_is_running() throws Exception {
-        k = KuzzleSingleton.getInstance();
-
-        k.connect();
-    }
-
-    @Given("^there is an index \'([^\"]*)\'$")
-    public void there_is_an_index(String index) throws Exception {
-        world.index = index;
-        if (!k.getIndex().exists(index)) {
-            k.getIndex().create(index);
-        }
-    }
-
-    @Given("^it has a collection \'([^\"]*)\'$")
-    public void it_has_a_collection(String collection) throws Exception {
-        world.collection = collection;
-        if (!k.getCollection().exists(world.index, collection)) {
-            k.getCollection().create(world.index, collection);
-        }
-    }
-
-    @Given("^the collection has a document with id \'([^\"]*)\'$")
-    public void the_collection_has_a_document_with_id(String id) throws Exception {
-        QueryOptions options = new QueryOptions();
-        options.setRefresh("wait_for");
-
-        try {
-            k.getDocument().create(world.index, world.collection, id, "{\"foo\":\"bar\"}", options);
-            this.documentId = id;
-        } catch (BadRequestException e) {
-            if (!e.getMessage().equals("Document already exists")) {
-                throw e;
-            }
-        }
-    }
-
-    @When("^I create a document with id \'([^\"]*)\'$")
-    public void i_try_to_create_a_new_document_with_id(String id) throws Exception {
-        this.errorMessage = null;
-        try {
-            k.getDocument().create(world.index, world.collection, id, "{\"foo\": \"bar\"}");
-            this.documentId = id;
-            this.errorMessage = null;
-        } catch (BadRequestException e) {
-            this.errorMessage = e.getMessage();
-        }
-    }
-
-    @Then("^I get an error with message \'([^\"]*)\'$")
-    public void i_get_an_error_with_message(String message) throws Exception {
-        Assert.assertEquals(message, this.errorMessage);
-    }
-
-    @Then("^the document is successfully created$")
-    public void the_document_is_successfully_created() throws Exception {
-        Assert.assertNull(this.errorMessage);
-    }
-
-    @When("^I update the document with id \'([^\"]*)\' and content \'([^\"]*)\' = \'([^\"]*)\'$")
-    public void i_update_the_document_with_id_and_content(String id, String key, String value) throws Exception {
-        QueryOptions options = new QueryOptions();
-        options.setRefresh("wait_for");
-
-        k.getDocument().update(world.index, world.collection, id, "{\""+key+"\":\""+value+"\"}");
-    }
-
-    @When("^I createOrReplace a document with id \'([^\"]*)\'$")
-    public void i_createOrReplace_a_new_document_with_id(String id) throws Exception {
-        this.errorMessage = null;
-        try {
-            k.getDocument().createOrReplace(world.index, world.collection, id, "{\"foo\": \"barz\"}");
-            this.documentId = id;
-            this.errorMessage = null;
-        } catch (BadRequestException e) {
-            this.errorMessage = e.getMessage();
-        }
-    }
-
-    @Then("^the document is successfully replaced$")
-    public void the_document_is_successfully_replaced() throws Exception {
-        String doc = k.getDocument().get(world.index, world.collection, this.documentId);
-        Assert.assertNull(this.errorMessage);
-
-        Gson gson = new Gson();
-        Source s = gson.fromJson(doc, Source.class);
-        Assert.assertEquals("\"barz\"", s._source.get("foo").toString());
-    }
-
-    @Given("^the collection doesn't have a document with id \'([^\"]*)\'$")
-    public void the_collection_doesn_t_have_a_document_with_id(String id) throws Exception {
-        QueryOptions options = new QueryOptions();
-        options.setRefresh("wait_for");
-
-        try {
-            k.getDocument().delete(world.index, world.collection, id, options);
-        } catch (KuzzleException e) {}
-    }
-
-    @When("^I replace a document with id \'([^\"]*)\'$")
-    public void i_replace_a_document_with_id(String id) throws Exception {
-        this.errorMessage = null;
-        try {
-            k.getDocument().replace(world.index, world.collection, id, "{\"foo\": \"barz\"}");
-            this.documentId = id;
-        } catch (BadRequestException e) {
-            this.errorMessage = e.getMessage();
-        }
-    }
-
-    @When("^I delete a document with id \'([^\"]*)\'$")
-    public void i_delete_a_document_with_id(String id) throws Exception {
-        this.errorMessage = null;
-        try {
-            k.getDocument().delete(world.index, world.collection, id);
-        } catch (KuzzleException e) {
-            this.errorMessage = e.getMessage();
-        }
-    }
-
-    @Then("^the document is successfully deleted")
-    public void the_document_is_successfully_deleted() throws Exception {
-        Assert.assertNull(this.errorMessage);
-    }
-
-    @When("^I update a document with id \'([^\"]*)\'$")
-    public void i_update_a_document_with_id(String id) throws Exception {
-        this.errorMessage = null;
-        try {
-            k.getDocument().update(world.index, world.collection, id, "{\"foo\": \"barz\"}");
-            this.documentId = id;
-        } catch (BadRequestException e) {
-            this.errorMessage = e.getMessage();
-        }
-    }
-
-    @Then("^the document is successfully updated")
-    public void the_document_is_successfully_updated() throws Exception {
-        String doc = k.getDocument().get(world.index, world.collection, this.documentId);
-        Assert.assertNull(this.errorMessage);
-
-        Gson gson = new Gson();
-        Source s = gson.fromJson(doc, Source.class);
-        Assert.assertEquals("\"barz\"", s._source.get("foo").toString());
-    }
-
-    @When("^I search a document with id \'([^\"]*)\'$")
-    public void i_search_a_document_with_id(String id) throws Exception {
-        this.errorMessage = null;
-
-        try {
-            QueryOptions options = new QueryOptions();
-            options.setSize(42);
-            this.documents = k.getDocument().search(world.index, world.collection, "{\"query\": {\"bool\": {\"should\":[{\"match\":{\"_id\": \""+id+"\"}}]}}}");
-        } catch (BadRequestException e) {
-            this.errorMessage = e.getMessage();
-        }
-    }
-
-    @Then("^the document is successfully found$")
-    public void the_document_is_successfully_found() throws Exception {
-        Assert.assertNotNull(this.documents);
-        Assert.assertNotNull(this.documents.getDocuments());
-        Assert.assertNotEquals("[]", this.documents.getDocuments());
-    }
-
-    @Then("^the document is not found$")
-    public void the_document_is_not_found() throws Exception {
-        Assert.assertNotNull(this.documents.getDocuments());
-        Assert.assertEquals("[]", this.documents.getDocuments());
-    }
-
-    @Then("^I shall receive (\\d+)$")
-    public void i_shall_receive(int nbDocuments) throws Exception {
-        Assert.assertEquals(nbDocuments, this.nbDocuments);
-        this.nbDocuments = 0;
-    }
-
-    @Then("^I must have (\\d+) documents in the collection$")
-    public void i_must_have_documents_in_the_collection(int nb) {
-        Assert.assertEquals(nb, k.getDocument().count(world.index, world.collection, "{}"));
-    }
-
-    @When("^I count how many documents there is in the collection$")
-    public void i_count_how_many_documents_there_is_in_the_collection() throws Exception {
-        nbDocuments = k.getDocument().count(world.index, world.collection, "{}");
-    }
-
-    @When("^I delete the documents \\[\'(.*)\', \'(.*)\'\\]$")
-    public void i_delete_the_documents(String doc1, String doc2) throws Exception {
-        QueryOptions o = new QueryOptions();
-        o.setRefresh("wait_for");
-
-        StringVector v = new StringVector();
-        v.add(doc1);
-        v.add(doc2);
-        try {
-            k.getDocument().mDelete(world.index, world.collection, v, o);
-            this.partialException = false;
-        } catch (PartialException e) {
-            this.partialException = true;
-        }
-    }
-
-    @Then("^the collection must be empty$")
-    public void the_collection_must_be_empty() {
-        Assert.assertEquals(0, k.getDocument().count(world.index, world.collection, "{}"));
-    }
-
-    @And("^I get a partial error$")
-    public void i_get_a_partial_error() {
-        Assert.assertTrue(this.partialException);
-        this.partialException = false;
-    }
-
-    @When("^I create the documents \\[\'(.*)\', \'(.*)\'\\]$")
-    public void i_create_the_documents(String doc1, String doc2) throws Exception {
-        QueryOptions o = new QueryOptions();
-        o.setRefresh("wait_for");
-
-        String docs = "{\"documents\":[{\"_id\":\""+doc1+"\", \"body\":{}}, {\"_id\":\""+doc2+"\", \"body\":{}}]}";
-        try {
-            k.getDocument().mCreate(world.index, world.collection, docs, o);
-            this.partialException = false;
-        } catch (PartialException e) {
-            this.partialException = true;
-        }
-    }
-
-    @Then("^I should have no partial error$")
-    public void i_should_have_no_partial_error() {
-        Assert.assertFalse(this.partialException);
-    }
-
-    @When("^I replace the documents \\[\'(.*)\', \'(.*)\'\\]$")
-    public void i_replace_the_documents(String doc1, String doc2) throws Exception {
-        QueryOptions o = new QueryOptions();
-        o.setRefresh("wait_for");
-
-        String docs = "{\"documents\":[{\"_id\":\""+doc1+"\", \"body\":{\"foo\":\"barz\"}}, {\"_id\":\""+doc2+"\", \"body\":{\"foo\":\"barz\"}}]}";
-        try {
-            k.getDocument().mReplace(world.index, world.collection, docs, o);
-            this.partialException = false;
-        } catch (PartialException e) {
-            this.partialException = true;
-        }
-    }
-
-    @Then("^the document \'([^\"]*)\' should be replaced")
-    public void the_documents_should_be_replaced(String id1) throws Exception {
-        String doc = k.getDocument().get(world.index, world.collection, id1);
-        Assert.assertNull(this.errorMessage);
-
-        Gson gson = new Gson();
-        Source s = gson.fromJson(doc, Source.class);
-        Assert.assertEquals("\"barz\"", s._source.get("foo").toString());
-    }
-
-    @When("^I update the documents \\[\'(.*)\', \'(.*)\'\\]$")
-    public void i_update_the_documents(String doc1, String doc2) throws Exception {
-        QueryOptions o = new QueryOptions();
-        o.setRefresh("wait_for");
-
-        String docs = "{\"documents\":[{\"_id\":\""+doc1+"\", \"body\":{\"foo\":\"barz\"}}, {\"_id\":\""+doc2+"\", \"body\":{\"foo\":\"barz\"}}]}";
-        try {
-            k.getDocument().mUpdate(world.index, world.collection, docs, o);
-            this.partialException = false;
-        } catch (PartialException e) {
-            this.partialException = true;
-        } catch (KuzzleException e) {
-            this.errorMessage = e.getMessage();
-        }
-    }
-
-    @Then("^the document \'([^\"]*)\' should be updated")
-    public void the_documents_should_be_updated(String id1) throws Exception {
-        Assert.assertNull(this.errorMessage);
-        String doc = k.getDocument().get(world.index, world.collection, id1);
-        Assert.assertNull(this.errorMessage);
-
-        Gson gson = new Gson();
-        Source s = gson.fromJson(doc, Source.class);
-        Assert.assertEquals("\"barz\"", s._source.get("foo").toString());
-    }
-
-    @When("^I createOrReplace the documents \\[\'(.*)\', \'(.*)\'\\]$")
-    public void i_createOrReplace_the_documents(String doc1, String doc2) throws Exception {
-        QueryOptions o = new QueryOptions();
-        o.setRefresh("wait_for");
-
-        String docs = "{\"documents\":[{\"_id\":\""+doc1+"\", \"body\":{\"foo\":\"barz\"}}, {\"_id\":\""+doc2+"\", \"body\":{\"foo\":\"barz\"}}]}";
-        try {
-            k.getDocument().mCreateOrReplace(world.index, world.collection, docs, o);
-            this.partialException = false;
-        } catch (PartialException e) {
-            this.partialException = true;
-        } catch (KuzzleException e) {
-            this.errorMessage = e.getMessage();
-        }
-    }
-
-    @Then("^the document \'([^\"]*)\' should be created")
-    public void the_documents_should_be_created(String id1) throws Exception {
-        Assert.assertNull(this.errorMessage);
-        String doc = k.getDocument().get(world.index, world.collection, id1);
-        Assert.assertNull(this.errorMessage);
-
-        Gson gson = new Gson();
-        Source s = gson.fromJson(doc, Source.class);
-        Assert.assertEquals("\"barz\"", s._source.get("foo").toString());
-    }
-
-    @When("^I check if \'([^\"]*)\' exists$")
-    public void i_createOrReplace_the_documents(String doc) throws Exception {
-        this.documentExists = false;
-        try {
-            this.documentExists = k.getDocument().exists(world.index, world.collection, doc);
-        } catch (KuzzleException e) {
-            this.errorMessage = e.getMessage();
-        }
-    }
-
-    @Then("^the document should exist$")
-    public void the_document_should_exists() throws Exception {
-        Assert.assertNull(this.errorMessage);
-        Assert.assertTrue(this.documentExists);
-    }
-
-    @Then("^the document should not exist$")
-    public void the_document_should_not_exists() throws Exception {
-        Assert.assertNull(this.errorMessage);
-        Assert.assertFalse(this.documentExists);
-    }
-
-    @When("^I get documents \\[\'(.*)\', \'(.*)\'\\]$")
-    public void i_get_document_mget_my_document_id_and_mget_my_document_id(String id1, String id2) throws Exception {
-        try {
-            StringVector v = new StringVector();
-            v.add(id1);
-            v.add(id2);
-            jsonDocuments = k.getDocument().mGet(world.index, world.collection, v, false);
-        } catch (KuzzleException e) {
-            this.errorMessage = e.getMessage();
-        }
-    }
-
-    @Then("^the documents should be retrieved$")
-    public void the_documents_should_be_retrieved() throws Exception {
-        Assert.assertNull(this.errorMessage);
-        Assert.assertNotNull(this.jsonDocuments);
-    }
-}
diff --git a/internal/wrappers/features/java/src/test/java/gradle/cucumber/Geofencedefs.java b/internal/wrappers/features/java/src/test/java/gradle/cucumber/Geofencedefs.java
deleted file mode 100644
index 51f4aa1c..00000000
--- a/internal/wrappers/features/java/src/test/java/gradle/cucumber/Geofencedefs.java
+++ /dev/null
@@ -1,72 +0,0 @@
-package gradle.cucumber;
-
-import cucumber.api.java.Before;
-import cucumber.api.java.en.Given;
-import cucumber.api.java.en.Then;
-import cucumber.api.java.en.When;
-import io.kuzzle.sdk.*;
-import org.junit.Assert;
-
-public class Geofencedefs {
-    private Kuzzle k;
-    private NotificationResult content = null;
-    private String documentId;
-
-    @Before
-    public void before() {
-        k = KuzzleSingleton.getInstance();
-    }
-
-    @Given("^I subscribe to \"([^\"]*)\" collection$")
-    public void i_subscribe_to_collection(String collection) throws Exception {
-        String filter = "{" +
-                "\"geoBoundingBox\": {" +
-                "\"position\": {" +
-                "\"topLeft\": {" +
-                "\"lat\": 10," +
-                "\"lon\": 1" +
-                "}," +
-                "\"bottomRight\": {" +
-                "\"lat\": 1," +
-                "\"lon\": 10" +
-                "}" +
-                "}" +
-                "}" +
-                "}";
-
-        RoomOptions opts = new RoomOptions();
-        opts.setUser("all");
-        opts.setState("all");
-        opts.setScope("all");
-        opts.setSubscribeToSelf(true);
-
-        k.getAuth().login("local", "{\"username\": \""+"useradmin"+"\", \"password\":\""+"testpwd"+"\" }", 40000);
-
-        k.getRealtime().subscribe("index", collection, filter, new NotificationListener() {
-            @Override
-            public void onMessage(NotificationResult res) {
-                content = res;
-            }
-        }, opts);
-    }
-
-    @When("^I create a document in \"([^\"]*)\" and inside my geofence$")
-    public void i_create_a_document_in_and_inside_my_geofence(String collection) throws Exception {
-        System.err.println("create document");
-        documentId = k.getDocument().create("index", collection, "", "{\"position\":{\"lat\": 2, \"lon\": 2}}");
-        Thread.sleep(1000);
-    }
-
-    @Then("^I receive a \"([^\"]*)\" notification$")
-    public void i_receive_a_notification(String scope) throws Exception {
-        Assert.assertNotNull(content);
-        Assert.assertEquals(scope, content.getScope());
-    }
-
-    @When("^I update this document to be outside my geofence$")
-    public void i_update_this_document_to_be_outside_my_geofence() throws Exception {
-        content = null;
-        k.getDocument().update("index", "geofence", documentId, "{\"position\":{\"lat\": 30, \"lon\": 20}}");
-        Thread.sleep(1000);
-    }
-}
diff --git a/internal/wrappers/features/java/src/test/java/gradle/cucumber/Indexdefs.java b/internal/wrappers/features/java/src/test/java/gradle/cucumber/Indexdefs.java
deleted file mode 100644
index e0064ef8..00000000
--- a/internal/wrappers/features/java/src/test/java/gradle/cucumber/Indexdefs.java
+++ /dev/null
@@ -1,100 +0,0 @@
-package gradle.cucumber;
-
-import cucumber.api.PendingException;
-import cucumber.api.java.Before;
-import cucumber.api.java.en.Given;
-import cucumber.api.java.en.Then;
-import cucumber.api.java.en.When;
-import io.kuzzle.sdk.Kuzzle;
-import io.kuzzle.sdk.KuzzleException;
-import io.kuzzle.sdk.QueryOptions;
-import io.kuzzle.sdk.StringVector;
-import org.junit.Assert;
-
-public class Indexdefs {
-    private Kuzzle k;
-    private World world;
-    private String errorMessage;
-
-    @Before
-    public void before() {
-        k = KuzzleSingleton.getInstance();
-    }
-
-    @Given("^there is no index called \'([^\"]*)\'$")
-    public void there_is_no_index_called(String index) {
-        try {
-            QueryOptions o = new QueryOptions();
-            o.setRefresh("wait_for");
-
-            k.getIndex().delete(index, o);
-        } catch (KuzzleException e) {}
-    }
-
-    @When("^I create an index called \'([^\"]*)\'$")
-    public void i_create_an_index_called_test_index(String index) throws Exception {
-        try {
-            k.getIndex().create(index);
-        } catch (KuzzleException e) {
-            this.errorMessage = e.getMessage();
-        }
-        world.index = index;
-    }
-
-    @Then("^the index should exist$")
-    public void the_index_should_exists() throws Exception {
-            Assert.assertTrue(k.getIndex().exists(world.index));
-    }
-
-
-    @Then("^I get an error$")
-    public void i_get_an_error() throws Exception {
-        Assert.assertNotNull(this.errorMessage);
-    }
-
-    @Given("^there is the indexes \'([^\"]*)\' and \'([^\"]*)\'$")
-    public void there_is_the_indexes_test_index_and_test_index(String index1, String index2) throws Exception {
-        try {
-            QueryOptions o = new QueryOptions();
-            o.setRefresh("wait_for");
-
-            k.getIndex().create(index1, o);
-            k.getIndex().create(index2, o);
-        } catch(Exception e) {}
-    }
-
-    @When("^I delete the indexes \'([^\"]*)\' and \'([^\"]*)\'$")
-    public void i_delete_the_indexes_test_index_and_test_index(String index1, String index2) throws Exception {
-        QueryOptions o = new QueryOptions();
-        o.setRefresh("wait_for");
-
-        StringVector v = new StringVector();
-        v.add(index1);
-        v.add(index2);
-
-        k.getIndex().mDelete(v, o);
-    }
-
-    @Then("^indexes \'([^\"]*)\' and \'([^\"]*)\' don't exist$")
-    public void indexes_test_index_and_test_index_don_t_exist(String index1, String index2) throws Exception {
-        Assert.assertFalse(k.getIndex().exists(index1));
-        Assert.assertFalse(k.getIndex().exists(index2));
-    }
-
-    @When("^I list indexes$")
-    public void i_list_indexes() throws Exception {
-      world.stringArray = k.getIndex().list();
-    }
-
-    @Then("^I get \'([^\"]*)\' and \'([^\"]*)\'$")
-    public void i_get_test_index_and_test_index(String index1, String index2) throws Exception {
-      int match = 0;
-
-      for (int i = 0; i < world.stringArray.size(); ++i) {
-        if (world.stringArray.get(i).equals(index1) || world.stringArray.get(i).equals(index2))
-          match++;
-      }
-
-      Assert.assertTrue(match == 2);
-    }
-}
diff --git a/internal/wrappers/features/java/src/test/java/gradle/cucumber/KuzzleSingleton.java b/internal/wrappers/features/java/src/test/java/gradle/cucumber/KuzzleSingleton.java
deleted file mode 100644
index 152afb57..00000000
--- a/internal/wrappers/features/java/src/test/java/gradle/cucumber/KuzzleSingleton.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package gradle.cucumber;
-
-import io.kuzzle.sdk.Kuzzle;
-
-public class KuzzleSingleton {
-    private static Kuzzle kuzzle = null;
-
-    public static Kuzzle getInstance() {
-        if (kuzzle != null) {
-            return kuzzle;
-        }
-
-        kuzzle = new Kuzzle((System.getenv().get("KUZZLE_HOST") != null) ? (System.getenv().get("KUZZLE_HOST")) : "localhost");
-        return kuzzle;
-    }
-}
diff --git a/internal/wrappers/features/java/src/test/java/gradle/cucumber/Subscribedefs.java b/internal/wrappers/features/java/src/test/java/gradle/cucumber/Subscribedefs.java
deleted file mode 100644
index 621e7903..00000000
--- a/internal/wrappers/features/java/src/test/java/gradle/cucumber/Subscribedefs.java
+++ /dev/null
@@ -1,92 +0,0 @@
-package gradle.cucumber;
-
-import cucumber.api.java.After;
-import cucumber.api.java.Before;
-import cucumber.api.java.en.Given;
-import cucumber.api.java.en.Then;
-import cucumber.api.java.en.When;
-import io.kuzzle.sdk.*;
-import org.junit.Assert;
-
-public class Subscribedefs {
-    private Kuzzle k;
-    private String roomId;
-    private NotificationContent content = null;
-    private World world;
-
-    @Before
-    public void before() {
-        k = KuzzleSingleton.getInstance();
-    }
-
-    @After
-    public void after() {
-        if (roomId != null) {
-            k.getRealtime().unsubscribe(roomId);
-        }
-    }
-
-    @Given("^I subscribe to \'(.*)\'$")
-    public void i_subscribe_to(String collection) throws Exception {
-        roomId = k.getRealtime().subscribe(world.index, collection, "{}", new NotificationListener() {
-            @Override
-            public void onMessage(NotificationResult res) {
-                content = res.getResult();
-            }
-        });
-    }
-
-    @Given("^I subscribe to \'(.*)\' with \'(.*)\' as filter$")
-    public void i_subscribe_with_filter(String collection, String filter) throws Exception {
-        content = null;
-        roomId = k.getRealtime().subscribe(world.index, collection, filter, new NotificationListener() {
-            @Override
-            public void onMessage(NotificationResult res) {
-                content = res.getResult();
-            }
-        });
-    }
-
-    @When("^I create a document in \'([^\"]*)\'$")
-    public void i_create_a_document_in(String collection) throws Exception {
-        k.getDocument().create(world.index, collection, "", "{}");
-        Thread.sleep(1000);
-    }
-
-    @Then("^I( do not)? receive a notification$")
-    public void i_receive_a_notification(String dont) throws Exception {
-        Thread.sleep(1000);
-        if (dont == null) {
-            Assert.assertNotNull(content);
-            Assert.assertNotNull(content.getContent());
-            content = null;
-            return;
-        }
-        Assert.assertNull(content);
-    }
-
-    @Given("^I received a notification$")
-    public void i_received_a_notification() throws Exception {
-        Thread.sleep(1000);
-        Assert.assertNotNull(content);
-        Assert.assertNotNull(content.getContent());
-        content = null;
-    }
-
-    @Given("^I unsubscribe")
-    public void i_unsubscribe() throws Exception {
-        k.getRealtime().unsubscribe(roomId);
-    }
-
-    @When("^I delete the document with id \'([^\"]*)\'$")
-    public void i_delete_the_document_with_id(String id) throws Exception {
-        k.getDocument().delete(world.index, world.collection, id);
-        Thread.sleep(1000);
-    }
-
-    @When("^I publish a document$")
-    public void i_publish_a_document() throws Exception {
-        k.getRealtime().publish(world.index, world.collection, "{}");
-    }
-
-}
diff --git a/internal/wrappers/features/java/src/test/java/gradle/cucumber/UserManagementdefs.java b/internal/wrappers/features/java/src/test/java/gradle/cucumber/UserManagementdefs.java
deleted file mode 100644
index 570336f4..00000000
--- a/internal/wrappers/features/java/src/test/java/gradle/cucumber/UserManagementdefs.java
+++ /dev/null
@@ -1,103 +0,0 @@
-package gradle.cucumber;
-
-import cucumber.api.java.After;
-import cucumber.api.java.Before;
-import cucumber.api.java.en.Given;
-import cucumber.api.java.en.Then;
-import cucumber.api.java.en.When;
-import io.kuzzle.sdk.*;
-import org.junit.Assert;
-
-public class UserManagementdefs {
-    private Kuzzle k;
-    private String userId;
-    private User currentUser;
-
-    @Before
-    public void before() {
-        k = KuzzleSingleton.getInstance();
-    }
-
-    @After
-    public void after() {
-        if (k != null && (k.getJwt() == null || !k.getJwt().equals(""))) {
-            k.getAuth().logout();
-        }
-    }
-
-    @Given("^there is an user with id \'([^\"]*)\'$")
-    public void there_is_an_user_with_id(String id) throws Exception {
-        this.userId = id;
-    }
-
-    @Given("^the user has 'local' credentials with name \'([^\"]*)\' and password \'([^\"]*)\'$")
-    public void the_user_has_local_credentials_with_name_and_password(String name, String password) throws Exception {
-      KuzzleRequest request = new KuzzleRequest();
-        String json = "{\n" +
-                "  \"content\": {\n" +
-                "    \"profileIds\": [\"default\"]" +
-                "  },\n" +
-                "  \"credentials\": {\n" +
-                "    \"local\": {\n" +
-                "      \"username\": \""+name+"\"," +
-                "      \"password\": \""+password+"\"" +
-                "    }\n" +
-                "  }\n" +
-                "}";
-
-        request.setController("security");
-        request.setAction("createUser");
-        request.setId(this.userId);
-        request.setBody(json);
-        request.setStrategy("local");
-
-        try {
-            k.query(request);
-        } catch(KuzzleException e) {
-            if (e.getClass() != PreconditionException.class) {
-                throw e;
-            }
-        }
-    }
-
-    @When("^I log in as \'([^\"]*)\':\'([^\"]*)\'$")
-    public void i_log_in_as(String name, String password) throws Exception {
-        try {
-            k.getAuth().login("local", "{\"username\": \"" + name + "\", \"password\":\"" + password + "\" }");
-        } catch (KuzzleException e) {
-            if (e.getClass() != UnauthorizedException.class) {
-                throw e;
-            }
-        }
-    }
-
-    @Then("^the JWT is valid$")
-    public void the_JWT_is_valid() throws Exception {
-        Assert.assertTrue(k.getAuth().checkToken(k.getJwt()).getValid());
-    }
-
-    @Then("^the JWT is invalid$")
-    public void the_JWT_is_invalid() throws Exception {
-        Assert.assertFalse(k.getAuth().checkToken(k.getJwt()).getValid());
-    }
-
-    @Given("^I update my user custom data with the pair \'([^\"]*)\':\'([^\"]*)\'$")
-    public void i_update_my_user_custom_data_with_the_pair(String fieldname, String fieldvalue) throws Exception {
-        k.getAuth().updateSelf("{\""+fieldname+"\": \""+fieldvalue+"\"}");
-    }
-
-    @When("^I get my user info$")
-    public void i_get_my_user_info() throws Exception {
-        currentUser = k.getAuth().getCurrentUser();
-    }
-
-    @Then("^the response '_source' field contains the pair \'([^\"]*)\':\'([^\"]*)\'$")
-    public void the_response__source_field_contains_the_pair(String key, String value) throws Exception {
-        Assert.assertNotNull(currentUser.getContent());
-    }
-
-    @When("^I logout$")
-    public void i_logout() throws Exception {
-        k.getAuth().logout();
-    }
-}
diff --git a/internal/wrappers/features/java/src/test/java/gradle/cucumber/World.java b/internal/wrappers/features/java/src/test/java/gradle/cucumber/World.java
deleted file mode 100644
index c3c7d33c..00000000
--- a/internal/wrappers/features/java/src/test/java/gradle/cucumber/World.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package gradle.cucumber;
-
-import io.kuzzle.sdk.*;
-
-public class World {
-    public static String index;
-    public static String collection;
-    public static StringVector stringArray;
-}
diff --git a/internal/wrappers/features/realtime.feature b/internal/wrappers/features/realtime.feature
deleted file mode 100644
index 0751f7e9..00000000
--- a/internal/wrappers/features/realtime.feature
+++ /dev/null
@@ -1,45 +0,0 @@
-Feature: Realtime subscription
-
-  Scenario: Receive notifications when a document is created
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    And I subscribe to 'test-collection'
-    When I create a document in 'test-collection'
-    Then I receive a notification
-
-  Scenario: Receive notifications when a document is updated
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    And the collection has a document with id 'my-document-id'
-    And I subscribe to 'test-collection' with '{"equals": {"foo": "barz"}}' as filter
-    When I update the document with id 'my-document-id' and content 'foo' = 'barz'
-    Then I receive a notification
-
-  Scenario: Receive notifications when a document is deleted
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    And the collection has a document with id 'my-document-id'
-    And I subscribe to 'test-collection'
-    When I delete the document with id 'my-document-id'
-    Then I receive a notification
-
-  Scenario: Receive notifications when a document is published
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    And I subscribe to 'test-collection'
-    When I publish a document
-    Then I receive a notification
-
-  Scenario: Stop receiving notification when I unsubscribe
-    Given Kuzzle Server is running
-    And there is an index 'test-index'
-    And it has a collection 'test-collection'
-    And the collection has a document with id 'my-document-id'
-    And I subscribe to 'test-collection'
-    And I unsubscribe
-    When I publish a document
-    Then I do not receive a notification
diff --git a/internal/wrappers/features/run_cpp.sh b/internal/wrappers/features/run_cpp.sh
deleted file mode 100644
index d2017860..00000000
--- a/internal/wrappers/features/run_cpp.sh
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/env bash
-set -e
-cd internal/wrappers
-sh ./build_cpp_tests.sh
-
-FEATURE_FILE=$1
-
-if [ -z "$KUZZLE_HOST" ]; then
-  # For debug
-  ./_build_cpp_tests/KuzzleSDKStepDefs &
-else
-  # To hide cucumber debug output in CI
-  ./_build_cpp_tests/KuzzleSDKStepDefs > /dev/null &
-fi
-
-if [ ! -z "$FEATURE_FILE" ]; then
-  cucumber features/$FEATURE_FILE
-else
-  cucumber
-fi
-
-cd -
diff --git a/internal/wrappers/features/run_java.sh b/internal/wrappers/features/run_java.sh
deleted file mode 100755
index 4e290c8e..00000000
--- a/internal/wrappers/features/run_java.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/bash
-set -e
-cd internal/wrappers/features/java
-gradle cucumber
-cd -
diff --git a/internal/wrappers/features/step_definitions/cucumber.wire b/internal/wrappers/features/step_definitions/cucumber.wire
deleted file mode 100644
index 581267b9..00000000
--- a/internal/wrappers/features/step_definitions/cucumber.wire
+++ /dev/null
@@ -1,6 +0,0 @@
-host: localhost
-port: 3902
-timeout:
-  invoke: 30
-  step_matches: 60
-
diff --git a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/CMakeLists.txt b/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/CMakeLists.txt
deleted file mode 100644
index 5c461d1f..00000000
--- a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/CMakeLists.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-find_package(Boost 1.34 REQUIRED)
-
-add_library(json_spirit.header INTERFACE)
-target_sources(json_spirit.header INTERFACE
-    ${CMAKE_CURRENT_SOURCE_DIR}/json_spirit.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/json_spirit_error_position.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/json_spirit_reader_template.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/json_spirit_stream_reader.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/json_spirit_utils.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/json_spirit_value.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/json_spirit_writer_template.h
-)
-target_include_directories(json_spirit.header SYSTEM
-    INTERFACE
-        ${Boost_INCLUDE_DIR}
-        ${CMAKE_CURRENT_SOURCE_DIR}/..
-)
-
-add_library(json_spirit STATIC EXCLUDE_FROM_ALL
-    ${CMAKE_CURRENT_SOURCE_DIR}/json_spirit_reader.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/json_spirit_reader.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/json_spirit_value.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/json_spirit_writer.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/json_spirit_writer.h
-)
-target_link_libraries(json_spirit PUBLIC json_spirit.header)
diff --git a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit.h b/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit.h
deleted file mode 100644
index 7dac05c3..00000000
--- a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef JSON_SPIRIT
-#define JSON_SPIRIT
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include "json_spirit_value.h"
-#include "json_spirit_reader.h"
-#include "json_spirit_writer.h"
-#include "json_spirit_utils.h"
-
-#endif
diff --git a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit.vcproj b/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit.vcproj
deleted file mode 100644
index ed0e5e0c..00000000
--- a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit.vcproj
+++ /dev/null
@@ -1,209 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="8.00"
-	Name="json_spirit_lib"
-	ProjectGUID="{BE262A86-CC26-4B25-A877-883ED2688CEC}"
-	RootNamespace="json_spirit"
-	Keyword="Win32Proj"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="4"
-			CharacterSet="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				AdditionalOptions="&#x0D;&#x0A;"
-				Optimization="0"
-				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="3"
-				DisableLanguageExtensions="false"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="true"
-				DebugInformationFormat="4"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="4"
-			CharacterSet="1"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="2"
-				EnableIntrinsicFunctions="false"
-				FavorSizeOrSpeed="0"
-				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
-				RuntimeLibrary="2"
-				BufferSecurityCheck="false"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="true"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath=".\json_spirit_reader.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\json_spirit_writer.cpp"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-			<File
-				RelativePath=".\json_spirit.h"
-				>
-			</File>
-			<File
-				RelativePath=".\json_spirit_error_position.h"
-				>
-			</File>
-			<File
-				RelativePath=".\json_spirit_reader.h"
-				>
-			</File>
-			<File
-				RelativePath=".\json_spirit_reader_template.h"
-				>
-			</File>
-			<File
-				RelativePath=".\json_spirit_stream_reader.h"
-				>
-			</File>
-			<File
-				RelativePath=".\json_spirit_utils.h"
-				>
-			</File>
-			<File
-				RelativePath=".\json_spirit_value.h"
-				>
-			</File>
-			<File
-				RelativePath=".\json_spirit_writer.h"
-				>
-			</File>
-			<File
-				RelativePath=".\json_spirit_writer_template.h"
-				>
-			</File>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_error_position.h b/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_error_position.h
deleted file mode 100644
index 4a535ff5..00000000
--- a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_error_position.h
+++ /dev/null
@@ -1,54 +0,0 @@
-#ifndef JSON_SPIRIT_ERROR_POSITION
-#define JSON_SPIRIT_ERROR_POSITION
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include <string>
-
-namespace json_spirit
-{
-    // An Error_position exception is thrown by the "read_or_throw" functions below on finding an error.
-    // Note the "read_or_throw" functions are around 3 times slower than the standard functions "read" 
-    // functions that return a bool.
-    //
-    struct Error_position
-    {
-        Error_position();
-        Error_position( unsigned int line, unsigned int column, const std::string& reason );
-        bool operator==( const Error_position& lhs ) const;
-        unsigned int line_;
-        unsigned int column_;
-        std::string reason_;
-    };
-
-    inline Error_position::Error_position()
-    :   line_( 0 )
-    ,   column_( 0 )
-    {
-    }
-
-    inline Error_position::Error_position( unsigned int line, unsigned int column, const std::string& reason )
-    :   line_( line )
-    ,   column_( column )
-    ,   reason_( reason )
-    {
-    }
-
-    inline bool Error_position::operator==( const Error_position& lhs ) const
-    {
-        if( this == &lhs ) return true;
-
-        return ( reason_ == lhs.reason_ ) &&
-               ( line_   == lhs.line_ ) &&
-               ( column_ == lhs.column_ ); 
-}
-}
-
-#endif
diff --git a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_reader.cpp b/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_reader.cpp
deleted file mode 100644
index 8e2fb5e2..00000000
--- a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_reader.cpp
+++ /dev/null
@@ -1,137 +0,0 @@
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#include "json_spirit_reader.h"
-#include "json_spirit_reader_template.h"
-
-using namespace json_spirit;
-
-bool json_spirit::read( const std::string& s, Value& value )
-{
-    return read_string( s, value );
-}
-
-void json_spirit::read_or_throw( const std::string& s, Value& value )
-{
-    read_string_or_throw( s, value );
-}
-
-bool json_spirit::read( std::istream& is, Value& value )
-{
-    return read_stream( is, value );
-}
-
-void json_spirit::read_or_throw( std::istream& is, Value& value )
-{
-    read_stream_or_throw( is, value );
-}
-
-bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
-{
-    return read_range( begin, end, value );
-}
-
-void json_spirit::read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
-{
-    begin = read_range_or_throw( begin, end, value );
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-
-bool json_spirit::read( const std::wstring& s, wValue& value )
-{
-    return read_string( s, value );
-}
-
-void json_spirit::read_or_throw( const std::wstring& s, wValue& value )
-{
-    read_string_or_throw( s, value );
-}
-
-bool json_spirit::read( std::wistream& is, wValue& value )
-{
-    return read_stream( is, value );
-}
-
-void json_spirit::read_or_throw( std::wistream& is, wValue& value )
-{
-    read_stream_or_throw( is, value );
-}
-
-bool json_spirit::read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value )
-{
-    return read_range( begin, end, value );
-}
-
-void json_spirit::read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value )
-{
-    begin = read_range_or_throw( begin, end, value );
-}
-
-#endif
-
-bool json_spirit::read( const std::string& s, mValue& value )
-{
-    return read_string( s, value );
-}
-
-void json_spirit::read_or_throw( const std::string& s, mValue& value )
-{
-    read_string_or_throw( s, value );
-}
-
-bool json_spirit::read( std::istream& is, mValue& value )
-{
-    return read_stream( is, value );
-}
-
-void json_spirit::read_or_throw( std::istream& is, mValue& value )
-{
-    read_stream_or_throw( is, value );
-}
-
-bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
-{
-    return read_range( begin, end, value );
-}
-
-void json_spirit::read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
-{
-    begin = read_range_or_throw( begin, end, value );
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-
-bool json_spirit::read( const std::wstring& s, wmValue& value )
-{
-    return read_string( s, value );
-}
-
-void json_spirit::read_or_throw( const std::wstring& s, wmValue& value )
-{
-    read_string_or_throw( s, value );
-}
-
-bool json_spirit::read( std::wistream& is, wmValue& value )
-{
-    return read_stream( is, value );
-}
-
-void json_spirit::read_or_throw( std::wistream& is, wmValue& value )
-{
-    read_stream_or_throw( is, value );
-}
-
-bool json_spirit::read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value )
-{
-    return read_range( begin, end, value );
-}
-
-void json_spirit::read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value )
-{
-    begin = read_range_or_throw( begin, end, value );
-}
-
-#endif
diff --git a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_reader.h b/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_reader.h
deleted file mode 100644
index a58bfc10..00000000
--- a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_reader.h
+++ /dev/null
@@ -1,62 +0,0 @@
-#ifndef JSON_SPIRIT_READER
-#define JSON_SPIRIT_READER
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include "json_spirit_value.h"
-#include "json_spirit_error_position.h"
-#include <iostream>
-
-namespace json_spirit
-{
-    // functions to reads a JSON values
-
-    bool read( const std::string& s, Value& value );
-    bool read( std::istream& is,     Value& value );
-    bool read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value );
-
-    void read_or_throw( const std::string& s, Value& value );  
-    void read_or_throw( std::istream& is,     Value& value );
-    void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, Value& value );
-
-#ifndef BOOST_NO_STD_WSTRING
-
-    bool read( const std::wstring& s, wValue& value );
-    bool read( std::wistream&  is,    wValue& value );
-    bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value );    
-
-    void read_or_throw( const std::wstring& s, wValue& value );
-    void read_or_throw( std::wistream& is,     wValue& value );
-    void read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value );
-
-#endif
-
-    bool read( const std::string& s, mValue& value );
-    bool read( std::istream& is,     mValue& value );
-    bool read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value );
-
-    void read_or_throw( const std::string& s, mValue& value );  
-    void read_or_throw( std::istream& is,     mValue& value );
-    void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value );
-
-#ifndef BOOST_NO_STD_WSTRING
-
-    bool read( const std::wstring& s, wmValue& value );
-    bool read( std::wistream& is,     wmValue& value );
-    bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value );    
-
-    void read_or_throw( const std::wstring& s, wmValue& value );
-    void read_or_throw( std::wistream& is,     wmValue& value );
-    void read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value );
-
-#endif
-}
-
-#endif
diff --git a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_reader_template.h b/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_reader_template.h
deleted file mode 100644
index 81cded43..00000000
--- a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_reader_template.h
+++ /dev/null
@@ -1,612 +0,0 @@
-#ifndef JSON_SPIRIT_READER_TEMPLATE
-#define JSON_SPIRIT_READER_TEMPLATE
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#include "json_spirit_value.h"
-#include "json_spirit_error_position.h"
-
-//#define BOOST_SPIRIT_THREADSAFE  // uncomment for multithreaded use, requires linking to boost.thread
-
-#include <boost/bind.hpp>
-#include <boost/function.hpp>
-#include <boost/version.hpp>
-
-#if BOOST_VERSION >= 103800
-    #include <boost/spirit/include/classic_core.hpp>
-    #include <boost/spirit/include/classic_confix.hpp>
-    #include <boost/spirit/include/classic_escape_char.hpp>
-    #include <boost/spirit/include/classic_multi_pass.hpp>
-    #include <boost/spirit/include/classic_position_iterator.hpp>
-    #define spirit_namespace boost::spirit::classic
-#else
-    #include <boost/spirit/core.hpp>
-    #include <boost/spirit/utility/confix.hpp>
-    #include <boost/spirit/utility/escape_char.hpp>
-    #include <boost/spirit/iterator/multi_pass.hpp>
-    #include <boost/spirit/iterator/position_iterator.hpp>
-    #define spirit_namespace boost::spirit
-#endif
-
-namespace json_spirit
-{
-    const spirit_namespace::int_parser < boost::int64_t >  int64_p  = spirit_namespace::int_parser < boost::int64_t  >();
-    const spirit_namespace::uint_parser< boost::uint64_t > uint64_p = spirit_namespace::uint_parser< boost::uint64_t >();
-
-    template< class Iter_type >
-    bool is_eq( Iter_type first, Iter_type last, const char* c_str )
-    {
-        for( Iter_type i = first; i != last; ++i, ++c_str )
-        {
-            if( *c_str == 0 ) return false;
-
-            if( *i != *c_str ) return false;
-        }
-
-        return true;
-    }
-
-    template< class Char_type >
-    Char_type hex_to_num( const Char_type c )
-    {
-        if( ( c >= '0' ) && ( c <= '9' ) ) return c - '0';
-        if( ( c >= 'a' ) && ( c <= 'f' ) ) return c - 'a' + 10;
-        if( ( c >= 'A' ) && ( c <= 'F' ) ) return c - 'A' + 10;
-        return 0;
-    }
-
-    template< class Char_type, class Iter_type >
-    Char_type hex_str_to_char( Iter_type& begin )
-    {
-        const Char_type c1( *( ++begin ) );
-        const Char_type c2( *( ++begin ) );
-
-        return ( hex_to_num( c1 ) << 4 ) + hex_to_num( c2 );
-    }       
-
-    template< class Char_type, class Iter_type >
-    Char_type unicode_str_to_char( Iter_type& begin )
-    {
-        const Char_type c1( *( ++begin ) );
-        const Char_type c2( *( ++begin ) );
-        const Char_type c3( *( ++begin ) );
-        const Char_type c4( *( ++begin ) );
-
-        return ( hex_to_num( c1 ) << 12 ) + 
-               ( hex_to_num( c2 ) <<  8 ) + 
-               ( hex_to_num( c3 ) <<  4 ) + 
-               hex_to_num( c4 );
-    }
-
-    template< class String_type >
-    void append_esc_char_and_incr_iter( String_type& s, 
-                                        typename String_type::const_iterator& begin, 
-                                        typename String_type::const_iterator end )
-    {
-        typedef typename String_type::value_type Char_type;
-             
-        const Char_type c2( *begin );
-
-        switch( c2 )
-        {
-            case 't':  s += '\t'; break;
-            case 'b':  s += '\b'; break;
-            case 'f':  s += '\f'; break;
-            case 'n':  s += '\n'; break;
-            case 'r':  s += '\r'; break;
-            case '\\': s += '\\'; break;
-            case '/':  s += '/';  break;
-            case '"':  s += '"';  break;
-            case 'x':  
-            {
-                if( end - begin >= 3 )  //  expecting "xHH..."
-                {
-                    s += hex_str_to_char< Char_type >( begin );  
-                }
-                break;
-            }
-            case 'u':  
-            {
-                if( end - begin >= 5 )  //  expecting "uHHHH..."
-                {
-                    s += unicode_str_to_char< Char_type >( begin );  
-                }
-                break;
-            }
-        }
-    }
-
-    template< class String_type >
-    String_type substitute_esc_chars( typename String_type::const_iterator begin, 
-                                   typename String_type::const_iterator end )
-    {
-        typedef typename String_type::const_iterator Iter_type;
-
-        if( end - begin < 2 ) return String_type( begin, end );
-
-        String_type result;
-        
-        result.reserve( end - begin );
-
-        const Iter_type end_minus_1( end - 1 );
-
-        Iter_type substr_start = begin;
-        Iter_type i = begin;
-
-        for( ; i < end_minus_1; ++i )
-        {
-            if( *i == '\\' )
-            {
-                result.append( substr_start, i );
-
-                ++i;  // skip the '\'
-             
-                append_esc_char_and_incr_iter( result, i, end );
-
-                substr_start = i + 1;
-            }
-        }
-
-        result.append( substr_start, end );
-
-        return result;
-    }
-
-    template< class String_type >
-    String_type get_str_( typename String_type::const_iterator begin, 
-                       typename String_type::const_iterator end )
-    {
-        assert( end - begin >= 2 );
-
-        typedef typename String_type::const_iterator Iter_type;
-
-        Iter_type str_without_quotes( ++begin );
-        Iter_type end_without_quotes( --end );
-
-        return substitute_esc_chars< String_type >( str_without_quotes, end_without_quotes );
-    }
-
-    inline std::string get_str( std::string::const_iterator begin, std::string::const_iterator end )
-    {
-        return get_str_< std::string >( begin, end );
-    }
-
-    inline std::wstring get_str( std::wstring::const_iterator begin, std::wstring::const_iterator end )
-    {
-        return get_str_< std::wstring >( begin, end );
-    }
-    
-    template< class String_type, class Iter_type >
-    String_type get_str( Iter_type begin, Iter_type end )
-    {
-        const String_type tmp( begin, end );  // convert multipass iterators to string iterators
-
-        return get_str( tmp.begin(), tmp.end() );
-    }
-
-    // this class's methods get called by the spirit parse resulting
-    // in the creation of a JSON object or array
-    //
-    // NB Iter_type could be a std::string iterator, wstring iterator, a position iterator or a multipass iterator
-    //
-    template< class Value_type, class Iter_type >
-    class Semantic_actions 
-    {
-    public:
-
-        typedef typename Value_type::Config_type Config_type;
-        typedef typename Config_type::String_type String_type;
-        typedef typename Config_type::Object_type Object_type;
-        typedef typename Config_type::Array_type Array_type;
-        typedef typename String_type::value_type Char_type;
-
-        Semantic_actions( Value_type& value )
-        :   value_( value )
-        ,   current_p_( 0 )
-        {
-        }
-
-        void begin_obj( Char_type c )
-        {
-            assert( c == '{' );
-
-            begin_compound< Object_type >();
-        }
-
-        void end_obj( Char_type c )
-        {
-            assert( c == '}' );
-
-            end_compound();
-        }
-
-        void begin_array( Char_type c )
-        {
-            assert( c == '[' );
-     
-            begin_compound< Array_type >();
-        }
-
-        void end_array( Char_type c )
-        {
-            assert( c == ']' );
-
-            end_compound();
-        }
-
-        void new_name( Iter_type begin, Iter_type end )
-        {
-            assert( current_p_->type() == obj_type );
-
-            name_ = get_str< String_type >( begin, end );
-        }
-
-        void new_str( Iter_type begin, Iter_type end )
-        {
-            add_to_current( get_str< String_type >( begin, end ) );
-        }
-
-        void new_true( Iter_type begin, Iter_type end )
-        {
-            assert( is_eq( begin, end, "true" ) );
-
-            add_to_current( true );
-        }
-
-        void new_false( Iter_type begin, Iter_type end )
-        {
-            assert( is_eq( begin, end, "false" ) );
-
-            add_to_current( false );
-        }
-
-        void new_null( Iter_type begin, Iter_type end )
-        {
-            assert( is_eq( begin, end, "null" ) );
-
-            add_to_current( Value_type() );
-        }
-
-        void new_int( boost::int64_t i )
-        {
-            add_to_current( i );
-        }
-
-        void new_uint64( boost::uint64_t ui )
-        {
-            add_to_current( ui );
-        }
-
-        void new_real( double d )
-        {
-            add_to_current( d );
-        }
-
-    private:
-
-        Semantic_actions& operator=( const Semantic_actions& ); 
-                                    // to prevent "assignment operator could not be generated" warning
-
-        Value_type* add_first( const Value_type& value )
-        {
-            assert( current_p_ == 0 );
-
-            value_ = value;
-            current_p_ = &value_;
-            return current_p_;
-        }
-
-        template< class Array_or_obj >
-        void begin_compound()
-        {
-            if( current_p_ == 0 )
-            {
-                add_first( Array_or_obj() );
-            }
-            else
-            {
-                stack_.push_back( current_p_ );
-
-                Array_or_obj new_array_or_obj;   // avoid copy by building new array or object in place
-
-                current_p_ = add_to_current( new_array_or_obj );
-            }
-        }
-
-        void end_compound()
-        {
-            if( current_p_ != &value_ )
-            {
-                current_p_ = stack_.back();
-                
-                stack_.pop_back();
-            }    
-        }
-
-        Value_type* add_to_current( const Value_type& value )
-        {
-            if( current_p_ == 0 )
-            {
-                return add_first( value );
-            }
-            else if( current_p_->type() == array_type )
-            {
-                current_p_->get_array().push_back( value );
-
-                return &current_p_->get_array().back(); 
-            }
-            
-            assert( current_p_->type() == obj_type );
-
-            return &Config_type::add( current_p_->get_obj(), name_, value );
-        }
-
-        Value_type& value_;             // this is the object or array that is being created
-        Value_type* current_p_;         // the child object or array that is currently being constructed
-
-        std::vector< Value_type* > stack_;   // previous child objects and arrays
-
-        String_type name_;              // of current name/value pair
-    };
-
-    template< typename Iter_type >
-    void throw_error( spirit_namespace::position_iterator< Iter_type > i, const std::string& reason )
-    {
-        throw Error_position( i.get_position().line, i.get_position().column, reason );
-    }
-
-    template< typename Iter_type >
-    void throw_error( Iter_type i, const std::string& reason )
-    {
-       throw reason;
-    }
-
-    // the spirit grammer 
-    //
-    template< class Value_type, class Iter_type >
-    class Json_grammer : public spirit_namespace::grammar< Json_grammer< Value_type, Iter_type > >
-    {
-    public:
-
-        typedef Semantic_actions< Value_type, Iter_type > Semantic_actions_t;
-
-        Json_grammer( Semantic_actions_t& semantic_actions )
-        :   actions_( semantic_actions )
-        {
-        }
-
-        static void throw_not_value( Iter_type begin, Iter_type end )
-        {
-    	    throw_error( begin, "not a value" );
-        }
-
-        static void throw_not_array( Iter_type begin, Iter_type end )
-        {
-    	    throw_error( begin, "not an array" );
-        }
-
-        static void throw_not_object( Iter_type begin, Iter_type end )
-        {
-    	    throw_error( begin, "not an object" );
-        }
-
-        static void throw_not_pair( Iter_type begin, Iter_type end )
-        {
-    	    throw_error( begin, "not a pair" );
-        }
-
-        static void throw_not_colon( Iter_type begin, Iter_type end )
-        {
-    	    throw_error( begin, "no colon in pair" );
-        }
-
-        static void throw_not_string( Iter_type begin, Iter_type end )
-        {
-    	    throw_error( begin, "not a string" );
-        }
-
-        template< typename ScannerT >
-        class definition
-        {
-        public:
-
-            definition( const Json_grammer& self )
-            {
-                using namespace spirit_namespace;
-
-                typedef typename Value_type::String_type::value_type Char_type;
-
-                // first we convert the semantic action class methods to functors with the 
-                // parameter signature expected by spirit
-
-                typedef boost::function< void( Char_type )            > Char_action;
-                typedef boost::function< void( Iter_type, Iter_type ) > Str_action;
-                typedef boost::function< void( double )               > Real_action;
-                typedef boost::function< void( boost::int64_t )       > Int_action;
-                typedef boost::function< void( boost::uint64_t )      > Uint64_action;
-
-                Char_action   begin_obj  ( boost::bind( &Semantic_actions_t::begin_obj,   &self.actions_, _1 ) );
-                Char_action   end_obj    ( boost::bind( &Semantic_actions_t::end_obj,     &self.actions_, _1 ) );
-                Char_action   begin_array( boost::bind( &Semantic_actions_t::begin_array, &self.actions_, _1 ) );
-                Char_action   end_array  ( boost::bind( &Semantic_actions_t::end_array,   &self.actions_, _1 ) );
-                Str_action    new_name   ( boost::bind( &Semantic_actions_t::new_name,    &self.actions_, _1, _2 ) );
-                Str_action    new_str    ( boost::bind( &Semantic_actions_t::new_str,     &self.actions_, _1, _2 ) );
-                Str_action    new_true   ( boost::bind( &Semantic_actions_t::new_true,    &self.actions_, _1, _2 ) );
-                Str_action    new_false  ( boost::bind( &Semantic_actions_t::new_false,   &self.actions_, _1, _2 ) );
-                Str_action    new_null   ( boost::bind( &Semantic_actions_t::new_null,    &self.actions_, _1, _2 ) );
-                Real_action   new_real   ( boost::bind( &Semantic_actions_t::new_real,    &self.actions_, _1 ) );
-                Int_action    new_int    ( boost::bind( &Semantic_actions_t::new_int,     &self.actions_, _1 ) );
-                Uint64_action new_uint64 ( boost::bind( &Semantic_actions_t::new_uint64,  &self.actions_, _1 ) );
-
-                // actual grammer
-
-                json_
-                    = value_ | eps_p[ &throw_not_value ]
-                    ;
-
-                value_
-                    = string_[ new_str ] 
-                    | number_ 
-                    | object_ 
-                    | array_ 
-                    | str_p( "true" ) [ new_true  ] 
-                    | str_p( "false" )[ new_false ] 
-                    | str_p( "null" ) [ new_null  ]
-                    ;
-
-                object_ 
-                    = ch_p('{')[ begin_obj ]
-                    >> !members_
-                    >> ( ch_p('}')[ end_obj ] | eps_p[ &throw_not_object ] )
-                    ;
-
-                members_
-                    = pair_ >> *( ',' >> pair_ )
-                    ;
-
-                pair_
-                    = string_[ new_name ]
-                    >> ( ':' | eps_p[ &throw_not_colon ] )
-                    >> ( value_ | eps_p[ &throw_not_value ] )
-                    ;
-
-                array_
-                    = ch_p('[')[ begin_array ]
-                    >> !elements_
-                    >> ( ch_p(']')[ end_array ] | eps_p[ &throw_not_array ] )
-                    ;
-
-                elements_
-                    = value_ >> *( ',' >> value_ )
-                    ;
-
-                string_ 
-                    = lexeme_d // this causes white space inside a string to be retained
-                      [
-                          confix_p
-                          ( 
-                              '"', 
-                              *lex_escape_ch_p,
-                              '"'
-                          ) 
-                      ]
-                    ;
-
-                number_
-                    = strict_real_p[ new_real   ] 
-                    | int64_p      [ new_int    ]
-                    | uint64_p     [ new_uint64 ]
-                    ;
-            }
-
-            spirit_namespace::rule< ScannerT > json_, object_, members_, pair_, array_, elements_, value_, string_, number_;
-
-            const spirit_namespace::rule< ScannerT >& start() const { return json_; }
-        };
-
-    private:
-
-        Json_grammer& operator=( const Json_grammer& ); // to prevent "assignment operator could not be generated" warning
-
-        Semantic_actions_t& actions_;
-    };
-
-    template< class Iter_type, class Value_type >
-    Iter_type read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value )
-    {
-        Semantic_actions< Value_type, Iter_type > semantic_actions( value );
-     
-        const spirit_namespace::parse_info< Iter_type > info = 
-                            spirit_namespace::parse( begin, end, 
-                                                    Json_grammer< Value_type, Iter_type >( semantic_actions ), 
-                                                    spirit_namespace::space_p );
-
-        if( !info.hit )
-        {
-            assert( false ); // in theory exception should already have been thrown
-            throw_error( info.stop, "error" );
-        }
-
-        return info.stop;
-    }
-
-    template< class Iter_type, class Value_type >
-    void add_posn_iter_and_read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value )
-    {
-        typedef spirit_namespace::position_iterator< Iter_type > Posn_iter_t;
-
-        const Posn_iter_t posn_begin( begin, end );
-        const Posn_iter_t posn_end( end, end );
-     
-        read_range_or_throw( posn_begin, posn_end, value );
-    }
-
-    template< class Iter_type, class Value_type >
-    bool read_range( Iter_type& begin, Iter_type end, Value_type& value )
-    {
-        try
-        {
-            begin = read_range_or_throw( begin, end, value );
-
-            return true;
-        }
-        catch( ... )
-        {
-            return false;
-        }
-    }
-
-    template< class String_type, class Value_type >
-    void read_string_or_throw( const String_type& s, Value_type& value )
-    {
-        add_posn_iter_and_read_range_or_throw( s.begin(), s.end(), value );
-    }
-
-    template< class String_type, class Value_type >
-    bool read_string( const String_type& s, Value_type& value )
-    {
-        typename String_type::const_iterator begin = s.begin();
-
-        return read_range( begin, s.end(), value );
-    }
-
-    template< class Istream_type >
-    struct Multi_pass_iters
-    {
-        typedef typename Istream_type::char_type Char_type;
-        typedef std::istream_iterator< Char_type, Char_type > istream_iter;
-        typedef spirit_namespace::multi_pass< istream_iter > Mp_iter;
-
-        Multi_pass_iters( Istream_type& is )
-        {
-            is.unsetf( std::ios::skipws );
-
-            begin_ = spirit_namespace::make_multi_pass( istream_iter( is ) );
-            end_   = spirit_namespace::make_multi_pass( istream_iter() );
-        }
-
-        Mp_iter begin_;
-        Mp_iter end_;
-    };
-
-    template< class Istream_type, class Value_type >
-    bool read_stream( Istream_type& is, Value_type& value )
-    {
-        Multi_pass_iters< Istream_type > mp_iters( is );
-
-        return read_range( mp_iters.begin_, mp_iters.end_, value );
-    }
-
-    template< class Istream_type, class Value_type >
-    void read_stream_or_throw( Istream_type& is, Value_type& value )
-    {
-        const Multi_pass_iters< Istream_type > mp_iters( is );
-
-        add_posn_iter_and_read_range_or_throw( mp_iters.begin_, mp_iters.end_, value );
-    }
-}
-
-#endif
diff --git a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_stream_reader.h b/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_stream_reader.h
deleted file mode 100644
index a9ceeacf..00000000
--- a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_stream_reader.h
+++ /dev/null
@@ -1,70 +0,0 @@
-#ifndef JSON_SPIRIT_READ_STREAM
-#define JSON_SPIRIT_READ_STREAM
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include "json_spirit_reader_template.h"
-
-namespace json_spirit
-{
-    // these classes allows you to read multiple top level contiguous values from a stream,
-    // the normal stream read functions have a bug that prevent multiple top level values 
-    // from being read unless they are separated by spaces
-
-    template< class Istream_type, class Value_type >
-    class Stream_reader
-    {
-    public:
-
-        Stream_reader( Istream_type& is )
-        :   iters_( is )
-        {
-        }
-
-        bool read_next( Value_type& value )
-        {
-            return read_range( iters_.begin_, iters_.end_, value );
-        }
-
-    private:
-
-        typedef Multi_pass_iters< Istream_type > Mp_iters;
-
-        Mp_iters iters_;
-    };
-
-    template< class Istream_type, class Value_type >
-    class Stream_reader_thrower
-    {
-    public:
-
-        Stream_reader_thrower( Istream_type& is )
-        :   iters_( is )
-        ,    posn_begin_( iters_.begin_, iters_.end_ )
-        ,    posn_end_( iters_.end_, iters_.end_ )
-        {
-        }
-
-        void read_next( Value_type& value )
-        {
-            posn_begin_ = read_range_or_throw( posn_begin_, posn_end_, value );
-        }
-
-    private:
-
-        typedef Multi_pass_iters< Istream_type > Mp_iters;
-        typedef spirit_namespace::position_iterator< typename Mp_iters::Mp_iter > Posn_iter_t;
-
-        Mp_iters iters_;
-        Posn_iter_t posn_begin_, posn_end_;
-    };
-}
-
-#endif
diff --git a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_utils.h b/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_utils.h
deleted file mode 100644
index 7eb338e7..00000000
--- a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_utils.h
+++ /dev/null
@@ -1,61 +0,0 @@
-#ifndef JSON_SPIRIT_UTILS
-#define JSON_SPIRIT_UTILS
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include "json_spirit_value.h"
-#include <map>
-
-namespace json_spirit
-{ 
-    template< class Obj_t, class Map_t >
-    void obj_to_map( const Obj_t& obj, Map_t& mp_obj )
-    {
-        mp_obj.clear();
-
-        for( typename Obj_t::const_iterator i = obj.begin(); i != obj.end(); ++i )
-        {
-            mp_obj[ i->name_ ] = i->value_;
-        }
-    }
-
-    template< class Obj_t, class Map_t >
-    void map_to_obj( const Map_t& mp_obj, Obj_t& obj )
-    {
-        obj.clear();
-
-        for( typename Map_t::const_iterator i = mp_obj.begin(); i != mp_obj.end(); ++i )
-        {
-            obj.push_back( typename Obj_t::value_type( i->first, i->second ) );
-        }
-    }
-
-    typedef std::map< std::string, Value > Mapped_obj;
-
-#ifndef BOOST_NO_STD_WSTRING
-    typedef std::map< std::wstring, wValue > wMapped_obj;
-#endif
-
-    template< class Object_type, class String_type >
-    const typename Object_type::value_type::Value_type& find_value( const Object_type& obj, const String_type& name )
-    {
-        for( typename Object_type::const_iterator i = obj.begin(); i != obj.end(); ++i )
-        {
-            if( i->name_ == name )
-            {
-                return i->value_;
-            }
-        }
-
-        return Object_type::value_type::Value_type::null;
-    }
-}
-
-#endif
diff --git a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_value.cpp b/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_value.cpp
deleted file mode 100644
index dd5b50e5..00000000
--- a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_value.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-/* Copyright (c) 2007 John W Wilkinson
-
-   This source code can be used for any purpose as long as
-   this comment is retained. */
-
-// json spirit version 2.00
-
-#include "json_spirit_value.h"
diff --git a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_value.h b/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_value.h
deleted file mode 100644
index e8be3553..00000000
--- a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_value.h
+++ /dev/null
@@ -1,532 +0,0 @@
-#ifndef JSON_SPIRIT_VALUE
-#define JSON_SPIRIT_VALUE
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include <vector>
-#include <map>
-#include <string>
-#include <cassert>
-#include <sstream>
-#include <stdexcept>
-#include <boost/config.hpp> 
-#include <boost/cstdint.hpp> 
-#include <boost/shared_ptr.hpp> 
-#include <boost/variant.hpp> 
-
-namespace json_spirit
-{
-    enum Value_type{ obj_type, array_type, str_type, bool_type, int_type, real_type, null_type };
-
-    template< class Config >    // Config determines whether the value uses std::string or std::wstring and
-                                // whether JSON Objects are represented as vectors or maps
-    class Value_impl
-    {
-    public:
-
-        typedef Config Config_type;
-        typedef typename Config::String_type String_type;
-        typedef typename Config::Object_type Object;
-        typedef typename Config::Array_type Array;
-        typedef typename String_type::const_pointer Const_str_ptr;  // eg const char*
-
-        Value_impl();  // creates null value
-        Value_impl( Const_str_ptr      value ); 
-        Value_impl( const String_type& value );
-        Value_impl( const Object&      value );
-        Value_impl( const Array&       value );
-        Value_impl( bool               value );
-        Value_impl( int                value );
-        Value_impl( boost::int64_t     value );
-        Value_impl( boost::uint64_t    value );
-        Value_impl( double             value );
-
-        Value_impl( const Value_impl& other );
-
-        bool operator==( const Value_impl& lhs ) const;
-
-        Value_impl& operator=( const Value_impl& lhs );
-
-        Value_type type() const;
-
-        bool is_uint64() const;
-        bool is_null() const;
-
-        const String_type& get_str()    const;
-        const Object&      get_obj()    const;
-        const Array&       get_array()  const;
-        bool               get_bool()   const;
-        int                get_int()    const;
-        boost::int64_t     get_int64()  const;
-        boost::uint64_t    get_uint64() const;
-        double             get_real()   const;
-
-        Object& get_obj();
-        Array&  get_array();
-
-        template< typename T > T get_value() const;  // example usage: int    i = value.get_value< int >();
-                                                     // or             double d = value.get_value< double >();
-
-        static const Value_impl null;
-
-    private:
-
-        void check_type( const Value_type vtype ) const;
-
-        typedef boost::variant< String_type, 
-                                boost::recursive_wrapper< Object >, boost::recursive_wrapper< Array >, 
-                                bool, boost::int64_t, double > Variant;
-
-        Value_type type_;
-        Variant v_;
-        bool is_uint64_;
-    };
-
-    // vector objects
-
-    template< class Config >
-    struct Pair_impl
-    {
-        typedef typename Config::String_type String_type;
-        typedef typename Config::Value_type Value_type;
-
-        Pair_impl( const String_type& name, const Value_type& value );
-
-        bool operator==( const Pair_impl& lhs ) const;
-
-        String_type name_;
-        Value_type value_;
-    };
-
-    template< class String >
-    struct Config_vector
-    {
-        typedef String String_type;
-        typedef Value_impl< Config_vector > Value_type;
-        typedef Pair_impl < Config_vector > Pair_type;
-        typedef std::vector< Value_type > Array_type;
-        typedef std::vector< Pair_type > Object_type;
-
-        static Value_type& add( Object_type& obj, const String_type& name, const Value_type& value )
-        {
-            obj.push_back( Pair_type( name , value ) );
-
-            return obj.back().value_;
-        }
-                
-        static String_type get_name( const Pair_type& pair )
-        {
-            return pair.name_;
-        }
-                
-        static Value_type get_value( const Pair_type& pair )
-        {
-            return pair.value_;
-        }
-    };
-
-    // typedefs for ASCII
-
-    typedef Config_vector< std::string > Config;
-
-    typedef Config::Value_type  Value;
-    typedef Config::Pair_type   Pair;
-    typedef Config::Object_type Object;
-    typedef Config::Array_type  Array;
-
-    // typedefs for Unicode
-
-#ifndef BOOST_NO_STD_WSTRING
-
-    typedef Config_vector< std::wstring > wConfig;
-
-    typedef wConfig::Value_type  wValue;
-    typedef wConfig::Pair_type   wPair;
-    typedef wConfig::Object_type wObject;
-    typedef wConfig::Array_type  wArray;
-#endif
-
-    // map objects
-
-    template< class String >
-    struct Config_map
-    {
-        typedef String String_type;
-        typedef Value_impl< Config_map > Value_type;
-        typedef std::vector< Value_type > Array_type;
-        typedef std::map< String_type, Value_type > Object_type;
-        typedef typename Object_type::value_type Pair_type;
-
-        static Value_type& add( Object_type& obj, const String_type& name, const Value_type& value )
-        {
-            return obj[ name ] = value;
-        }
-                
-        static String_type get_name( const Pair_type& pair )
-        {
-            return pair.first;
-        }
-                
-        static Value_type get_value( const Pair_type& pair )
-        {
-            return pair.second;
-        }
-    };
-
-    // typedefs for ASCII
-
-    typedef Config_map< std::string > mConfig;
-
-    typedef mConfig::Value_type  mValue;
-    typedef mConfig::Object_type mObject;
-    typedef mConfig::Array_type  mArray;
-
-    // typedefs for Unicode
-
-#ifndef BOOST_NO_STD_WSTRING
-
-    typedef Config_map< std::wstring > wmConfig;
-
-    typedef wmConfig::Value_type  wmValue;
-    typedef wmConfig::Object_type wmObject;
-    typedef wmConfig::Array_type  wmArray;
-
-#endif
-
-    ///////////////////////////////////////////////////////////////////////////////////////////////
-    //
-    // implementation
-
-    template< class Config >
-    const Value_impl< Config > Value_impl< Config >::null;
-
-    template< class Config >
-    Value_impl< Config >::Value_impl()
-    :   type_( null_type )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( const Const_str_ptr value )
-    :   type_( str_type )
-    ,   v_( String_type( value ) )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( const String_type& value )
-    :   type_( str_type )
-    ,   v_( value )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( const Object& value )
-    :   type_( obj_type )
-    ,   v_( value )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( const Array& value )
-    :   type_( array_type )
-    ,   v_( value )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( bool value )
-    :   type_( bool_type )
-    ,   v_( value )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( int value )
-    :   type_( int_type )
-    ,   v_( static_cast< boost::int64_t >( value ) )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( boost::int64_t value )
-    :   type_( int_type )
-    ,   v_( value )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( boost::uint64_t value )
-    :   type_( int_type )
-    ,   v_( static_cast< boost::int64_t >( value ) )
-    ,   is_uint64_( true )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( double value )
-    :   type_( real_type )
-    ,   v_( value )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( const Value_impl< Config >& other )
-    :   type_( other.type() )
-    ,   v_( other.v_ )
-    ,   is_uint64_( other.is_uint64_ )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >& Value_impl< Config >::operator=( const Value_impl& lhs )
-    {
-        Value_impl tmp( lhs );
-
-        std::swap( type_, tmp.type_ );
-        std::swap( v_, tmp.v_ );
-        std::swap( is_uint64_, tmp.is_uint64_ );
-
-        return *this;
-    }
-
-    template< class Config >
-    bool Value_impl< Config >::operator==( const Value_impl& lhs ) const
-    {
-        if( this == &lhs ) return true;
-
-        if( type() != lhs.type() ) return false;
-
-        return v_ == lhs.v_; 
-    }
-
-    template< class Config >
-    Value_type Value_impl< Config >::type() const
-    {
-        return type_;
-    }
-
-    template< class Config >
-    bool Value_impl< Config >::is_uint64() const
-    {
-        return is_uint64_;
-    }
-
-    template< class Config >
-    bool Value_impl< Config >::is_null() const
-    {
-        return type() == null_type;
-    }
-
-    template< class Config >
-    void Value_impl< Config >::check_type( const Value_type vtype ) const
-    {
-        if( type() != vtype ) 
-        {
-            std::ostringstream os;
-
-            os << "value type is " << type() << " not " << vtype;
-
-            throw std::runtime_error( os.str() );
-        }
-    }
-
-    template< class Config >
-    const typename Config::String_type& Value_impl< Config >::get_str() const
-    {
-        check_type(  str_type );
-
-        return *boost::get< String_type >( &v_ );
-    }
-
-    template< class Config >
-    const typename Value_impl< Config >::Object& Value_impl< Config >::get_obj() const
-    {
-        check_type( obj_type );
-
-        return *boost::get< Object >( &v_ );
-    }
-     
-    template< class Config >
-    const typename Value_impl< Config >::Array& Value_impl< Config >::get_array() const
-    {
-        check_type(  array_type );
-
-        return *boost::get< Array >( &v_ );
-    }
-     
-    template< class Config >
-    bool Value_impl< Config >::get_bool() const
-    {
-        check_type(  bool_type );
-
-        return boost::get< bool >( v_ );
-    }
-     
-    template< class Config >
-    int Value_impl< Config >::get_int() const
-    {
-        check_type(  int_type );
-
-        return static_cast< int >( get_int64() );
-    }
-    
-    template< class Config >
-    boost::int64_t Value_impl< Config >::get_int64() const
-    {
-        check_type(  int_type );
-
-        return boost::get< boost::int64_t >( v_ );
-    }
-    
-    template< class Config >
-    boost::uint64_t Value_impl< Config >::get_uint64() const
-    {
-        check_type(  int_type );
-
-        return static_cast< boost::uint64_t >( get_int64() );
-    }
-
-    template< class Config >
-    double Value_impl< Config >::get_real() const
-    {
-        if( type() == int_type )
-        {
-            return is_uint64() ? static_cast< double >( get_uint64() )
-                               : static_cast< double >( get_int64() );
-        }
-
-        check_type(  real_type );
-
-        return boost::get< double >( v_ );
-    }
-
-    template< class Config >
-    typename Value_impl< Config >::Object& Value_impl< Config >::get_obj()
-    {
-        check_type(  obj_type );
-
-        return *boost::get< Object >( &v_ );
-    }
-
-    template< class Config >
-    typename Value_impl< Config >::Array& Value_impl< Config >::get_array()
-    {
-        check_type(  array_type );
-
-        return *boost::get< Array >( &v_ );
-    }
-
-    template< class Config >
-    Pair_impl< Config >::Pair_impl( const String_type& name, const Value_type& value )
-    :   name_( name )
-    ,   value_( value )
-    {
-    }
-
-    template< class Config >
-    bool Pair_impl< Config >::operator==( const Pair_impl< Config >& lhs ) const
-    {
-        if( this == &lhs ) return true;
-
-        return ( name_ == lhs.name_ ) && ( value_ == lhs.value_ );
-    }
-
-    // converts a C string, ie. 8 bit char array, to a string object
-    //
-    template < class String_type >
-    String_type to_str( const char* c_str )
-    {
-        String_type result;
-
-        for( const char* p = c_str; *p != 0; ++p )
-        {
-            result += *p;
-        }
-
-        return result;
-    }
-
-    //
-
-    namespace internal_
-    {
-        template< typename T >
-        struct Type_to_type
-        {
-        };
-
-        template< class Value > 
-        int get_value( const Value& value, Type_to_type< int > )
-        {
-            return value.get_int();
-        }
-       
-        template< class Value > 
-        boost::int64_t get_value( const Value& value, Type_to_type< boost::int64_t > )
-        {
-            return value.get_int64();
-        }
-       
-        template< class Value > 
-        boost::uint64_t get_value( const Value& value, Type_to_type< boost::uint64_t > )
-        {
-            return value.get_uint64();
-        }
-       
-        template< class Value > 
-        double get_value( const Value& value, Type_to_type< double > )
-        {
-            return value.get_real();
-        }
-       
-        template< class Value > 
-        typename Value::String_type get_value( const Value& value, Type_to_type< typename Value::String_type > )
-        {
-            return value.get_str();
-        }
-       
-        template< class Value > 
-        typename Value::Array get_value( const Value& value, Type_to_type< typename Value::Array > )
-        {
-            return value.get_array();
-        }
-       
-        template< class Value > 
-        typename Value::Object get_value( const Value& value, Type_to_type< typename Value::Object > )
-        {
-            return value.get_obj();
-        }
-       
-        template< class Value > 
-        bool get_value( const Value& value, Type_to_type< bool > )
-        {
-            return value.get_bool();
-        }
-    }
-
-    template< class Config >
-    template< typename T > 
-    T Value_impl< Config >::get_value() const
-    {
-        return internal_::get_value( *this, internal_::Type_to_type< T >() );
-    }
-}
-
-#endif
diff --git a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_writer.cpp b/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_writer.cpp
deleted file mode 100644
index f3367b68..00000000
--- a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_writer.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#include "json_spirit_writer.h"
-#include "json_spirit_writer_template.h"
-
-void json_spirit::write( const Value& value, std::ostream& os )
-{
-    write_stream( value, os, false );
-}
-
-void json_spirit::write_formatted( const Value& value, std::ostream& os )
-{
-    write_stream( value, os, true );
-}
-
-std::string json_spirit::write( const Value& value )
-{
-    return write_string( value, false );
-}
-
-std::string json_spirit::write_formatted( const Value& value )
-{
-    return write_string( value, true );
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-
-void json_spirit::write( const wValue& value, std::wostream& os )
-{
-    write_stream( value, os, false );
-}
-
-void json_spirit::write_formatted( const wValue& value, std::wostream& os )
-{
-    write_stream( value, os, true );
-}
-
-std::wstring json_spirit::write( const wValue&  value )
-{
-    return write_string( value, false );
-}
-
-std::wstring json_spirit::write_formatted( const wValue&  value )
-{
-    return write_string( value, true );
-}
-
-#endif
-
-void json_spirit::write( const mValue& value, std::ostream& os )
-{
-    write_stream( value, os, false );
-}
-
-void json_spirit::write_formatted( const mValue& value, std::ostream& os )
-{
-    write_stream( value, os, true );
-}
-
-std::string json_spirit::write( const mValue& value )
-{
-    return write_string( value, false );
-}
-
-std::string json_spirit::write_formatted( const mValue& value )
-{
-    return write_string( value, true );
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-
-void json_spirit::write( const wmValue& value, std::wostream& os )
-{
-    write_stream( value, os, false );
-}
-
-void json_spirit::write_formatted( const wmValue& value, std::wostream& os )
-{
-    write_stream( value, os, true );
-}
-
-std::wstring json_spirit::write( const wmValue&  value )
-{
-    return write_string( value, false );
-}
-
-std::wstring json_spirit::write_formatted( const wmValue&  value )
-{
-    return write_string( value, true );
-}
-
-#endif
diff --git a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_writer.h b/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_writer.h
deleted file mode 100644
index 1b67b512..00000000
--- a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_writer.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef JSON_SPIRIT_WRITER
-#define JSON_SPIRIT_WRITER
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include "json_spirit_value.h"
-#include <iostream>
-
-namespace json_spirit
-{
-    // functions to convert JSON Values to text, 
-    // the "formatted" versions add whitespace to format the output nicely
-
-    void         write          ( const Value& value, std::ostream&  os );
-    void         write_formatted( const Value& value, std::ostream&  os );
-    std::string  write          ( const Value& value );
-    std::string  write_formatted( const Value& value );
-
-#ifndef BOOST_NO_STD_WSTRING
-
-    void         write          ( const wValue& value, std::wostream& os );
-    void         write_formatted( const wValue& value, std::wostream& os );
-    std::wstring write          ( const wValue& value );
-    std::wstring write_formatted( const wValue& value );
-
-#endif
-
-    void         write          ( const mValue& value, std::ostream&  os );
-    void         write_formatted( const mValue& value, std::ostream&  os );
-    std::string  write          ( const mValue& value );
-    std::string  write_formatted( const mValue& value );
-
-#ifndef BOOST_NO_STD_WSTRING
-
-    void         write          ( const wmValue& value, std::wostream& os );
-    void         write_formatted( const wmValue& value, std::wostream& os );
-    std::wstring write          ( const wmValue& value );
-    std::wstring write_formatted( const wmValue& value );
-
-#endif
-}
-
-#endif
diff --git a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_writer_template.h b/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_writer_template.h
deleted file mode 100644
index 87b528b9..00000000
--- a/internal/wrappers/features/step_defs_cpp/3rdparty/json_spirit/json_spirit_writer_template.h
+++ /dev/null
@@ -1,246 +0,0 @@
-#ifndef JSON_SPIRIT_WRITER_TEMPLATE
-#define JSON_SPIRIT_WRITER_TEMPLATE
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#include "json_spirit_value.h"
-
-#include <cassert>
-#include <cwctype>
-#include <sstream>
-#include <iomanip>
-
-namespace json_spirit
-{
-    inline char to_hex_char( unsigned int c )
-    {
-        assert( c <= 0xF );
-
-        const char ch = static_cast< char >( c );
-
-        if( ch < 10 ) return '0' + ch;
-
-        return 'A' - 10 + ch;
-    }
-
-    template< class String_type >
-    String_type non_printable_to_string( unsigned int c )
-    {
-        typedef typename String_type::value_type Char_type;
-
-        String_type result( 6, '\\' );
-
-        result[1] = 'u';
-
-        result[ 5 ] = to_hex_char( c & 0x000F ); c >>= 4;
-        result[ 4 ] = to_hex_char( c & 0x000F ); c >>= 4;
-        result[ 3 ] = to_hex_char( c & 0x000F ); c >>= 4;
-        result[ 2 ] = to_hex_char( c & 0x000F );
-
-        return result;
-    }
-
-    template< typename Char_type, class String_type >
-    bool add_esc_char( Char_type c, String_type& s )
-    {
-        switch( c )
-        {
-            case '"':  s += to_str< String_type >( "\\\"" ); return true;
-            case '\\': s += to_str< String_type >( "\\\\" ); return true;
-            case '\b': s += to_str< String_type >( "\\b"  ); return true;
-            case '\f': s += to_str< String_type >( "\\f"  ); return true;
-            case '\n': s += to_str< String_type >( "\\n"  ); return true;
-            case '\r': s += to_str< String_type >( "\\r"  ); return true;
-            case '\t': s += to_str< String_type >( "\\t"  ); return true;
-        }
-
-        return false;
-    }
-
-    template< class String_type >
-    String_type add_esc_chars( const String_type& s )
-    {
-        typedef typename String_type::const_iterator Iter_type;
-        typedef typename String_type::value_type     Char_type;
-
-        String_type result;
-
-        const Iter_type end( s.end() );
-
-        for( Iter_type i = s.begin(); i != end; ++i )
-        {
-            const Char_type c( *i );
-
-            if( add_esc_char( c, result ) ) continue;
-
-            const wint_t unsigned_c( ( c >= 0 ) ? c : 256 + c );
-
-            if( std::iswprint( unsigned_c ) )
-            {
-                result += c;
-            }
-            else
-            {
-                result += non_printable_to_string< String_type >( unsigned_c );
-            }
-        }
-
-        return result;
-    }
-
-    // this class generates the JSON text,
-    // it keeps track of the indentation level etc.
-    //
-    template< class Value_type, class Ostream_type >
-    class Generator
-    {
-        typedef typename Value_type::Config_type Config_type;
-        typedef typename Config_type::String_type String_type;
-        typedef typename Config_type::Object_type Object_type;
-        typedef typename Config_type::Array_type Array_type;
-        typedef typename String_type::value_type Char_type;
-        typedef typename Object_type::value_type Obj_member_type;
-
-    public:
-
-        Generator( const Value_type& value, Ostream_type& os, bool pretty )
-        :   os_( os )
-        ,   indentation_level_( 0 )
-        ,   pretty_( pretty )
-        {
-            output( value );
-        }
-
-    private:
-
-        void output( const Value_type& value )
-        {
-            switch( value.type() )
-            {
-                case obj_type:   output( value.get_obj() );   break;
-                case array_type: output( value.get_array() ); break;
-                case str_type:   output( value.get_str() );   break;
-                case bool_type:  output( value.get_bool() );  break;
-                case int_type:   output_int( value );         break;
-                case real_type:  os_ << std::showpoint << std::setprecision( 16 ) 
-                                     << value.get_real();     break;
-                case null_type:  os_ << "null";               break;
-                default: assert( false );
-            }
-        }
-
-        void output( const Object_type& obj )
-        {
-            output_array_or_obj( obj, '{', '}' );
-        }
-
-        void output( const Array_type& arr )
-        {
-            output_array_or_obj( arr, '[', ']' );
-        }
-
-        void output( const Obj_member_type& member )
-        {
-            output( Config_type::get_name( member ) ); space(); 
-            os_ << ':'; space(); 
-            output( Config_type::get_value( member ) );
-        }
-
-        void output_int( const Value_type& value )
-        {
-            if( value.is_uint64() )
-            {
-                os_ << value.get_uint64();
-            }
-            else
-            {
-               os_ << value.get_int64();
-            }
-        }
-
-        void output( const String_type& s )
-        {
-            os_ << '"' << add_esc_chars( s ) << '"';
-        }
-
-        void output( bool b )
-        {
-            os_ << to_str< String_type >( b ? "true" : "false" );
-        }
-
-        template< class T >
-        void output_array_or_obj( const T& t, Char_type start_char, Char_type end_char )
-        {
-            os_ << start_char; new_line();
-
-            ++indentation_level_;
-            
-            for( typename T::const_iterator i = t.begin(); i != t.end(); ++i )
-            {
-                indent(); output( *i );
-
-                typename T::const_iterator next = i;
-
-                if( ++next != t.end())
-                {
-                    os_ << ',';
-                }
-
-                new_line();
-            }
-
-            --indentation_level_;
-
-            indent(); os_ << end_char;
-        }
-        
-        void indent()
-        {
-            if( !pretty_ ) return;
-
-            for( int i = 0; i < indentation_level_; ++i )
-            { 
-                os_ << "    ";
-            }
-        }
-
-        void space()
-        {
-            if( pretty_ ) os_ << ' ';
-        }
-
-        void new_line()
-        {
-            if( pretty_ ) os_ << '\n';
-        }
-
-        Generator& operator=( const Generator& ); // to prevent "assignment operator could not be generated" warning
-
-        Ostream_type& os_;
-        int indentation_level_;
-        bool pretty_;
-    };
-
-    template< class Value_type, class Ostream_type >
-    void write_stream( const Value_type& value, Ostream_type& os, bool pretty )
-    {
-        Generator< Value_type, Ostream_type >( value, os, pretty );
-    }
-
-    template< class Value_type >
-    typename Value_type::String_type write_string( const Value_type& value, bool pretty )
-    {
-        typedef typename Value_type::String_type::value_type Char_type;
-
-        std::basic_ostringstream< Char_type > os;
-
-        write_stream( value, os, pretty );
-
-        return os.str();
-    }
-}
-
-#endif
diff --git a/internal/wrappers/features/step_defs_cpp/CMakeLists.txt b/internal/wrappers/features/step_defs_cpp/CMakeLists.txt
deleted file mode 100644
index 46bd2f6c..00000000
--- a/internal/wrappers/features/step_defs_cpp/CMakeLists.txt
+++ /dev/null
@@ -1,118 +0,0 @@
-cmake_minimum_required(VERSION 3.0.0)
-project(KuzzleSKDTests)
-
-include(ExternalProject)
-
-#
-# Cucumber CPP
-#
-
-ExternalProject_Add(
-    project_cucumber_cpp
-    GIT_REPOSITORY https://github.com/cucumber/cucumber-cpp
-    INSTALL_COMMAND ""
-
-    CMAKE_CACHE_ARGS
-      -DCUKE_DISABLE_QT:BOOL=ON 
-      -DCUKE_ENABLE_EXAMPLES:BOOL=OFF 
-      -DCUKE_DISABLE_GTEST:BOOL=ON
-      -DCUKE_DISABLE_UNIT_TESTS:BOOL=ON
-      -DCUKE_DISABLE_E2E_TESTS:BOOL=ON
-)
-
-# Library
-ExternalProject_Get_Property(project_cucumber_cpp binary_dir)
-set(CUCUMBER_CPP_LIBRARY_PATH ${binary_dir}/${CMAKE_FIND_SOURCE_PREFIXES}/src/libcucumber-cpp.a)
-list( APPEND CUCUMBER_CPP_INCLUDE_PATH "${binary_dir}/${CMAKE_FIND_SOURCE_PREFIXES}/src")
-set(CUCUMBER_CPP_LIBRARY cucumber-cpp)
-
-
-ExternalProject_Get_property(project_cucumber_cpp SOURCE_DIR)
-list(APPEND CUCUMBER_CPP_INCLUDE_PATH "${SOURCE_DIR}/include")
-
-message("cucumber-cpp: include path  = ${CUCUMBER_CPP_INCLUDE_PATH}")
-message("cucumber-cpp: library parh = ${CUCUMBER_CPP_LIBRARY_PATH}")
-
-# Workaround to avoid CMake to discard include path that doesn't exist yet
-file(MAKE_DIRECTORY ${binary_dir}/${CMAKE_FIND_SOURCE_PREFIXES}/src)
-file(MAKE_DIRECTORY ${SOURCE_DIR}/include)
-
-add_library(cucumber-cpp STATIC IMPORTED) # or STATIC instead of SHARED
-add_dependencies(cucumber-cpp project_cucumber_cpp)
-set_target_properties(cucumber-cpp PROPERTIES
-    IMPORTED_LOCATION ${CUCUMBER_CPP_LIBRARY_PATH}
-    INTERFACE_INCLUDE_DIRECTORIES  
-        "${CUCUMBER_CPP_INCLUDE_PATH}"
-    DEPENDS project_cucumber_cpp
-)
-
-#
-# JSon Spirit
-#
-
-add_subdirectory(3rdparty/json_spirit)
-
-#
-# Kuzzle SDK 
-#
-
-get_filename_component(KUZZLE_SDK_ROOT "${CMAKE_SOURCE_DIR}/../../" ABSOLUTE)
-message("Kuzzle SDK root: ${KUZZLE_SDK_ROOT}")
-
-#
-# Boost
-#
-set(BOOST_MIN_VERSION "1.46")
-
-set(Boost_USE_STATIC_RUNTIME OFF)
-set(CUKE_CORE_BOOST_LIBS thread system regex date_time program_options filesystem)
-if(NOT CUKE_DISABLE_BOOST_TEST)
-    # "An external test runner utility is required to link with dynamic library" (Boost User's Guide)
-    set(Boost_USE_STATIC_LIBS OFF)
-    set(CMAKE_CXX_FLAGS "-DBOOST_TEST_DYN_LINK ${CMAKE_CXX_FLAGS}")
-    find_package(Boost ${BOOST_MIN_VERSION} COMPONENTS unit_test_framework)
-endif()
-
-if(CUKE_USE_STATIC_BOOST)
-    set(Boost_USE_STATIC_LIBS ON)
-    find_package(Boost ${BOOST_MIN_VERSION} COMPONENTS ${CUKE_CORE_BOOST_LIBS} REQUIRED)
-
-    if(NOT MSVC)
-        find_package(Threads)
-        set(CUKE_EXTRA_LIBRARIES ${CUKE_EXTRA_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
-    endif()
-else()
-    set(CMAKE_CXX_FLAGS "-DBOOST_ALL_DYN_LINK ${CMAKE_CXX_FLAGS}")
-    set(Boost_USE_STATIC_LIBS OFF)
-    find_package(Boost ${BOOST_MIN_VERSION} COMPONENTS ${CUKE_CORE_BOOST_LIBS} REQUIRED)
-endif()
-
-include_directories(${Boost_INCLUDE_DIRS})
-set(CUKE_EXTRA_LIBRARIES ${CUKE_EXTRA_LIBRARIES} ${Boost_THREAD_LIBRARY} ${Boost_SYSTEM_LIBRARY} ${Boost_REGEX_LIBRARY} ${Boost_DATE_TIME_LIBRARY} ${Boost_PROGRAM_OPTIONS_LIBRARY} ${Boost_FILESYSTEM_LIBRARY})
-
-
-if(Boost_UNIT_TEST_FRAMEWORK_FOUND)
-    set (CMAKE_CXX_STANDARD 11)
-
-    FILE(GLOB SRCFILES *.cpp)
-    add_executable(KuzzleSDKStepDefs ${SRCFILES})
-    add_dependencies(KuzzleSDKStepDefs project_cucumber_cpp)
-
-
-    add_library(kuzzlesdk SHARED IMPORTED) # or STATIC instead of SHARED
-    set_target_properties(kuzzlesdk PROPERTIES
-    IMPORTED_LOCATION "${KUZZLE_SDK_ROOT}/build/c/libkuzzlesdk.a" 
-    INTERFACE_INCLUDE_DIRECTORIES "${KUZZLE_SDK_ROOT}/build/c"
-    )
-
-    add_library(cpp SHARED IMPORTED) # or STATIC instead of SHARED
-    set_target_properties(cpp PROPERTIES
-    IMPORTED_LOCATION  "${KUZZLE_SDK_ROOT}/build/cpp/libcpp.a"
-    INTERFACE_INCLUDE_DIRECTORIES "${KUZZLE_SDK_ROOT}/headers"
-    )
-
-    target_link_libraries(KuzzleSDKStepDefs cpp kuzzlesdk  pthread cucumber-cpp  json_spirit ${CUKE_EXTRA_LIBRARIES} ${CUKE_LIBRARIES} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY} )
-else()
-    message(FATAL_ERROR)
-endif()
-
diff --git a/internal/wrappers/features/step_defs_cpp/collection-steps.cpp b/internal/wrappers/features/step_defs_cpp/collection-steps.cpp
deleted file mode 100644
index 0c750c51..00000000
--- a/internal/wrappers/features/step_defs_cpp/collection-steps.cpp
+++ /dev/null
@@ -1,217 +0,0 @@
-#include "steps.hpp"
-
-// Anonymous namespace to handle a linker error
-// see https://stackoverflow.com/questions/14320148/linker-error-on-cucumber-cpp-when-dealing-with-multiple-feature-files
-namespace {
-  WHEN("^I create a collection \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(string, collection_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      ctx->kuzzle->collection->create(ctx->index, collection_id);
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  THEN("^the collection \'([^\"]*)\' should exist$")
-  {
-    REGEX_PARAM(string, collection_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    BOOST_CHECK(ctx->kuzzle->collection->exists(ctx->index, collection_id) == true);
-  }
-
-  WHEN("^I check if the collection \'([^\"]*)\' exists$")
-  {
-    REGEX_PARAM(string, collection_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    ctx->success = ctx->kuzzle->collection->exists(ctx->index, collection_id) ? 1 : 0;
-  }
-
-  THEN("^the collection should exist$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    BOOST_CHECK(ctx->success == 1);
-  }
-
-  GIVEN("^it has a collection \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(string, collection_name);
-
-    ScenarioScope<KuzzleCtx> ctx;
-    ctx->collection = collection_name;
-
-    K_LOG_D("Creating collection: %s", collection_name.c_str());
-    try {
-      ctx->kuzzle->collection->create(ctx->index, ctx->collection);
-    } catch (KuzzleException e) {
-      K_LOG_E(e.getMessage().c_str());
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  WHEN("^I list the collections of \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(string, index_name);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    ctx->content = ctx->kuzzle->collection->list(index_name);
-
-    json_spirit::Value collectionsList;
-    json_spirit::read(ctx->content, collectionsList);
-    json_spirit::Value field_value = json_spirit::find_value(collectionsList.get_obj(), "collections");
-
-    ctx->hits = field_value.get_array().size();
-  }
-
-  GIVEN("^the collection has a document with id \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(string, document_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    query_options options = {0};
-    options.refresh = const_cast<char*>("wait_for");
-
-    ctx->kuzzle->document->create(ctx->index, ctx->collection, document_id, "{\"a\":\"document\"}", &options);
-  }
-
-  WHEN("^I truncate the collection \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(string, collection_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    query_options options = {0};
-    options.refresh = const_cast<char*>("wait_for");
-
-    ctx->kuzzle->collection->truncate(ctx->index, collection_id, &options);
-  }
-
-  THEN("^the collection \'([^\"]*)\' should be empty$")
-  {
-    REGEX_PARAM(string, collection_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    search_result *result = ctx->kuzzle->document->search(ctx->index, collection_id, "{}");
-
-    BOOST_CHECK(result->total == 0);
-
-    kuzzle_free_search_result(result);
-  }
-
-  WHEN("^I update the mapping of collection \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(string, collection_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    string mapping = "{\"properties\": {\"gordon\": {\"type\": \"keyword\"}}}";
-
-    ctx->kuzzle->collection->updateMapping(ctx->index, collection_id, mapping);
-  }
-
-  THEN("^the mapping of \'([^\"]*)\' should be updated$")
-  {
-    REGEX_PARAM(string, collection_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    string mapping = ctx->kuzzle->collection->getMapping(ctx->index, collection_id);
-
-    BOOST_CHECK(mapping.find("\"gordon\":{\"type\":\"keyword\"}") != string::npos);
-  }
-
-  WHEN("^I update the specifications of the collection \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(string, collection_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    string specifications = "{\"" + ctx->index + "\":{\""+ collection_id +"\":{\"strict\":false}}}";
-
-    ctx->kuzzle->collection->updateSpecifications(ctx->index, collection_id, specifications);
-  }
-
-  THEN("^the specifications of \'([^\"]*)\' should be updated$")
-  {
-    REGEX_PARAM(string, collection_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    string specifications = ctx->kuzzle->collection->getSpecifications(ctx->index, collection_id);
-    string expected_specifications = "{\"validation\":{\"strict\":false},\"index\":\"" + ctx->index + "\",\"collection\":\"" + collection_id + "\"}";
-
-    BOOST_CHECK(specifications == expected_specifications);
-
-    ctx->kuzzle->collection->updateSpecifications(ctx->index, collection_id, "{\"" + ctx->index + "\":{\""+ collection_id +"\":{\"strict\":true}}}");
-  }
-
-  WHEN("^I validate the specifications of \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(string, collection_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    string specifications = "{\"" + ctx->index + "\":{\"" + collection_id + "\":{\"strict\":true}}}";
-
-    ctx->success = ctx->kuzzle->collection->validateSpecifications(specifications) ? 1 : 0;
-  }
-
-  THEN("^they should be validated$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    BOOST_CHECK(ctx->success == 1);
-  }
-
-  GIVEN("^has specifications$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    string specifications = "{\"" + ctx->index + "\":{\""+ ctx->collection +"\":{\"strict\":true}}}";
-
-    ctx->kuzzle->collection->updateSpecifications(ctx->index, ctx->collection, specifications);
-  }
-
-  WHEN("^I delete the specifications of \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(string, collection_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    ctx->kuzzle->collection->deleteSpecifications(ctx->index, collection_id);
-  }
-
-  THEN("^the specifications of \'([^\"]*)\' must not exist$")
-  {
-    REGEX_PARAM(string, collection_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    BOOST_CHECK(ctx->kuzzle->collection->getSpecifications(ctx->index, collection_id) == "");
-  }
-
-  WHEN("^I create a collection \'([^\"]*)\' with a mapping$")
-  {
-    REGEX_PARAM(string, collection_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-    string mapping = "{\"properties\": {\"gordon\": {\"type\": \"keyword\"}}}";
-
-    try {
-      ctx->kuzzle->collection->create(ctx->index, collection_id, &mapping);
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-}
diff --git a/internal/wrappers/features/step_defs_cpp/document-steps.cpp b/internal/wrappers/features/step_defs_cpp/document-steps.cpp
deleted file mode 100644
index d4a19f46..00000000
--- a/internal/wrappers/features/step_defs_cpp/document-steps.cpp
+++ /dev/null
@@ -1,389 +0,0 @@
-#include "steps.hpp"
-
-// Anonymous namespace to handle a linker error
-// see https://stackoverflow.com/questions/14320148/linker-error-on-cucumber-cpp-when-dealing-with-multiple-feature-files
-namespace {
-  WHEN("^I create a document with id \'([^\"]*)\'$") {
-    REGEX_PARAM(std::string, document_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      query_options options = {0};
-      options.refresh = const_cast<char*>("wait_for");
-
-      ctx->kuzzle->document->create(ctx->index, ctx->collection, document_id, "{\"a\":\"document\"}", &options);
-      ctx->success = 1;
-    } catch (KuzzleException e) {
-      ctx->success = 0;
-      ctx->error_message = e.getMessage();
-    }
-  }
-
-  THEN("^I get an error with message \'([^\"]*)\'$") {
-    REGEX_PARAM(std::string, error_message);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    BOOST_CHECK(ctx->success == 0);
-    BOOST_CHECK(ctx->error_message == error_message);
-  }
-
-  THEN("^the document is successfully created$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    BOOST_CHECK(ctx->success == 1);
-  }
-
-  GIVEN("^the collection doesn't have a document with id \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(std::string, document_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      query_options options = {0};
-      options.refresh = const_cast<char*>("wait_for");
-
-      ctx->kuzzle->document->delete_(ctx->index, ctx->collection, document_id, &options);
-    } catch (KuzzleException e) {
-      ctx->error_message = e.getMessage();
-      ctx->success = 0;
-    }
-  }
-
-  WHEN("^I createOrReplace a document with id \'([^\"]*)\'$") {
-    REGEX_PARAM(std::string, document_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      query_options options = {0};
-      options.refresh = const_cast<char*>("wait_for");
-
-      ctx->kuzzle->document->createOrReplace(ctx->index, ctx->collection, document_id, "{\"a\":\"replaced document\"}", &options);
-      ctx->document_id = document_id;
-      ctx->success = 1;
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  THEN("^the document is successfully replaced$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    string document = ctx->kuzzle->document->get(ctx->index, ctx->collection, ctx->document_id);
-
-    BOOST_CHECK(ctx->success == 1);
-    BOOST_CHECK(document.find("replaced document") != std::string::npos);
-  }
-
-  WHEN("^I replace a document with id \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(std::string, document_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      query_options options = {0};
-      options.refresh = const_cast<char*>("wait_for");
-
-      ctx->kuzzle->document->replace(ctx->index, ctx->collection, document_id, "{\"a\":\"replaced document\"}", &options);
-      ctx->document_id = document_id;
-      ctx->success = 1;
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  THEN("^the document is successfully deleted$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    BOOST_CHECK(ctx->success == 1);
-  }
-
-  WHEN("^I update a document with id \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(std::string, document_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      query_options options = {0};
-      options.refresh = const_cast<char*>("wait_for");
-
-      ctx->kuzzle->document->update(ctx->index, ctx->collection, document_id, "{\"a\":\"updated document\"}", &options);
-      ctx->document_id = document_id;
-      ctx->success = 1;
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  THEN("^the document is successfully updated$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    string document = ctx->kuzzle->document->get(ctx->index, ctx->collection, ctx->document_id);
-
-    BOOST_CHECK(ctx->success == 1);
-    BOOST_CHECK(document.find("updated document") != std::string::npos);
-  }
-
-  WHEN("^I search a document with id \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(std::string, document_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      ctx->documents = ctx->kuzzle->document->search(ctx->index, ctx->collection, "{\"query\": {\"bool\": {\"should\":[{\"match\":{\"_id\": \"" + document_id + "\"}}]}}}");
-      ctx->success = 1;
-    } catch (KuzzleException e) {
-      kuzzle_free_search_result(ctx->documents);
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  THEN("^the document is (successfully|not) found$")
-  {
-    REGEX_PARAM(std::string, search_status);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    BOOST_CHECK(ctx->success == 1);
-
-    if (search_status == "successfully")
-      BOOST_CHECK(ctx->documents->total == 1);
-    else
-      BOOST_CHECK(ctx->documents->total == 0);
-
-    kuzzle_free_search_result(ctx->documents);
-  }
-
-  WHEN("^I count how many documents there is in the collection$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      ctx->hits = ctx->kuzzle->document->count(ctx->index, ctx->collection, "{}");
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  WHEN("^I delete the documents \\[\'(.*)\', \'(.*)\'\\]$")
-  {
-    REGEX_PARAM(std::string, document1_id);
-    REGEX_PARAM(std::string, document2_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      query_options options = {0};
-      options.refresh = const_cast<char*>("wait_for");
-
-      std::vector<string> document_ids;
-      document_ids.push_back(document1_id);
-      document_ids.push_back(document2_id);
-
-      ctx->kuzzle->document->mDelete(ctx->index, ctx->collection, document_ids, &options);
-      ctx->success = 1;
-      ctx->partial_exception = 0;
-    } catch (PartialException e) {
-      ctx->partial_exception = 1;
-      ctx->success = 0;
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  THEN("^I must have (\\d+) documents in the collection$")
-  {
-    REGEX_PARAM(unsigned int, documents_count);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      BOOST_CHECK(ctx->kuzzle->document->count(ctx->index, ctx->collection, "{}") == documents_count);
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  WHEN("^I create the documents \\[\'(.*)\', \'(.*)\'\\]$")
-  {
-    REGEX_PARAM(std::string, document1_id);
-    REGEX_PARAM(std::string, document2_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      query_options options = {0};
-      options.refresh = const_cast<char*>("wait_for");
-
-      string documents = "{\"documents\":[{\"_id\":\"" + document1_id + "\", \"body\":{}}, {\"_id\":\"" + document2_id + "\", \"body\":{}}]}";
-      ctx->kuzzle->document->mCreate(ctx->index, ctx->collection, documents, &options);
-      ctx->success = 1;
-      ctx->partial_exception = 0;
-    } catch (PartialException e) {
-      ctx->partial_exception = 1;
-      ctx->success = 0;
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  WHEN("^I replace the documents \\[\'(.*)\', \'(.*)\'\\]$")
-  {
-    REGEX_PARAM(std::string, document1_id);
-    REGEX_PARAM(std::string, document2_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      query_options options = {0};
-      options.refresh = const_cast<char*>("wait_for");
-
-      string documents = "{\"documents\":[{\"_id\":\"" + document1_id + "\", \"body\":{\"a\":\"replaced document\"}}, {\"_id\":\"" + document2_id + "\", \"body\":{\"a\":\"replaced document\"}}]}";
-      ctx->kuzzle->document->mReplace(ctx->index, ctx->collection, documents, &options);
-      ctx->success = 1;
-      ctx->partial_exception = 0;
-    } catch (PartialException e) {
-      ctx->partial_exception = 1;
-      ctx->success = 0;
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  THEN("^the document \'([^\"]*)\' should be replaced$")
-  {
-    REGEX_PARAM(std::string, document_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    string document = ctx->kuzzle->document->get(ctx->index, ctx->collection, document_id);
-
-    BOOST_CHECK(document.find("replaced document") != std::string::npos);
-  }
-
-  WHEN("^I update the documents \\[\'(.*)\', \'(.*)\'\\]$")
-  {
-    REGEX_PARAM(std::string, document1_id);
-    REGEX_PARAM(std::string, document2_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      query_options options = {0};
-      options.refresh = const_cast<char*>("wait_for");
-
-      string documents = "{\"documents\":[{\"_id\":\"" + document1_id + "\", \"body\":{\"a\":\"replaced document\"}}, {\"_id\":\"" + document2_id + "\", \"body\":{\"a\":\"replaced document\"}}]}";
-      ctx->kuzzle->document->mUpdate(ctx->index, ctx->collection, documents, &options);
-      ctx->success = 1;
-      ctx->partial_exception = 0;
-    } catch (PartialException e) {
-      ctx->partial_exception = 1;
-      ctx->success = 0;
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  THEN("^the document \'([^\"]*)\' should be updated$")
-  {
-    REGEX_PARAM(std::string, document_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    string document = ctx->kuzzle->document->get(ctx->index, ctx->collection, document_id);
-
-    BOOST_CHECK(document.find("replaced document") != std::string::npos);
-  }
-
-  WHEN("^I createOrReplace the documents \\[\'(.*)\', \'(.*)\'\\]$")
-  {
-    REGEX_PARAM(std::string, document1_id);
-    REGEX_PARAM(std::string, document2_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      query_options options = {0};
-      options.refresh = const_cast<char*>("wait_for");
-
-      string documents = "{\"documents\":[{\"_id\":\"" + document1_id + "\", \"body\":{\"a\":\"replaced document\"}}, {\"_id\":\"" + document2_id + "\", \"body\":{\"a\":\"replaced document\"}}]}";
-      ctx->kuzzle->document->mCreateOrReplace(ctx->index, ctx->collection, documents, &options);
-      ctx->success = 1;
-      ctx->partial_exception = 0;
-    } catch (PartialException e) {
-      ctx->partial_exception = 1;
-      ctx->success = 0;
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  THEN("^the document \'([^\"]*)\' should be created$")
-  {
-    REGEX_PARAM(std::string, document_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    string document = ctx->kuzzle->document->get(ctx->index, ctx->collection, document_id);
-
-    BOOST_CHECK(document.find("replaced document") != std::string::npos);
-  }
-
-  WHEN("^I check if \'([^\"]*)\' exists$")
-  {
-    REGEX_PARAM(std::string, document_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    ctx->success = ctx->kuzzle->document->exists(ctx->index, ctx->collection, document_id) ? 1 : 0;
-  }
-
-  THEN("^the document should (not )?exist(s)?$")
-  {
-    REGEX_PARAM(std::string, existence);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    if (existence == "not ")
-      BOOST_CHECK(ctx->success == 0);
-    else
-      BOOST_CHECK(ctx->success == 1);
-  }
-
-  WHEN("^I get documents \\[\'(.*)\', \'(.*)\'\\]$")
-  {
-    REGEX_PARAM(std::string, document1_id);
-    REGEX_PARAM(std::string, document2_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      std::vector<string> document_ids;
-      document_ids.push_back(document1_id);
-      document_ids.push_back(document2_id);
-
-      ctx->content = ctx->kuzzle->document->mGet(ctx->index, ctx->collection, document_ids, false);
-      ctx->success = 1;
-    } catch (KuzzleException e) {
-      ctx->success = 0;
-    }
-  }
-
-  THEN("^the documents should be retrieved$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    BOOST_CHECK(ctx->success == 1);
-    BOOST_CHECK(ctx->content != "");
-  }
-}
diff --git a/internal/wrappers/features/step_defs_cpp/index-steps.cpp b/internal/wrappers/features/step_defs_cpp/index-steps.cpp
deleted file mode 100644
index e75a03f1..00000000
--- a/internal/wrappers/features/step_defs_cpp/index-steps.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-#include "steps.hpp"
-
-// Anonymous namespace to handle a linker error
-// see https://stackoverflow.com/questions/14320148/linker-error-on-cucumber-cpp-when-dealing-with-multiple-feature-files
-namespace {
-
-  GIVEN("^there is no index called \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(std::string, index_name);
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      ctx->kuzzle->index->delete_(index_name);
-    } catch (KuzzleException e) {
-      K_LOG_E(e.getMessage().c_str());
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  GIVEN("^there is an index \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(std::string, index_name);
-    ScenarioScope<KuzzleCtx> ctx;
-    ctx->index = index_name;
-
-    if (!ctx->kuzzle->index->exists(index_name)) {
-      K_LOG_D("Creating index: %s", index_name.c_str());
-      try {
-        ctx->kuzzle->index->create(index_name);
-      } catch (KuzzleException e) {
-        K_LOG_E(e.getMessage().c_str());
-        BOOST_FAIL(e.getMessage());
-      }
-    } else {
-      K_LOG_D("Using existing index: %s", index_name.c_str());
-    }
-  }
-
-  GIVEN("^there is the indexes \'([^\"]*)\' and \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(std::string, index_name1);
-    REGEX_PARAM(std::string, index_name2);
-    ScenarioScope<KuzzleCtx> ctx;
-
-    if (! ctx->kuzzle->index->exists(index_name1)) {
-      try {
-        ctx->kuzzle->index->create(index_name1);
-      } catch(KuzzleException e) {
-        K_LOG_E(e.getMessage().c_str());
-        BOOST_FAIL(e.getMessage());
-      }
-    } else {
-      K_LOG_D("Using existing index: %s", index_name1.c_str());
-    }
-
-    if (! ctx->kuzzle->index->exists(index_name2)) {
-      try {
-        ctx->kuzzle->index->create(index_name2);
-      } catch(KuzzleException e) {
-        K_LOG_E(e.getMessage().c_str());
-        BOOST_FAIL(e.getMessage());
-      }
-    } else {
-      K_LOG_D("Using existing index: %s", index_name2.c_str());
-    }
-  }
-
-  WHEN("^I delete the indexes \'([^\"]*)\' and \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(std::string, index_name1);
-    REGEX_PARAM(std::string, index_name2);
-    ScenarioScope<KuzzleCtx> ctx;
-
-    std::vector<std::string> v;
-
-    v.push_back(index_name1);
-    v.push_back(index_name2);
-
-    try {
-      ctx->kuzzle->index->mDelete(v);
-    } catch(KuzzleException e) {
-      K_LOG_E(e.getMessage().c_str());
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  WHEN("^I create an index called \'([^\"]*)\'$")
-  {
-
-    REGEX_PARAM(std::string, index_name);
-    ScenarioScope<KuzzleCtx> ctx;
-
-    K_LOG_D("Creating index: %s", index_name.c_str());
-    try {
-      ctx->kuzzle->index->create(index_name);
-      ctx->index = index_name;
-    } catch (KuzzleException e) {
-      ctx->success = false;
-      K_LOG_E(e.getMessage().c_str());
-    }
-  }
-
-  THEN("^the index should exist$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-    BOOST_CHECK(ctx->kuzzle->index->exists(ctx->index));
-  }
-
-  THEN("^indexes \'([^\"]*)\' and \'([^\"]*)\' don't exist$")
-  {
-    REGEX_PARAM(std::string, index_name1);
-    REGEX_PARAM(std::string, index_name2);
-    ScenarioScope<KuzzleCtx> ctx;
-
-    BOOST_CHECK(
-      !ctx->kuzzle->index->exists(index_name1) &&
-      !ctx->kuzzle->index->exists(index_name2)
-    );
-  }
-
-  WHEN("^I list indexes$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    ctx->string_array = ctx->kuzzle->index->list();
-  }
-
-  THEN("^I get \'([^\"]*)\' and \'([^\"]*)\'$")
-  {
-    REGEX_PARAM(std::string, index_name1);
-    REGEX_PARAM(std::string, index_name2);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    BOOST_CHECK(std::find(ctx->string_array.begin(), ctx->string_array.end(), index_name1) != ctx->string_array.end());
-    BOOST_CHECK(std::find(ctx->string_array.begin(), ctx->string_array.end(), index_name2) != ctx->string_array.end());
-  }
-
-}
diff --git a/internal/wrappers/features/step_defs_cpp/kuzzle-sdk-steps.cpp b/internal/wrappers/features/step_defs_cpp/kuzzle-sdk-steps.cpp
deleted file mode 100644
index 50b3998e..00000000
--- a/internal/wrappers/features/step_defs_cpp/kuzzle-sdk-steps.cpp
+++ /dev/null
@@ -1,219 +0,0 @@
-#include "steps.hpp"
-
-// Anonymous namespace to handle a linker error
-// see https://stackoverflow.com/questions/14320148/linker-error-on-cucumber-cpp-when-dealing-with-multiple-feature-files
-namespace {
-  BEFORE() { kuz_log_sep(); }
-
-  GIVEN("^I create a user 'useradmin' with password 'testpwd' with id 'useradmin-id'$") { pending(); }
-
-  GIVEN("^I update my user custom data with the pair ([\\w]+):(.+)$")
-  {
-    REGEX_PARAM(std::string, fieldname);
-    REGEX_PARAM(std::string, fieldvalue);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    string data = "{\"" + fieldname + "\":" + fieldvalue + "}";
-
-    K_LOG_D("Updating user data with : %s", data.c_str());
-
-    try {
-      ctx->kuzzle->auth->updateSelf(data);
-    } catch (KuzzleException e) {
-      K_LOG_E(e.getMessage().c_str());
-    }
-  }
-
-  THEN("^the response 'content' field contains the pair c:(.+)$")
-  {
-    K_LOG_I("Checking user content field");
-    REGEX_PARAM(std::string, fieldname);
-    REGEX_PARAM(std::string, expected_fieldvalue);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    json_spirit::Value userContentValue;
-    std::string        userContent = ctx->currentUser->content;
-    json_spirit::read(userContent, userContentValue);
-
-    json_spirit::write_formatted(userContentValue);
-
-    json_spirit::Value fieldvalue = json_spirit::find_value(userContentValue.get_obj(), fieldname);
-    switch (fieldvalue.type()) {
-      case json_spirit::str_type: {
-        std::string s = fieldvalue.get_str();
-        K_LOG_D("Field value: \"%s\" of type string", s.c_str());
-        BOOST_CHECK("\"" + s + "\"" == expected_fieldvalue);
-        break;
-      }
-      case json_spirit::bool_type: {
-        auto   b = fieldvalue.get_bool();
-        string s = b ? "true" : "false";
-        K_LOG_D("Field value: \"%s\" of type bool", b ? "true" : "false");
-        BOOST_CHECK(s == expected_fieldvalue);
-        break;
-      }
-      case json_spirit::int_type: {
-        auto i = fieldvalue.get_int();
-        K_LOG_D("Field value: %d of type int", i);
-        string s = std::to_string(i);
-        BOOST_CHECK(s == expected_fieldvalue);
-        break;
-      }
-      case json_spirit::real_type: {
-        float f = fieldvalue.get_real();
-        K_LOG_D("Field value: %f of type real", f);
-        float e = std::stof(expected_fieldvalue);
-        K_LOG_D("Expected value: %f", e);
-        BOOST_CHECK(f == std::stof(expected_fieldvalue));
-        break;
-      }
-        // TODO: Add obj test case...
-    }
-
-    ctx->customUserDataType = fieldvalue.type();
-  }
-
-  THEN("^is a string$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-    BOOST_CHECK(ctx->customUserDataType == json_spirit::str_type);
-  }
-
-  THEN("^is a number$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-    BOOST_CHECK(ctx->customUserDataType == json_spirit::int_type || ctx->customUserDataType == json_spirit::real_type);
-  }
-
-  THEN("^is a bool$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-    BOOST_CHECK(ctx->customUserDataType == json_spirit::bool_type);
-  }
-
-  GIVEN("^Kuzzle Server is running$")
-  {
-    K_LOG_I("Connecting to Kuzzle on 'localhost:7512'");
-    ScenarioScope<KuzzleCtx> ctx;
-    ctx->kuzzle_options         = KUZZLE_OPTIONS_DEFAULT;
-    std::string hostname = "localhost";
-
-    if (std::getenv("KUZZLE_HOST") != NULL) {
-      hostname = std::getenv("KUZZLE_HOST");
-    }
-
-    try {
-      ctx->kuzzle = new Kuzzle(hostname, &ctx->kuzzle_options);
-    } catch (KuzzleException e) {
-      K_LOG_E(e.getMessage().c_str());
-    }
-    char* error = ctx->kuzzle->connect();
-    BOOST_CHECK(error == NULL);
-  }
-
-  THEN("^I get an error$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    BOOST_CHECK(ctx->success == 0);
-  }
-
-  GIVEN("^there is an user with id '([\\w\\-]+)'$")
-  {
-    REGEX_PARAM(std::string, user_id);
-    ScenarioScope<KuzzleCtx> ctx;
-    ctx->user_id = user_id;
-  }
-
-  GIVEN("^the user has 'local' credentials with name '([\\w\\-]+)' and password "
-        "'([\\w\\-]+)'$")
-  {
-    REGEX_PARAM(std::string, username);
-    REGEX_PARAM(std::string, password);
-    ScenarioScope<KuzzleCtx> ctx;
-
-    kuzzle_user_create(ctx->kuzzle, ctx->user_id, username, password);
-  }
-
-  WHEN("^I log in as '([\\w\\-]+)':'([\\w\\-]+)'$")
-  {
-    REGEX_PARAM(std::string, username);
-    REGEX_PARAM(std::string, password);
-    ScenarioScope<KuzzleCtx> ctx;
-
-    string jwt;
-    try {
-      jwt = ctx->kuzzle->auth->login("local", get_login_creds(username, password));
-      K_LOG_D("Logged in as '%s'", username.c_str());
-      K_LOG_D("JWT is: %s", jwt.c_str());
-    } catch (KuzzleException e) {
-      K_LOG_W(e.getMessage().c_str());
-    }
-    ctx->jwt = jwt;
-  }
-
-  THEN("^the retrieved JWT is valid$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-    token_validity*          v = ctx->kuzzle->auth->checkToken(ctx->jwt);
-    BOOST_CHECK(v->valid);
-  }
-
-  THEN("^the retrieved JWT is invalid$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-    token_validity*          v = ctx->kuzzle->auth->checkToken(ctx->jwt);
-    BOOST_CHECK(!v->valid);
-  }
-  WHEN("^I logout$") {
-      ScenarioScope<KuzzleCtx> ctx;
-      ctx->kuzzle->auth->logout();
-  }
-
-  WHEN("^I get my user info$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      ctx->currentUser = ctx->kuzzle->auth->getCurrentUser();
-    } catch (KuzzleException e) {
-      K_LOG_E(e.getMessage().c_str());
-    }
-
-    K_LOG_D("current user = 0x%p", ctx->currentUser);
-    K_LOG_D("Current user content: %s", ctx->currentUser->content);
-
-    BOOST_CHECK_MESSAGE(ctx->currentUser != NULL, "Failed to retrieve current user");
-  }
-
-  THEN("^(the result contains|I shall receive) (\\d+)( hits)?$")
-  {
-    REGEX_PARAM(string, unused);
-    REGEX_PARAM(unsigned int, hits);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    BOOST_CHECK(hits == ctx->hits);
-  }
-
-  THEN("^the content should not be null$")
-  {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    BOOST_CHECK(ctx->content != "");
-  }
-
-  THEN("^I (should have|get) (a|no) partial error$") {
-    REGEX_PARAM(string, unused);
-    REGEX_PARAM(string, error_presence);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    if (error_presence == "no")
-      BOOST_CHECK(ctx->partial_exception == 0);
-    else
-      BOOST_CHECK(ctx->partial_exception == 1);
-  }
-}
diff --git a/internal/wrappers/features/step_defs_cpp/kuzzle_utils.cpp b/internal/wrappers/features/step_defs_cpp/kuzzle_utils.cpp
deleted file mode 100644
index 9f87aa26..00000000
--- a/internal/wrappers/features/step_defs_cpp/kuzzle_utils.cpp
+++ /dev/null
@@ -1,240 +0,0 @@
-#include <boost/property_tree/json_parser.hpp>
-#include <boost/property_tree/ptree.hpp>
-#include <json_spirit/json_spirit_reader.h>
-#include <json_spirit/json_spirit_writer.h>
-#include <map>
-#include <sstream>
-
-#include <exceptions.hpp>
-#include <kuzzle.hpp>
-#include <kuzzlesdk.h>
-
-#include "kuzzle_utils.h"
-
-using boost::property_tree::ptree;
-using boost::property_tree::read_json;
-using boost::property_tree::write_json;
-
-using kuzzleio::Kuzzle;
-using kuzzleio::KuzzleException;
-using std::cout;
-using std::endl;
-using std::string;
-
-using json_spirit::Array;
-using json_spirit::Object;
-using json_spirit::Pair;
-using json_spirit::Value;
-
-std::string get_login_creds(const std::string &username,
-                            const std::string &password)
-{
-  // Write json.
-  ptree pt;
-  pt.put("username", username);
-  pt.put("password", password);
-  std::ostringstream buf;
-  write_json(buf, pt, false);
-  return buf.str();
-}
-
-string get_createUser_body(const std::string &username,
-                           const std::string &password)
-{
-  // Write json.
-
-  Object body;
-  Object content;
-  Object creds;
-  Object local;
-
-  local.push_back(Pair("username", Value(username)));
-  local.push_back(Pair("password", Value(password)));
-
-  creds.push_back(Pair("local", Value(local)));
-
-  Array profileIds;
-  profileIds.push_back("default");
-
-  content.push_back(json_spirit::Pair("profileIds", Value(profileIds)));
-  content.push_back(json_spirit::Pair("name", Value(username)));
-
-  body.push_back(Pair("content", Value(content)));
-  body.push_back(Pair("credentials", Value(creds)));
-
-  std::ostringstream buf;
-  json_spirit::write_formatted(body, buf);
-
-  return buf.str();
-}
-
-bool kuzzle_user_exists(Kuzzle *kuzzle, const string &user_id)
-{
-  bool user_exists = false;
-  try
-  {
-    kuzzle_request req = {0};
-    req.controller = "security";
-    req.action = "getUser";
-    req.id = user_id.c_str();
-    kuzzle->query(&req);
-    user_exists = true;
-  }
-  catch (kuzzleio::NotFoundException e)
-  {
-    user_exists = false;
-  }
-  catch (KuzzleException e)
-  {
-    K_LOG_W(e.getMessage().c_str());
-  }
-  return user_exists;
-}
-
-void kuzzle_user_delete(Kuzzle *kuzzle, const string &user_id)
-{
-  K_LOG_D("Deleting user with ID: '%s'", user_id.c_str());
-  try
-  {
-    kuzzle_request req = {0};
-    req.controller = "security";
-    req.action = "deleteUser";
-    req.id = user_id.c_str();
-
-    query_options options = {0};
-    options.refresh = const_cast<char*>("wait_for");
-    options.volatiles = const_cast<char*>("{}");
-    kuzzle->query(
-        &req, &options); // TODO: test if we can delete with options
-
-    K_LOG_D("Deleted user \"%s\"", user_id.c_str());
-  }
-  catch (KuzzleException e)
-  {
-    K_LOG_E("Failed to delete user \"%s\"", user_id.c_str());
-  }
-}
-
-void kuzzle_credentials_delete(Kuzzle *kuzzle, const string &strategy,
-                               const string &user_id)
-{
-  try
-  {
-    kuzzle_request req = {0};
-    req.controller = "security";
-    req.action = "deleteCredentials";
-    req.strategy = "local";
-    req.id = user_id.c_str();
-
-    kuzzle->query(&req);
-
-    K_LOG_D("Deleted '%s' credentials for userId '%s'", strategy.c_str(),
-            user_id.c_str());
-  }
-  catch (KuzzleException e)
-  {
-    K_LOG_E("Failed to delete '%s' credentials for userId '%s'",
-            strategy.c_str(), user_id.c_str());
-    K_LOG_E(e.getMessage().c_str());
-  }
-}
-
-void kuzzle_user_create(Kuzzle *kuzzle, const string &user_id,
-                        const string &username, const string &password)
-{
-
-  kuzzle_request req = {0};
-  req.controller = "security";
-  req.action = "createUser";
-  req.strategy = "local";
-  req.id = user_id.c_str();
-  string body = get_createUser_body(username, password);
-  req.body = body.c_str();
-
- // if (kuzzle_user_exists(kuzzle, user_id.c_str()))
-  {
-    K_LOG_W("An user with id: '%s' already exists, deleteting it...",
-            user_id.c_str());
-    kuzzle_credentials_delete(kuzzle, "local", user_id);
-    kuzzle_user_delete(kuzzle, user_id);
-  }
-
-    // kuzzle_credentials_delete(kuzzle, "local", user_id);
-
-  K_LOG_D("Creating user with id: '%s' and 'local' creds: %s:%s",
-          user_id.c_str(), username.c_str(), password.c_str());
-  K_LOG_D("Req body: %s", req.body);
-  try
-  {
-    kuzzle_response *resp = kuzzle->query(&req);
-    K_LOG_D("createUser ended with status: %d", resp->status);
-  }
-  catch (KuzzleException e)
-  {
-    K_LOG_E("Status (%d): %s", e.status, e.getMessage().c_str());
-    if (kuzzle_user_exists(kuzzle, user_id.c_str())) {
-      K_LOG_W("But user seems to exist anyway?????");
-    }
-  }
-}
-
-void kuz_log_sep()
-{
-  cout << "\x1b(0\x6c\x1b(B";
-  for (int i = 0; i < 79; i++)
-  {
-    cout << "\x1b(0\x71\x1b(B";
-  }
-  cout << endl;
-}
-
-void kuz_log_e(const char *filename, int linenumber, const char *fmt...)
-{
-  va_list args;
-  va_start(args, fmt);
-
-  cout << "\x1b(0\x78\x1b(B" << TXT_COLOR_RED << "E:";
-  cout << basename(filename) << ":" << linenumber << ":";
-  vprintf(fmt, args);
-  std::cout << TXT_COLOR_RESET << std::endl;
-
-  va_end(args);
-}
-
-void kuz_log_w(const char *filename, int linenumber, const char *fmt...)
-{
-  va_list args;
-  va_start(args, fmt);
-  cout << "\x1b(0\x78\x1b(B" << TXT_COLOR_YELLOW << "W:";
-  cout << basename(filename) << ":" << linenumber << ":";
-  vprintf(fmt, args);
-  cout << TXT_COLOR_RESET << endl;
-
-  va_end(args);
-}
-
-void kuz_log_d(const char *filename, int linenumber, const char *fmt...)
-{
-  va_list args;
-  va_start(args, fmt);
-
-  cout << "\x1b(0\x78\x1b(B" << TXT_COLOR_DEFAULT << "D:";
-  cout << basename(filename) << ":" << linenumber << ":";
-  vprintf(fmt, args);
-  cout << TXT_COLOR_RESET << endl;
-
-  va_end(args);
-}
-
-void kuz_log_i(const char *filename, int linenumber, const char *fmt...)
-{
-  va_list args;
-  va_start(args, fmt);
-
-  cout << "\x1b(0\x78\x1b(B" << TXT_COLOR_BLUE << "I:";
-  cout << basename(filename) << ":" << linenumber << ":";
-  vprintf(fmt, args);
-  cout << TXT_COLOR_RESET << endl;
-
-  va_end(args);
-}
diff --git a/internal/wrappers/features/step_defs_cpp/kuzzle_utils.h b/internal/wrappers/features/step_defs_cpp/kuzzle_utils.h
deleted file mode 100644
index d56dc386..00000000
--- a/internal/wrappers/features/step_defs_cpp/kuzzle_utils.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef _KUZZLE_UTIL_HPP_
-#define _KUZZLE_UTIL_HPP_
-
-#include <stdarg.h>
-#include <stdio.h>
-#define TXT_COLOR_RESET "\e[0m"
-
-#define TXT_COLOR_DEFAULT "\e[39m"
-#define TXT_COLOR_BLACK "\e[30m"
-#define TXT_COLOR_RED "\e[31m"
-#define TXT_COLOR_GREEN "\e[32m"
-#define TXT_COLOR_YELLOW "\e[33m"
-#define TXT_COLOR_BLUE "\e[34m"
-#define TXT_COLOR_MAGENTA "\e[35m"
-#define TXT_COLOR_CYAN "\e[36m"
-#define TXT_COLOR_LIGHTGREY "\e[37m"
-#define TXT_COLOR_DARKGREY "\e[90m"
-
-void kuz_log_sep();
-
-void kuz_log_e(const char *filename, int linenumber, const char *fmt...);
-void kuz_log_w(const char *filename, int linenumber, const char *fmt...);
-void kuz_log_d(const char *filename, int linenumber, const char *fmt...);
-void kuz_log_i(const char *filename, int linenumber, const char *fmt...);
-
-#define K_LOG_D(fmt, ...)                                                      \
-  do {                                                                         \
-    kuz_log_d(__FILE__, __LINE__, fmt, ##__VA_ARGS__);                         \
-  } while (0)
-
-#define K_LOG_W(fmt, ...)                                                      \
-  do {                                                                         \
-    kuz_log_w(__FILE__, __LINE__, fmt, ##__VA_ARGS__);                         \
-  } while (0)
-
-#define K_LOG_E(fmt, ...)                                                      \
-  do {                                                                         \
-    kuz_log_e(__FILE__, __LINE__, fmt, ##__VA_ARGS__);                         \
-  } while (0)
-
-#define K_LOG_I(fmt, ...)                                                      \
-  do {                                                                         \
-    kuz_log_i(__FILE__, __LINE__, fmt, ##__VA_ARGS__);                         \
-  } while (0)
-
-std::string get_login_creds(const std::string &username,
-                            const std::string &password);
-void kuzzle_user_create(kuzzleio::Kuzzle *kuzzle, const std::string &user_id,
-                        const std::string &username,
-                        const std::string &password);
-
-#endif
diff --git a/internal/wrappers/features/step_defs_cpp/realtime-steps.cpp b/internal/wrappers/features/step_defs_cpp/realtime-steps.cpp
deleted file mode 100644
index 74005b20..00000000
--- a/internal/wrappers/features/step_defs_cpp/realtime-steps.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-#include "steps.hpp"
-
-#include <signal.h>
-
-CustomNotificationListener* CustomNotificationListener::_singleton;
-
-// Anonymous namespace to handle a linker error
-// see https://stackoverflow.com/questions/14320148/linker-error-on-cucumber-cpp-when-dealing-with-multiple-feature-files
-namespace {
-
-  GIVEN("^I subscribe to \'(.*)\'$") {
-    REGEX_PARAM(std::string, collection_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      CustomNotificationListener *l = CustomNotificationListener::getSingleton();
-      ctx->room_id = ctx->kuzzle->realtime->subscribe(ctx->index, collection_id, "{}", &l->listener);
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  WHEN("^I create a document in \'([^\"]*)\'$") {
-    REGEX_PARAM(std::string, collection_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    query_options options = {0};
-    options.refresh = const_cast<char*>("wait_for");
-
-    try {
-      ctx->kuzzle->document->create(ctx->index, ctx->collection, "", "{\"foo\":\"bar\"}", &options);
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  THEN("^I receive a notification$") {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    sleep(1);
-    BOOST_CHECK(ctx->notif_result != NULL);
-    ctx->kuzzle->realtime->unsubscribe(ctx->room_id);
-
-    delete ctx->notif_result;
-    ctx->notif_result = NULL;
-  }
-
-  GIVEN("^I subscribe to \'([^\"]*)\' with \'(.*)\' as filter$") {
-    REGEX_PARAM(std::string, collection_id);
-    REGEX_PARAM(std::string, filter);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      CustomNotificationListener *l = CustomNotificationListener::getSingleton();
-      ctx->kuzzle->realtime->subscribe(ctx->index, collection_id, filter, &l->listener);
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  WHEN("^I update the document with id \'([^\"]*)\' and content \'([^\"]*)\' = \'([^\"]*)\'$") {
-    REGEX_PARAM(std::string, document_id);
-    REGEX_PARAM(std::string, key);
-    REGEX_PARAM(std::string, value);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    query_options options = {0};
-    options.refresh = const_cast<char*>("wait_for");
-
-    try {
-      ctx->kuzzle->document->update(ctx->index, ctx->collection, document_id, "{\""+key+"\":\""+value+"\"}", &options);
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  WHEN("^I delete the document with id \'([^\"]*)\'$") {
-    REGEX_PARAM(std::string, document_id);
-
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      ctx->kuzzle->document->delete_(ctx->index, ctx->collection, document_id);
-      ctx->success = 1;
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  WHEN("^I publish a document$") {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      ctx->kuzzle->realtime->publish(ctx->index, ctx->collection, "{}");
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  GIVEN("^I unsubscribe$") {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    try {
-      ctx->kuzzle->realtime->unsubscribe(ctx->room_id);
-      ctx->notif_result = NULL;
-    } catch (KuzzleException e) {
-      BOOST_FAIL(e.getMessage());
-    }
-  }
-
-  THEN("^I do not receive a notification$") {
-    ScenarioScope<KuzzleCtx> ctx;
-
-    BOOST_CHECK(ctx->notif_result == NULL);
-  }
-}
diff --git a/internal/wrappers/features/step_defs_cpp/steps.hpp b/internal/wrappers/features/step_defs_cpp/steps.hpp
deleted file mode 100644
index aa876bd6..00000000
--- a/internal/wrappers/features/step_defs_cpp/steps.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef _STEPS_HPP_
-#define _STEPS_HPP_
-
-#include <boost/test/unit_test.hpp>
-#define EXPECT_EQ BOOST_CHECK_EQUAL
-#include <cucumber-cpp/autodetect.hpp>
-#include <cstdlib>
-#include <iostream>
-#include <functional>
-
-#include "auth.hpp"
-#include "collection.hpp"
-#include "document.hpp"
-#include "index.hpp"
-#include "realtime.hpp"
-#include "kuzzle.hpp"
-
-#include "kuzzle_utils.h"
-
-#include "json_spirit/json_spirit.h"
-
-using cucumber::ScenarioScope;
-
-using namespace kuzzleio;
-using std::cout;
-using std::endl;
-using std::string;
-
-struct KuzzleCtx {
-  Kuzzle* kuzzle = NULL;
-  options kuzzle_options;
-
-  string user_id;
-  string index;
-  string collection;
-  string jwt;
-  string document_id;
-  search_result *documents;
-
-  string room_id;
-
-  kuzzle_user*                   currentUser        = NULL;
-  json_spirit::Value_type customUserDataType = json_spirit::null_type;
-
-  // 1 mean success, 0 failure and -1 is base state
-  int success = -1;
-  string error_message;
-  int hits = -1;
-  string content;
-  // 1 mean yes, 0 no and -1 is base state
-  int partial_exception = -1;
-  std::vector<string> string_array;
-
-  notification_result *notif_result = NULL;
-};
-
-class CustomNotificationListener {
-  private:
-    CustomNotificationListener() {
-      listener = [](const kuzzleio::notification_result* res) {
-        ScenarioScope<KuzzleCtx> ctx;
-        ctx->notif_result = const_cast<notification_result*>(res);
-      };
-    };
-    static CustomNotificationListener* _singleton;
-  public:
-    NotificationListener listener;
-    static CustomNotificationListener* getSingleton() {
-      if (!_singleton) {
-        _singleton = new CustomNotificationListener();
-      }
-      return _singleton;
-    }
-};
-
-#endif
diff --git a/internal/wrappers/headers/auth.hpp b/internal/wrappers/headers/auth.hpp
deleted file mode 100644
index 8733e9dc..00000000
--- a/internal/wrappers/headers/auth.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef _AUTH_HPP
-#define _AUTH_HPP
-
-#include "exceptions.hpp"
-#include "core.hpp"
-
-namespace kuzzleio {
-
-  class Kuzzle;
-
-  class Auth {
-    auth *_auth;
-    Auth();
-
-    public:
-      Kuzzle *_kuzzle;
-
-      Auth(Kuzzle *kuzzle);
-      Auth(Kuzzle *kuzzle, auth *auth);
-      virtual ~Auth();
-      token_validity* checkToken(const std::string& token);
-      std::string createMyCredentials(const std::string& strategy, const std::string& credentials, query_options* options=nullptr);
-      bool credentialsExist(const std::string& strategy, query_options *options=nullptr);
-      void deleteMyCredentials(const std::string& strategy, query_options *options=nullptr);
-      kuzzle_user* getCurrentUser();
-      std::string getMyCredentials(const std::string& strategy, query_options *options=nullptr);      
-      user_right* getMyRights(query_options *options=nullptr);
-      std::vector<std::string> getStrategies(query_options *options=nullptr);
-      std::string login(const std::string& strategy, const std::string& credentials, int expiresIn);
-      std::string login(const std::string& strategy, const std::string& credentials);
-      void logout() noexcept;
-      void setJwt(const std::string& jwt) noexcept;
-      std::string updateMyCredentials(const std::string& strategy, const std::string& credentials, query_options *options=nullptr);      
-      kuzzle_user* updateSelf(const std::string& content, query_options* options=nullptr);      
-      bool validateMyCredentials(const std::string& strategy, const std::string& credentials, query_options* options=nullptr);
-  };
-}
-
-#endif
diff --git a/internal/wrappers/headers/collection.hpp b/internal/wrappers/headers/collection.hpp
deleted file mode 100644
index 5b6e773a..00000000
--- a/internal/wrappers/headers/collection.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef _COLLECTION_HPP_
-#define _COLLECTION_HPP_
-
-#include <iostream>
-#include <list>
-#include "core.hpp"
-#include "exceptions.hpp"
-
-namespace kuzzleio {
-    class Kuzzle;
-    class Collection {
-        collection* _collection;
-        Collection();
-
-        public:
-            Collection(Kuzzle* kuzzle);
-            Collection(Kuzzle* kuzzle, collection *collection);
-            virtual ~Collection();
-            void create(const std::string& index, const std::string& collection, const std::string* body=nullptr, query_options *options=nullptr);
-            bool exists(const std::string& index, const std::string& collection, query_options *options=nullptr);
-            std::string list(const std::string& index, query_options *options=nullptr);
-            void truncate(const std::string& index, const std::string& collection, query_options *options=nullptr);
-            std::string getMapping(const std::string& index, const std::string& collection, query_options *options=nullptr);
-            void updateMapping(const std::string& index, const std::string& collection, const std::string& body, query_options *options=nullptr);
-            std::string getSpecifications(const std::string& index, const std::string& collection, query_options *options=nullptr);
-            search_result* searchSpecifications(query_options *options=nullptr);
-            std::string updateSpecifications(const std::string& index, const std::string& collection, const std::string& body, query_options *options=nullptr);
-            bool validateSpecifications(const std::string& body, query_options *options=nullptr);
-            void deleteSpecifications(const std::string& index, const std::string& collection, query_options *options=nullptr);
-    };
-}
-
-#endif
diff --git a/internal/wrappers/headers/document.hpp b/internal/wrappers/headers/document.hpp
deleted file mode 100644
index af1d3146..00000000
--- a/internal/wrappers/headers/document.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef _DOCUMENT_HPP_
-#define _DOCUMENT_HPP_
-
-#include "exceptions.hpp"
-#include "core.hpp"
-
-namespace kuzzleio {
-
-    class Document {
-        document* _document;
-        Document();
-
-        public:
-            Document(Kuzzle* kuzzle);
-            Document(Kuzzle* kuzzle, document *document);
-            virtual ~Document();
-            int count(const std::string& index, const std::string& collection, const std::string& body, query_options *options=nullptr);
-            bool exists(const std::string& index, const std::string& collection, const std::string& id, query_options *options=nullptr);
-            std::string create(const std::string& index, const std::string& collection, const std::string& id, const std::string& body, query_options *options=nullptr);
-            std::string createOrReplace(const std::string& index, const std::string& collection, const std::string& id, const std::string& body, query_options *options=nullptr);
-            std::string delete_(const std::string& index, const std::string& collection, const std::string& id, query_options *options=nullptr);
-            std::vector<std::string> deleteByQuery(const std::string& index, const std::string& collection, const std::string& body, query_options *options=nullptr);
-            std::string get(const std::string& index, const std::string& collection, const std::string& id, query_options *options=nullptr);
-            std::string replace(const std::string& index, const std::string& collection, const std::string& id, const std::string& body, query_options *options=nullptr);
-            std::string update(const std::string& index, const std::string& collection, const std::string& id, const std::string& body, query_options *options=nullptr);
-            bool validate(const std::string& index, const std::string& collection, const std::string& body, query_options *options=nullptr);
-            search_result* search(const std::string& index, const std::string& collection, const std::string& body, query_options *options=nullptr);
-            std::string mCreate(const std::string& index, const std::string& collection, const std::string& body, query_options *options=nullptr);
-            std::string mCreateOrReplace(const std::string& index, const std::string& collection, const std::string& body, query_options *options=nullptr);
-            std::vector<std::string> mDelete(const std::string& index, const std::string& collection, const std::vector<std::string>& ids, query_options *options=nullptr);
-            std::string mGet(const std::string& index, const std::string& collection, const std::vector<std::string>& ids, bool includeTrash, query_options *options=nullptr);
-            std::string mReplace(const std::string& index, const std::string& collection, const std::string& body, query_options *options=nullptr);
-            std::string mUpdate(const std::string& index, const std::string& collection, const std::string& body, query_options *options=nullptr);
-    };
-}
-
-#endif
diff --git a/internal/wrappers/headers/event_emitter.hpp b/internal/wrappers/headers/event_emitter.hpp
deleted file mode 100644
index 29923daf..00000000
--- a/internal/wrappers/headers/event_emitter.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef _EVENT_EMITTER_HPP_
-#define _EVENT_EMITTER_HPP_
-
-#include <functional>
-#include "kuzzle.hpp"
-
-typedef const std::function<void(const std::string)> EventListener;
-
-namespace kuzzleio {
-
-  class KuzzleEventEmitter {
-    public:
-      virtual KuzzleEventEmitter* addListener(Event e, EventListener* listener) = 0;
-      virtual KuzzleEventEmitter* removeListener(Event e, EventListener* listener) = 0;
-      virtual KuzzleEventEmitter* removeAllListeners(Event e) = 0;
-      virtual KuzzleEventEmitter* once(Event e, EventListener* listener) = 0;
-      virtual int listenerCount(Event e) = 0;
-  };
-}
-
-#endif
diff --git a/internal/wrappers/headers/exceptions.hpp b/internal/wrappers/headers/exceptions.hpp
deleted file mode 100644
index 9e222805..00000000
--- a/internal/wrappers/headers/exceptions.hpp
+++ /dev/null
@@ -1,155 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef _EXCEPTIONS_HPP_
-#define _EXCEPTIONS_HPP_
-
-#include <exception>
-#include <stdexcept>
-#include <stdlib.h>
-#include <string>
-
-#define PARTIAL_EXCEPTION 206
-#define BAD_REQUEST_EXCEPTION 400
-#define UNAUTHORIZED_EXCEPTION 401
-#define FORBIDDEN_EXCEPTION 403
-#define NOT_FOUND_EXCEPTION 404
-#define PRECONDITION_EXCEPTION 412
-#define SIZE_LIMIT_EXCEPTION 413
-#define INTERNAL_EXCEPTION 500
-#define SERVICE_UNAVAILABLE_EXCEPTION 503
-#define GATEWAY_TIMEOUT_EXCEPTION 504
-
-namespace kuzzleio {
-
-  struct KuzzleException : std::runtime_error {
-    int status;
-
-    KuzzleException(int status, const std::string& message);
-    KuzzleException(const std::string& message)
-    : KuzzleException(500, message) {};
-    KuzzleException(const KuzzleException& ke) : status(ke.status), std::runtime_error(ke.getMessage()) {};
-
-    virtual ~KuzzleException() throw() {};
-    std::string getMessage() const;
-  };
-
-  struct BadRequestException : KuzzleException {
-    BadRequestException(const std::string& message="Bad Request Exception")
-      : KuzzleException(BAD_REQUEST_EXCEPTION, message) {};
-    BadRequestException(const BadRequestException& bre) : KuzzleException(bre.status, bre.getMessage()) {}
-  };
-  struct ForbiddenException: KuzzleException {
-    ForbiddenException(const std::string& message="Forbidden Exception")
-      : KuzzleException(FORBIDDEN_EXCEPTION, message) {};
-    ForbiddenException(const ForbiddenException& fe) : KuzzleException(fe.status, fe.getMessage()) {}
-  };
-  struct GatewayTimeoutException: KuzzleException {
-    GatewayTimeoutException(const std::string& message="Gateway Timeout Exception")
-      : KuzzleException(GATEWAY_TIMEOUT_EXCEPTION, message) {};
-    GatewayTimeoutException(const GatewayTimeoutException& gte) : KuzzleException(gte.status, gte.getMessage()) {}
-  };
-  struct InternalException: KuzzleException {
-    InternalException(const std::string& message="Internal Exception")
-      : KuzzleException(INTERNAL_EXCEPTION, message) {};
-    InternalException(const InternalException& ie) : KuzzleException(ie.status, ie.getMessage()) {}
-  };
-  struct NotFoundException: KuzzleException {
-    NotFoundException(const std::string& message="Not Found Exception")
-      : KuzzleException(NOT_FOUND_EXCEPTION, message) {};
-    NotFoundException(const NotFoundException& nfe) : KuzzleException(nfe.status, nfe.getMessage()) {}
-  };
-  struct PartialException: KuzzleException {
-    PartialException(const std::string& message="Partial Exception")
-      : KuzzleException(PARTIAL_EXCEPTION, message) {};
-    PartialException(const PartialException& pe) : KuzzleException(pe.status, pe.getMessage()) {}
-  };
-  struct PreconditionException: KuzzleException {
-    PreconditionException(const std::string& message="Precondition Exception")
-      : KuzzleException(PRECONDITION_EXCEPTION, message) {};
-    PreconditionException(const PreconditionException& pe) : KuzzleException(pe.status, pe.getMessage()) {}
-  };
-  struct ServiceUnavailableException: KuzzleException {
-    ServiceUnavailableException(const std::string& message="Service Unavailable Exception")
-      : KuzzleException(SERVICE_UNAVAILABLE_EXCEPTION, message) {};
-    ServiceUnavailableException(const ServiceUnavailableException& sue) : KuzzleException(sue.status, sue.getMessage()) {}
-  };
-  struct SizeLimitException: KuzzleException {
-    SizeLimitException(const std::string& message="Size Limit Exception")
-      : KuzzleException(SIZE_LIMIT_EXCEPTION, message) {};
-    SizeLimitException(const SizeLimitException& sle) : KuzzleException(sle.status, sle.getMessage()) {}
-  };
-  struct UnauthorizedException : KuzzleException {
-    UnauthorizedException(const std::string& message="Unauthorized Exception")
-     : KuzzleException(UNAUTHORIZED_EXCEPTION, message) {}
-    UnauthorizedException(const UnauthorizedException& ue) : KuzzleException(ue.status, ue.getMessage()) {}
-  };
-
-  template <class T>
-  void throwExceptionFromStatus(T *result) {
-    const std::string error = std::string(result->error);
-    delete(result->error);
-    if (result->stack) {
-      free(const_cast<char *>(result->stack));
-    }
-
-    switch(result->status) {
-      case PARTIAL_EXCEPTION:
-        delete(result);
-        throw PartialException(error);
-      break;
-      case BAD_REQUEST_EXCEPTION:
-        delete(result);
-        throw BadRequestException(error);
-      break;
-      case UNAUTHORIZED_EXCEPTION:
-        delete(result);
-        throw UnauthorizedException(error);
-      break;
-      case FORBIDDEN_EXCEPTION:
-        delete(result);
-        throw ForbiddenException(error);
-      break;
-      case NOT_FOUND_EXCEPTION:
-        delete(result);
-        throw NotFoundException(error);
-      break;
-      case PRECONDITION_EXCEPTION:
-        delete(result);
-        throw PreconditionException(error);
-      break;
-      case SIZE_LIMIT_EXCEPTION:
-        delete(result);
-        throw SizeLimitException(error);
-      break;
-      case INTERNAL_EXCEPTION:
-        delete(result);
-        throw InternalException(error);
-      break;
-      case SERVICE_UNAVAILABLE_EXCEPTION:
-        delete(result);
-        throw ServiceUnavailableException(error);
-      break;
-      case GATEWAY_TIMEOUT_EXCEPTION:
-        delete(result);
-        throw GatewayTimeoutException(error);
-      break;
-      default:
-        delete(result);
-        throw KuzzleException(500, error);
-    }
-  }
-}
-
-#endif
diff --git a/internal/wrappers/headers/index.hpp b/internal/wrappers/headers/index.hpp
deleted file mode 100644
index fb385fc4..00000000
--- a/internal/wrappers/headers/index.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef _KUZZLE_INDEX_HPP
-#define _KUZZLE_INDEX_HPP
-#include <stdlib.h>
-#include <vector>
-#include "exceptions.hpp"
-#include "core.hpp"
-
-namespace kuzzleio {
-  class Kuzzle;
-  class Index {
-    kuzzle_index *_index;
-    Index();
-
-    public:
-      Index(Kuzzle* kuzzle);
-      Index(Kuzzle* kuzzle, kuzzle_index *index);
-      virtual ~Index();
-      void create(const std::string& index, query_options *options=nullptr);
-      void delete_(const std::string& index, query_options *options=nullptr);
-      std::vector<std::string> mDelete(const std::vector<std::string>& indexes, query_options *options=nullptr);
-      bool exists(const std::string& index, query_options *options=nullptr);
-      void refresh(const std::string& index, query_options *options=nullptr);
-      void refreshInternal(query_options *options=nullptr);
-      void setAutoRefresh(const std::string& index, bool autoRefresh, query_options *options=nullptr);
-      bool getAutoRefresh(const std::string& index, query_options *options=nullptr);
-      std::vector<std::string> list(query_options *options=nullptr);
-  };
-}
-
-#endif
diff --git a/internal/wrappers/headers/kuzzle.hpp b/internal/wrappers/headers/kuzzle.hpp
deleted file mode 100644
index aad1123d..00000000
--- a/internal/wrappers/headers/kuzzle.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef _KUZZLE_HPP_
-#define _KUZZLE_HPP_
-
-#include "exceptions.hpp"
-#include "core.hpp"
-#include "event_emitter.hpp"
-#include <string>
-#include <iostream>
-#include <vector>
-#include <map>
-#include <functional>
-
-namespace kuzzleio {
-  class Collection;
-  class Document;
-  class Auth;
-  class Index;
-  class Server;
-  class Realtime;
-
-  class Kuzzle : public KuzzleEventEmitter {
-    private:
-      std::map<int, EventListener*>  _listener_instances;
-
-    public:
-      kuzzle *_kuzzle;
-      Auth *auth;
-      Index  *index;
-      Server *server;
-      Collection *collection;
-      Document *document;
-      Realtime *realtime;
-
-      Kuzzle(const std::string& host, options *options=nullptr);
-      virtual ~Kuzzle();
-
-      char* connect() noexcept;
-
-      std::string getJwt() noexcept;
-      void disconnect() noexcept;
-      kuzzle_response* query(kuzzle_request* query, query_options* options=nullptr);
-      Kuzzle* playQueue() noexcept;
-      Kuzzle* setAutoReplay(bool autoReplay) noexcept;
-      Kuzzle* startQueuing() noexcept;
-      Kuzzle* stopQueuing() noexcept;
-      Kuzzle* flushQueue() noexcept;
-      std::string getVolatile() noexcept;
-      Kuzzle* setVolatile(const std::string& volatiles) noexcept;
-      std::map<int, EventListener*> getListeners() noexcept;
-      void emitEvent(Event& event, const std::string& body) noexcept;
-
-      virtual KuzzleEventEmitter* addListener(Event event, EventListener* listener) override;
-      virtual KuzzleEventEmitter* removeListener(Event event, EventListener* listener) override;
-      virtual KuzzleEventEmitter* removeAllListeners(Event event) override;
-      virtual KuzzleEventEmitter* once(Event event, EventListener* listener) override;
-      virtual int listenerCount(Event event) override;
-
-  };
-}
-
-#endif
diff --git a/internal/wrappers/headers/kuzzlesdk.h b/internal/wrappers/headers/kuzzlesdk.h
deleted file mode 100644
index b765a0b0..00000000
--- a/internal/wrappers/headers/kuzzlesdk.h
+++ /dev/null
@@ -1,668 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef _KUZZLESDK_H_
-#define _KUZZLESDK_H_
-
-#include <time.h>
-#include <errno.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <stdio.h>
-
-enum Mode {AUTO, MANUAL};
-//options passed to the Kuzzle() fct
-
-#define KUZZLE_OPTIONS_DEFAULT { \
-    .queue_ttl = 120000, \
-    .queue_max_size = 500, \
-    .offline_mode = MANUAL,  \
-    .auto_queue = false,  \
-    .auto_reconnect = true,  \
-    .auto_replay = false, \
-    .auto_resubscribe = true, \
-    .reconnection_delay = 1000, \
-    .replay_interval = 10, \
-    .refresh = NULL \
-}
-
-enum Event {
-    CONNECTED,
-    DISCARDED,
-    DISCONNECTED,
-    LOGIN_ATTEMPT,
-    NETWORK_ERROR,
-    OFFLINE_QUEUE_POP,
-    OFFLINE_QUEUE_PUSH,
-    QUERY_ERROR,
-    RECONNECTED,
-    JWT_EXPIRED,
-    ERROR
-};
-
-enum is_action_allowed {
-    ALLOWED,
-    CONDITIONNAL,
-    DENIED
-};
-
-
-# ifdef __cplusplus
-namespace kuzzleio {
-# endif
-
-//query object used by query()
-typedef struct {
-    char *query;
-    unsigned long long timestamp;
-    char   *request_id;
-} query_object;
-
-typedef struct {
-    query_object **queries;
-    size_t queries_length;
-} offline_queue;
-
-typedef void (*kuzzle_event_listener)(int, char*, void*);
-
-//define a request
-typedef struct {
-    const char *request_id;
-    const char *controller;
-    const char *action;
-    const char *index;
-    const char *collection;
-    const char *body;
-    const char *id;
-    long from;
-    long size;
-    const char *scroll;
-    const char *scroll_id;
-    const char *strategy;
-    unsigned long long expires_in;
-    const char *volatiles;
-    const char *scope;
-    const char *state;
-    const char *user;
-    long start;
-    long stop;
-    long end;
-    unsigned char bit;
-    const char *member;
-    const char *member1;
-    const char *member2;
-    char **members;
-    size_t members_length;
-    double lon;
-    double lat;
-    double distance;
-    const char *unit;
-    const char *options;
-    const char **keys;
-    size_t keys_length;
-    long cursor;
-    long offset;
-    const char *field;
-    const char **fields;
-    size_t fields_length;
-    const char *subcommand;
-    const char *pattern;
-    long idx;
-    const char *min;
-    const char *max;
-    const char *limit;
-    unsigned long count;
-    const char *match;
-} kuzzle_request;
-
-typedef offline_queue* (*kuzzle_offline_queue_loader)(void);
-typedef bool (*kuzzle_queue_filter)(const char*);
-
-typedef struct {
-    void *instance;
-    kuzzle_queue_filter filter;
-    kuzzle_offline_queue_loader loader;
-} kuzzle;
-
-typedef struct {
-  void *instance;
-  kuzzle* k;
-} realtime;
-
-typedef struct {
-    const char *type_;
-    int  from;
-    int  size;
-    const char *scroll;
-} search_options;
-
-typedef struct auth {
-  void *instance;
-  kuzzle *k;
-} auth;
-
-typedef struct {
-  void *instance;
-  kuzzle *k;
-} kuzzle_index;
-
-typedef struct {
-  void *instance;
-  kuzzle* k;
-} server;
-
-typedef struct {
-  const char *room;
-  const char *channel;
-  int status;
-  const char *error;
-  const char *stack;
-} subscribe_result;
-
-//options passed to room constructor
-typedef struct {
-    const char *scope;
-    const char *state;
-    const char *user;
-    bool subscribe_to_self;
-    const char *volatiles;
-} room_options;
-
-typedef struct {
-    void *instance;
-    const char *filters;
-    room_options *options;
-} room;
-
-typedef struct {
-  room *result;
-  int status;
-  const char *error;
-  const char *stack;
-} room_result;
-
-typedef void (callback)(char* notification);
-
-//options passed to query()
-typedef struct {
-    bool queuable;
-    bool withdist;
-    bool withcoord;
-    long from;
-    long size;
-    const char *scroll;
-    const char *scroll_id;
-    const char *refresh;
-    const char *if_exist;
-    int retry_on_conflict;
-    const char *volatiles;
-} query_options;
-
-typedef struct {
-    unsigned queue_ttl;
-    unsigned long queue_max_size;
-    enum Mode offline_mode;
-    bool auto_queue;
-    bool auto_reconnect;
-    bool auto_replay;
-    bool auto_resubscribe;
-    unsigned long reconnection_delay;
-    unsigned long replay_interval;
-    const char *refresh;
-} options;
-
-//meta of a document
-typedef struct {
-    const char *author;
-    unsigned long long created_at;
-    unsigned long long updated_at;
-    const char *updater;
-    bool active;
-    unsigned long long deleted_at;
-} meta;
-
-/* === Security === */
-
-typedef char *controllers;
-
-typedef struct  {
-    const char *index;
-    char **collections;
-    size_t collections_length;
-} policy_restriction;
-
-typedef struct {
-    const char *role_id;
-    policy_restriction *restricted_to;
-    size_t restricted_to_length;
-} policy;
-
-typedef struct {
-    const char *id;
-    policy *policies;
-    size_t policies_length;
-    kuzzle *k;
-} profile;
-
-typedef struct {
-    const char *id;
-    const char *controllers;
-    kuzzle *k;
-} role;
-
-// kuzzle user
-typedef struct {
-    const char *id;
-    const char *content;
-    char **profile_ids;
-    size_t profile_ids_length;
-    kuzzle *k;
-} kuzzle_user;
-
-// user content passed to user constructor
-typedef struct {
-    const char *content;
-    char **profile_ids;
-    size_t profile_ids_length;
-} user_data;
-
-/* === Dedicated response structures === */
-
-typedef struct {
-  int failed;
-  int successful;
-  int total;
-} shards;
-
-typedef struct {
-    void *instance;
-    kuzzle *k;
-} collection;
-
-typedef struct {
-    void *instance;
-    kuzzle *k;
-} document;
-
-typedef struct {
-    const char *id;
-    meta *m;
-    const char *content;
-    int count;
-} notification_content;
-
-typedef struct notification_result {
-    const char *request_id;
-    notification_content *result;
-    const char *volatiles;
-    const char *index;
-    const char *collection;
-    const char *controller;
-    const char *action;
-    const char *protocol;
-    const char *scope;
-    const char *state;
-    const char *user;
-    const char *n_type;
-    const char *room_id;
-    unsigned long long timestamp;
-    int status;
-    const char *error;
-    const char *stack;
-} notification_result;
-
-typedef struct profile_result {
-    profile *p;
-    int status;
-    const char *error;
-    const char *stack;
-} profile_result;
-
-typedef struct profiles_result {
-    profile *profiles;
-    size_t profiles_length;
-    int status;
-    const char *error;
-    const char *stack;
-} profiles_result;
-
-typedef struct role_result {
-    role *r;
-    int status;
-    const char *error;
-    const char *stack;
-} role_result;
-
-typedef struct roles_result {
-    role *roles;
-    size_t roles_length;
-    int status;
-    const char *error;
-    const char *stack;
-} roles_result;
-
-typedef struct {
-    const char *controller;
-    const char *action;
-    const char *index;
-    const char *collection;
-    const char *value;
-} user_right;
-
-typedef struct user_rights_result {
-  user_right *result;
-  size_t user_rights_length;
-  int status;
-  const char *error;
-  const char *stack;
-} user_rights_result;
-
-typedef struct user_result {
-    kuzzle_user *result;
-    int status;
-    const char *error;
-    const char *stack;
-} user_result;
-
-//statistics
-typedef struct {
-    const char* completed_requests;
-    const char* connections;
-    const char* failed_requests;
-    const char* ongoing_requests;
-    unsigned long long timestamp;
-} statistics;
-
-typedef struct statistics_result {
-    statistics* result;
-    int status;
-    const char *error;
-    const char *stack;
-} statistics_result;
-
-typedef struct all_statistics_result {
-    statistics* result;
-    size_t result_length;
-    int status;
-    const char *error;
-    const char *stack;
-} all_statistics_result;
-
-// ms.geopos
-typedef struct geopos_result {
-    double (*result)[2];
-    size_t result_length;
-    int status;
-    const char *error;
-    const char *stack;
-} geopos_result;
-
-// ms.geopoint
-typedef struct point {
-    float lat;
-    float lon;
-    const char *name;
-} point;
-
-// ms.msHashField
-typedef struct ms_hash_field {
-  const char *field;
-  const char *value;
-} ms_hash_field;
-
-// ms.keyValue
-typedef struct ms_key_value {
-  const char *key;
-  const char *value;
-} ms_key_value;
-
-// ms.sortedSet
-typedef struct ms_sorted_set {
-  float score;
-  const char *member;
-} ms_sorted_set;
-
-//check_token
-typedef struct token_validity {
-    bool valid;
-    const char *state;
-    unsigned long long expires_at;
-    int status;
-    const char *error;
-    const char *stack;
-} token_validity;
-
-/* === Generic response structures === */
-
-// raw Kuzzle response
-typedef struct {
-    const char *request_id;
-    const char *result;
-    const char *volatiles;
-    const char *index;
-    const char *collection;
-    const char *controller;
-    const char *action;
-    const char *room_id;
-    const char *channel;
-    int status;
-    const char *error;
-    const char *stack;
-} kuzzle_response;
-
-//any void result
-typedef struct error_result {
-    int status;
-    const char *error;
-    const char *stack;
-} error_result;
-
-//any json result
-typedef struct json_result {
-    const char *result;
-    int status;
-    const char *error;
-    const char *stack;
-} json_result;
-
-//any array of char result
-typedef struct json_array_result {
-    char **result;
-    size_t result_length;
-    int status;
-    const char *error;
-    const char *stack;
-} json_array_result;
-
-//any boolean result
-typedef struct bool_result {
-    bool result;
-    int status;
-    const char *error;
-    const char *stack;
-} bool_result;
-
-//any integer result
-typedef struct int_result {
-    long long result;
-    int status;
-    const char *error;
-    const char *stack;
-} int_result;
-
-typedef struct date_result {
-    long long result;
-    int status;
-    const char *error;
-    const char *stack;
-} date_result;
-
-//any double result
-typedef struct double_result {
-    double result;
-    int status;
-    const char *error;
-    const char *stack;
-} double_result;
-
-//any array of integers result
-typedef struct int_array_result {
-    long long *result;
-    size_t result_length;
-    int status;
-    const char *error;
-    const char *stack;
-} int_array_result;
-
-// any string result
-typedef struct string_result {
-    const char *result;
-    int status;
-    const char *error;
-    const char *stack;
-} string_result;
-
-//any array of strings result
-typedef struct string_array_result {
-    char **result;
-    size_t result_length;
-    int status;
-    const char *error;
-    const char *stack;
-} string_array_result;
-
-typedef struct {
-    profile *hits;
-    size_t hits_length;
-    unsigned total;
-    const char *scroll_id;
-} profile_search;
-
-typedef struct {
-    role *hits;
-    size_t hits_length;
-    unsigned total;
-} role_search;
-
-typedef struct {
-    kuzzle_user *hits;
-    size_t hits_length;
-    unsigned total;
-    const char *scroll_id;
-} user_search;
-
-//any delete* function
-typedef struct ack_result {
-    bool acknowledged;
-    bool shards_acknowledged;
-    int status;
-    const char *error;
-    const char *stack;
-} ack_result;
-
-typedef struct shards_result {
-    shards *result;
-    int status;
-    const char *error;
-    const char *stack;
-} shards_result;
-
-typedef struct {
-    bool strict;
-    const char *fields;
-    const char *validators;
-} specification;
-
-typedef struct {
-    specification *validation;
-    const char *index;
-    const char *collection;
-} specification_entry;
-
-typedef struct specification_result {
-    specification *result;
-    int status;
-    const char *error;
-    const char *stack;
-} specification_result;
-
-typedef struct search_result {
-    const char *documents;
-    unsigned fetched;
-    unsigned total;
-    const char *aggregations;
-    const char *filters;
-    query_options *options;
-    const char *collection;
-    int status;
-    const char *error;
-    const char *stack;
-} search_result;
-
-typedef struct search_profiles_result {
-    profile_search *result;
-    int status;
-    const char *error;
-    const char *stack;
-} search_profiles_result;
-
-typedef struct search_roles_result {
-    role_search *result;
-    int status;
-    const char *error;
-    const char *stack;
-} search_roles_result;
-
-typedef struct search_users_result {
-    user_search *result;
-    int status;
-    const char *error;
-    const char *stack;
-} search_users_result;
-
-typedef struct {
-    specification_entry *hits;
-    size_t hits_length;
-    unsigned total;
-    const char *scroll_id;
-} specification_search;
-
-typedef struct specification_search_result {
-    specification_search *result;
-    int status;
-    const char *error;
-    const char *stack;
-} specification_search_result;
-
-typedef struct  {
-    bool persisted;
-    const char *name;
-} collection_entry;
-
-typedef struct collection_entry_result {
-    collection_entry* result;
-    size_t result_length;
-    int status;
-    const char *error;
-    const char *stack;
-} collection_entry_result;
-
-typedef void (*kuzzle_notification_listener)(notification_result*, void*);
-typedef void (*kuzzle_subscribe_listener)(room_result*, void*);
-
-# ifdef __cplusplus
-}
-# endif
-
-#endif
diff --git a/internal/wrappers/headers/realtime.hpp b/internal/wrappers/headers/realtime.hpp
deleted file mode 100644
index 0e2f2eb6..00000000
--- a/internal/wrappers/headers/realtime.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef _KUZZLE_REALTIME_HPP
-#define _KUZZLE_REALTIME_HPP
-
-#include "exceptions.hpp"
-#include "core.hpp"
-#include <map>
-#include <functional>
-
-typedef std::function<void(const kuzzleio::notification_result*)> NotificationListener;
-
-namespace kuzzleio {
-
-  class Kuzzle;
-
-  class Realtime {
-    realtime *_realtime;
-    std::map<std::string, NotificationListener*> _listener_instances;
-    Realtime();
-
-    public:
-      Realtime(Kuzzle* kuzzle);
-      Realtime(Kuzzle* kuzzle, realtime* realtime);
-      virtual ~Realtime();
-      int count(const std::string& index, const std::string& collection, const std::string& roomId, query_options *options=nullptr);
-      std::string list(const std::string& index, const std::string& collection, query_options *options=nullptr);
-      void publish(const std::string& index, const std::string& collection, const std::string& body, query_options *options=nullptr);
-      std::string subscribe(const std::string& index, const std::string& collection, const std::string& body, NotificationListener* cb, room_options* options=nullptr);
-      void unsubscribe(const std::string& roomId, query_options *options=nullptr);
-      bool validate(const std::string& index, const std::string& collection, const std::string& body, query_options *options=nullptr);
-
-      NotificationListener* getListener(const std::string& roomId);
-  };
-}
-
-#endif
diff --git a/internal/wrappers/headers/sdk_wrappers_internal.h b/internal/wrappers/headers/sdk_wrappers_internal.h
deleted file mode 100644
index 5589754f..00000000
--- a/internal/wrappers/headers/sdk_wrappers_internal.h
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef __SDK_WRAPPERS_INTERNAL
-#define __SDK_WRAPPERS_INTERNAL
-
-# ifdef __cplusplus
-using namespace kuzzleio;
-# endif
-
-typedef char *char_ptr;
-typedef policy *policy_ptr;
-typedef policy_restriction *policy_restriction_ptr;
-typedef query_object *query_object_ptr;
-
-// used by memory_storage.geopos
-typedef double geopos_arr[2];
-
-static void set_errno(int err) {
-  errno = err;
-}
-
-static void kuzzle_notify(kuzzle_notification_listener f, notification_result* res, void* data) {
-    f(res, data);
-}
-
-static void kuzzle_trigger_event(int event, kuzzle_event_listener f, char* res, void* data) {
-    f(event, res, data);
-}
-
-static void room_on_subscribe(kuzzle_subscribe_listener f, room_result* res, void* data) {
-    f(res, data);
-}
-
-static bool kuzzle_filter_query(kuzzle_queue_filter f, const char *rq) {
-  return f(rq);
-}
-
-#endif
diff --git a/internal/wrappers/headers/server.hpp b/internal/wrappers/headers/server.hpp
deleted file mode 100644
index 3253b4d8..00000000
--- a/internal/wrappers/headers/server.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef _KUZZLE_SERVER_HPP
-#define _KUZZLE_SERVER_HPP
-
-#include "exceptions.hpp"
-#include "core.hpp"
-
-namespace kuzzleio {
-  class Server {
-    server *_server;
-    Server();
-
-    public:
-      Server(Kuzzle* kuzzle);
-      Server(Kuzzle *kuzzle, server *server);
-      virtual ~Server();
-      bool adminExists(query_options *options);
-      std::string getAllStats(query_options* options=nullptr);
-      std::string getStats(time_t start, time_t end, query_options* options=nullptr);
-      std::string getLastStats(query_options* options=nullptr);
-      std::string getConfig(query_options* options=nullptr);
-      std::string info(query_options* options=nullptr);
-      long long now(query_options* options=nullptr);
-  };
-}
-
-#endif
diff --git a/internal/wrappers/templates/android/core.i b/internal/wrappers/templates/android/core.i
deleted file mode 100644
index 5eaea904..00000000
--- a/internal/wrappers/templates/android/core.i
+++ /dev/null
@@ -1,107 +0,0 @@
-%rename(TokenValidity) token_validity;
-%rename(AckResponse) ack_response;
-%rename(queueTTL) queue_ttl;
-%rename(Options, match="class") options;
-%rename(QueryOptions) query_options;
-%rename(JsonObject) json_object;
-%rename(JsonResult) json_result;
-%rename(LoginResult) login_result;
-%rename(BoolResult) bool_result;
-%rename(Statistics) statistics;
-%rename(AllStatisticsResult) all_statistics_result;
-%rename(StatisticsResult) statistics_result;
-%rename(CollectionsList) collection_entry;
-%rename(CollectionsListResult) collection_entry_result;
-%rename(StringArrayResult) string_array_result;
-%rename(KuzzleResponse) kuzzle_response;
-%rename(KuzzleRequest) kuzzle_request;
-%rename(ShardsResult) shards_result;
-%rename(DateResult) date_result;
-%rename(UserData) user_data;
-%rename(KuzzleUser, match="class") kuzzle_user;
-%rename(RoomOptions) room_options;
-%rename(SearchFilters) search_filters;
-%rename(SearchResult) search_result;
-%rename(NotificationResult) notification_result;
-%rename(NotificationContent) notification_content;
-%rename(SubscribeToSelf) subscribe_to_self;
-
-%rename(delete) delete_;
-
-%ignore *::error;
-%ignore *::status;
-%ignore *::stack;
-
-%{
-#include "collection.cpp"
-#include "auth.cpp"
-#include "index.cpp"
-#include "server.cpp"
-#include "document.cpp"
-%}
-
-%ignore getListener;
-%ignore getListeners;
-
-%include "../java/std_function.i"
-%std_function(NotificationListener, void, onMessage, const kuzzleio::notification_result*);
-%std_function(EventListener, void, trigger, const std::string);
-
-%{
-#include "kuzzle.cpp"
-#include "realtime.cpp"
-%}
-
-%include "../java/exceptions.i"
-%include "std_string.i"
-%include "typemap.i"
-%include "json_wrap/kuzzle.i"
-%include "json_wrap/listeners.i"
-%include "json_wrap/document.i"
-%include "json_wrap/realtime.i"
-%include "json_wrap/server.i"
-%include "json_wrap/collection.i"
-%include "json_wrap/auth.i"
-
-%include "kcore.i"
-
-%include "std_vector.i"
-
-typedef long long time_t;
-
-%template(StringVector) std::vector<std::string>;
-
-%typemap(out) const StringVector& %{
-    return $1;
-%}
-
-%pragma(java) jniclasscode=%{
-  static {
-    try {
-      System.loadLibrary("kuzzle-wrapper-android");
-    } catch (Exception e) {
-      System.err.println("Native code library failed to load. \n");
-      e.printStackTrace();
-      System.exit(1);
-    }
-  }
-%}
-
-%extend kuzzleio::options {
-    options() {
-        options *o = kuzzle_new_options();
-        return o;
-    }
-
-    ~options() {
-        free($self);
-    }
-}
-
-%include "kuzzle.cpp"
-%include "collection.cpp"
-%include "document.cpp"
-%include "realtime.cpp"
-%include "auth.cpp"
-%include "index.cpp"
-%include "server.cpp"
diff --git a/internal/wrappers/templates/android/json_wrap/auth.i b/internal/wrappers/templates/android/json_wrap/auth.i
deleted file mode 100644
index a7ca9792..00000000
--- a/internal/wrappers/templates/android/json_wrap/auth.i
+++ /dev/null
@@ -1,135 +0,0 @@
-%javamethodmodifiers kuzzleio::Auth::createMyCredentials(const std::string& strategy, const std::string& credentials, query_options* options) "private";
-%javamethodmodifiers kuzzleio::Auth::createMyCredentials(const std::string& strategy, const std::string& credentials) "private";
-%rename (_getMyCredentials) kuzzleio::Auth::getMyCredentials(const std::string& strategy, query_options *options);
-%rename (_getMyCredentials) kuzzleio::Auth::getMyCredentials(const std::string& strategy);
-%javamethodmodifiers kuzzleio::Auth::getMyCredentials(const std::string& strategy, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Auth::getMyCredentials(const std::string& strategy) "private";
-%javamethodmodifiers kuzzleio::Auth::login(const std::string& strategy, const std::string& credentials, int expiresIn) "private";
-%javamethodmodifiers kuzzleio::Auth::login(const std::string& strategy, const std::string& credentials) "private";
-%rename (_updateMyCredentials) kuzzleio::Auth::updateMyCredentials(const std::string& strategy, const std::string& credentials, query_options *options);
-%rename (_updateMyCredentials) kuzzleio::Auth::updateMyCredentials(const std::string& strategy, const std::string& credentials);
-%javamethodmodifiers kuzzleio::Auth::updateMyCredentials(const std::string& strategy, const std::string& credentials, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Auth::updateMyCredentials(const std::string& strategy, const std::string& credentials) "private";
-%javamethodmodifiers kuzzleio::Auth::updateSelf(const std::string& content, query_options* options) "private";
-%javamethodmodifiers kuzzleio::Auth::updateSelf(const std::string& content) "private";
-%javamethodmodifiers kuzzleio::Auth::validateMyCredentials(const std::string& strategy, const std::string& credentials, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Auth::validateMyCredentials(const std::string& strategy, const std::string& credentials) "private";
-
-%typemap(javaimports) kuzzleio::Auth %{
-import android.webkit.WebView;
-import android.webkit.WebViewClient;
-import java.io.IOException;
-import java.net.HttpURLConnection;
-import java.io.BufferedReader;
-import java.io.InputStreamReader;
-import java.net.URI;
-%}
-%typemap(javacode) kuzzleio::Auth %{
-  public org.json.JSONObject createMyCredentials(String strategy, org.json.JSONObject credentials, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = createMyCredentials(strategy, credentials.toString(), options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject createMyCredentials(String strategy, org.json.JSONObject credentials) throws org.json.JSONException, KuzzleException {
-    return createMyCredentials(strategy, credentials, null);
-  }
-
-  public org.json.JSONObject getMyCredentials(String strategy, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = _getMyCredentials(strategy, options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject getMyCredentials(String strategy) throws org.json.JSONException, KuzzleException {
-    return getMyCredentials(strategy, null);
-  }
-
-  public String login(String strategy, org.json.JSONObject credentials, int expiresIn) throws org.json.JSONException, KuzzleException {
-    return login(strategy, credentials.toString(), expiresIn);
-  }
-
-  public String login(String strategy, org.json.JSONObject credentials) throws org.json.JSONException, KuzzleException {
-    return login(strategy, credentials.toString());
-  }
-
-  public org.json.JSONObject updateMyCredentials(String strategy, org.json.JSONObject credentials, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = _updateMyCredentials(strategy, credentials.toString(), options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject updateMyCredentials(String strategy, org.json.JSONObject credentials) throws org.json.JSONException, KuzzleException {
-    return updateMyCredentials(strategy, credentials, null);
-  }
-
-  public KuzzleUser updateSelf(org.json.JSONObject content, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    return updateSelf(content.toString(), options);
-  }
-
-  public KuzzleUser updateSelf(org.json.JSONObject content) throws org.json.JSONException, KuzzleException {
-    return updateSelf(content, null);
-  }
-
-  public boolean validateMyCredentials(String strategy, org.json.JSONObject credentials, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    return validateMyCredentials(strategy, credentials.toString(), options);
-  }
-
-  public boolean validateMyCredentials(String strategy, org.json.JSONObject credentials) throws org.json.JSONException, KuzzleException {
-    return validateMyCredentials(strategy, credentials, null);
-  }
-
-  /**
-   * WebViewClient to forward kuzzle's jwt token after an OAuth authentication
-   */
-  protected class KuzzleWebViewClient extends WebViewClient {
-    @Override
-    public boolean shouldOverrideUrlLoading(WebView view, final String url) {
-      if (url.contains("code=")) {
-        new Thread(new Runnable() {
-          @Override
-          public void run() {
-            try {
-              HttpURLConnection conn = (HttpURLConnection) URI.create(url).toURL().openConnection();
-              conn.setRequestMethod("GET");
-              conn.setUseCaches(false);
-
-              BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
-              StringBuilder sb = new StringBuilder();
-              String line;
-              while ((line = br.readLine()) != null) {
-                sb.append(line);
-              }
-              br.close();
-
-              org.json.JSONObject response = new org.json.JSONObject(sb.toString());
-              if (response.isNull("error")) {
-                Auth.this.setJwt(response.getString("jwt"));
-              } else {
-                Auth.this.get_kuzzle().emitEvent(Event.LOGIN_ATTEMPT, new org.json.JSONObject()
-                  .put("success", false)
-                  .put("error", response.getJSONObject("error")));
-              }
-            } catch (org.json.JSONException | IOException e) {
-              e.printStackTrace();
-            }
-          }
-        }).start();
-      } else {
-        view.loadUrl(url);
-      }
-      return true;
-    }
-  }
-
-  /**
-   * Gets kuzzle web view client.
-   *
-   * @return the kuzzle web view client
-   */
-  public KuzzleWebViewClient getKuzzleWebViewClient() {
-    return new KuzzleWebViewClient();
-  }
-%}
-
-
diff --git a/internal/wrappers/templates/android/json_wrap/collection.i b/internal/wrappers/templates/android/json_wrap/collection.i
deleted file mode 100644
index f126c91b..00000000
--- a/internal/wrappers/templates/android/json_wrap/collection.i
+++ /dev/null
@@ -1,89 +0,0 @@
-%javamethodmodifiers kuzzleio::Collection::create(const std::string& index, const std::string& collection, const std::string* body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Collection::create(const std::string& index, const std::string& collection, const std::string* body) "private";
-%rename (_list) kuzzleio::Collection::list(const std::string& index, query_options *options);
-%rename (_list) kuzzleio::Collection::list(const std::string& index);
-%javamethodmodifiers kuzzleio::Collection::list(const std::string& index, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Collection::list(const std::string& index) "private";
-%rename (_getMapping) kuzzleio::Collection::getMapping(const std::string& index, const std::string& collection, query_options *options);
-%rename (_getMapping) kuzzleio::Collection::getMapping(const std::string& index, const std::string& collection);
-%javamethodmodifiers kuzzleio::Collection::getMapping(const std::string& index, const std::string& collection, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Collection::getMapping(const std::string& index, const std::string& collection) "private";
-%javamethodmodifiers kuzzleio::Collection::updateMapping(const std::string& index, const std::string& collection, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Collection::updateMapping(const std::string& index, const std::string& collection, const std::string& body) "private";
-%rename (_getSpecifications) kuzzleio::Collection::getSpecifications(const std::string& index, const std::string& collection, query_options *options);
-%rename (_getSpecifications) kuzzleio::Collection::getSpecifications(const std::string& index, const std::string& collection);
-%javamethodmodifiers kuzzleio::Collection::getSpecifications(const std::string& index, const std::string& collection, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Collection::getSpecifications(const std::string& index, const std::string& collection) "private";
-%rename (_updateSpecifications) kuzzleio::Collection::updateSpecifications(const std::string& index, const std::string& collection, const std::string& body, query_options *options);
-%rename (_updateSpecifications) kuzzleio::Collection::updateSpecifications(const std::string& index, const std::string& collection, const std::string& body);
-%javamethodmodifiers kuzzleio::Collection::updateSpecifications(const std::string& index, const std::string& collection, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Collection::updateSpecifications(const std::string& index, const std::string& collection, const std::string& body) "private";
-%javamethodmodifiers kuzzleio::Collection::validateSpecifications(const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Collection::validateSpecifications(const std::string& body) "private";
-
-%typemap(javacode) kuzzleio::Collection %{
-  public void create(String index, String collection, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    create(index, collection, body.toString(), options);
-  }
-
-  public void create(String index, String collection, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    create(index, collection, body, null);
-  }
-
-  public org.json.JSONObject list(String index, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = _list(index, options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject list(String index) throws org.json.JSONException, KuzzleException {
-    return list(index, null);
-  }
-
-  public org.json.JSONObject getMapping(String index, String collection, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res =_getMapping(index, collection, options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject getMapping(String index, String collection) throws org.json.JSONException, KuzzleException {
-    return getMapping(index, collection, null);
-  }
-
-  public void updateMapping(String index, String collection, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    updateMapping(index, collection, body.toString(), options);
-  }
-
-  public void updateMapping(String index, String collection, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    updateMapping(index, collection, body, null);
-  }
-
-  public org.json.JSONObject getSpecifications(String index, String collection, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = _getSpecifications(index, collection, options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject getSpecifications(String index, String collection) throws org.json.JSONException, KuzzleException {
-    return getSpecifications(index, collection, null);
-  }
-
-  public org.json.JSONObject updateSpecifications(String index, String collection, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = _updateSpecifications(index, collection, body.toString(), options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject updateSpecifications(String index, String collection, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    return updateSpecifications(index, collection, body, null);
-  }
-
-  public boolean validateSpecifications(org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    return validateSpecifications(body.toString(), options);
-  }
-
-  public boolean validateSpecifications(org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    return validateSpecifications(body, null);
-  }
-
-%}
diff --git a/internal/wrappers/templates/android/json_wrap/document.i b/internal/wrappers/templates/android/json_wrap/document.i
deleted file mode 100644
index 08cf4432..00000000
--- a/internal/wrappers/templates/android/json_wrap/document.i
+++ /dev/null
@@ -1,168 +0,0 @@
-%javamethodmodifiers kuzzleio::Document::count(const std::string& index, const std::string& collection, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Document::count(const std::string& index, const std::string& collection, const std::string& body) "private";
-%javamethodmodifiers kuzzleio::Document::create(const std::string& index, const std::string& collection, const std::string& id, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Document::create(const std::string& index, const std::string& collection, const std::string& id, const std::string& body) "private";
-%javamethodmodifiers kuzzleio::Document::createOrReplace(const std::string& index, const std::string& collection, const std::string& id, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Document::createOrReplace(const std::string& index, const std::string& collection, const std::string& id, const std::string& body) "private";
-%javamethodmodifiers kuzzleio::Document::deleteByQuery(const std::string& index, const std::string& collection, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Document::deleteByQuery(const std::string& index, const std::string& collection, const std::string& body) "private";
-%rename (_get) kuzzleio::Document::get(const std::string& index, const std::string& collection, const std::string& id, query_options *options);
-%rename (_get) kuzzleio::Document::get(const std::string& index, const std::string& collection, const std::string& id);
-%javamethodmodifiers kuzzleio::Document::get(const std::string& index, const std::string& collection, const std::string& id, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Document::get(const std::string& index, const std::string& collection, const std::string& id) "private";
-%javamethodmodifiers kuzzleio::Document::replace(const std::string& index, const std::string& collection, const std::string& id, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Document::replace(const std::string& index, const std::string& collection, const std::string& id, const std::string& body) "private";
-%javamethodmodifiers kuzzleio::Document::update(const std::string& index, const std::string& collection, const std::string& id, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Document::update(const std::string& index, const std::string& collection, const std::string& id, const std::string& body) "private";
-%javamethodmodifiers kuzzleio::Document::validate(const std::string& index, const std::string& collection, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Document::validate(const std::string& index, const std::string& collection, const std::string& body) "private";
-%javamethodmodifiers kuzzleio::Document::search(const std::string& index, const std::string& collection, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Document::search(const std::string& index, const std::string& collection, const std::string& body) "private";
-%javamethodmodifiers kuzzleio::Document::mCreate(const std::string& index, const std::string& collection, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Document::mCreate(const std::string& index, const std::string& collection, const std::string& body) "private";
-%javamethodmodifiers kuzzleio::Document::mCreateOrReplace(const std::string& index, const std::string& collection, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Document::mCreateOrReplace(const std::string& index, const std::string& collection, const std::string& body) "private";
-%rename (_mGet) kuzzleio::Document::mGet(const std::string& index, const std::string& collection, const std::vector<std::string>& ids, bool includeTrash, query_options *options);
-%rename (_mGet) kuzzleio::Document::mGet(const std::string& index, const std::string& collection, const std::vector<std::string>& ids, bool includeTrash);
-%javamethodmodifiers kuzzleio::Document::mGet(const std::string& index, const std::string& collection, const std::vector<std::string>& ids, bool includeTrash, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Document::mGet(const std::string& index, const std::string& collection, const std::vector<std::string>& ids, bool includeTrash) "private";
-%javamethodmodifiers kuzzleio::Document::mReplace(const std::string& index, const std::string& collection, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Document::mReplace(const std::string& index, const std::string& collection, const std::string& body) "private";
-%javamethodmodifiers kuzzleio::Document::mUpdate(const std::string& index, const std::string& collection, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Document::mUpdate(const std::string& index, const std::string& collection, const std::string& body) "private";
-
-%typemap(javacode) kuzzleio::Document %{
-
-  public int count(String index, String collection, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    return count(index, collection, body.toString(), options);
-  }
-
-  public int count(String index, String collection, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    return count(index, collection, body, null);
-  }
-
-  public org.json.JSONObject create(String index, String collection, String id, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = create(index, collection, id, body.toString(), options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject create(String index, String collection, String id, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    return create(index, collection, id, body, null);
-  }
-
-  public org.json.JSONObject createOrReplace(String index, String collection, String id, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = createOrReplace(index, collection, id, body.toString(), options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject createOrReplace(String index, String collection, String id, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    return createOrReplace(index, collection, id, body, null);
-  }
-
-  public StringVector deleteByQuery(String index, String collection, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    return deleteByQuery(index, collection, body.toString(), options);
-  }
-
-  public StringVector deleteByQuery(String index, String collection, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    return deleteByQuery(index, collection, body, null);
-  }
-
-  public org.json.JSONObject get(String index, String collection, String id, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = _get(index, collection, id, options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject get(String index, String collection, String id) throws org.json.JSONException, KuzzleException {
-    return get(index, collection, id, null);
-  }
-
-  public org.json.JSONObject replace(String index, String collection, String id, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = replace(index, collection, id, body.toString(), options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject replace(String index, String collection, String id, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    return replace(index, collection, id, body, null);
-  }
-
-  public org.json.JSONObject update(String index, String collection, String id, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = update(index, collection, id, body.toString(), options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject update(String index, String collection, String id, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    return update(index, collection, id, body, null);
-  }
-
-  public boolean validate(String index, String collection, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    return validate(index, collection, body.toString(), options);
-  }
-
-  public boolean validate(String index, String collection, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    return validate(index, collection, body, null);
-  }
-
-  public SearchResult search(String index, String collection, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    return search(index, collection, body.toString(), options);
-  }
-
-  public SearchResult search(String index, String collection, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    return search(index, collection, body, null);
-  }
-
-  public org.json.JSONObject mCreate(String index, String collection, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = mCreate(index, collection, body.toString(), options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject mCreate(String index, String collection, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    return mCreate(index, collection, body, null);
-  }
-
-  public org.json.JSONObject mCreateOrReplace(String index, String collection, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = mCreateOrReplace(index, collection, body.toString(), options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject mCreateOrReplace(String index, String collection, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    return mCreateOrReplace(index, collection, body, null);
-  }
-
-  public org.json.JSONObject mGet(String index, String collection, StringVector ids, boolean includeTrash, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = _mGet(index, collection, ids, includeTrash, options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject mGet(String index, String collection, StringVector ids, boolean includeTrash) throws org.json.JSONException, KuzzleException {
-    return mGet(index, collection, ids, includeTrash, null);
-  }
-
-  public org.json.JSONObject mReplace(String index, String collection, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = mReplace(index, collection, body.toString(), options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject mReplace(String index, String collection, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    return mReplace(index, collection, body, null);
-  }
-
-  public org.json.JSONObject mUpdate(String index, String collection, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = mUpdate(index, collection, body.toString(), options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject mUpdate(String index, String collection, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    return mUpdate(index, collection, body, null);
-  }
-
-%}
diff --git a/internal/wrappers/templates/android/json_wrap/kuzzle.i b/internal/wrappers/templates/android/json_wrap/kuzzle.i
deleted file mode 100644
index 58d83d02..00000000
--- a/internal/wrappers/templates/android/json_wrap/kuzzle.i
+++ /dev/null
@@ -1,7 +0,0 @@
-%rename (_emitEvent) kuzzleio::Kuzzle::emitEvent(Event& event, const std::string& body);
-
-%typemap(javacode) kuzzleio::Kuzzle %{
-  public void emitEvent(Event event, org.json.JSONObject body) throws org.json.JSONException {
-    _emitEvent(event, body.toString());
-  }
-%}
\ No newline at end of file
diff --git a/internal/wrappers/templates/android/json_wrap/listeners.i b/internal/wrappers/templates/android/json_wrap/listeners.i
deleted file mode 100644
index aaf32760..00000000
--- a/internal/wrappers/templates/android/json_wrap/listeners.i
+++ /dev/null
@@ -1,48 +0,0 @@
-%define TYPEMAP_DIRECTOR_INPUT(JNI, CppType, JavaType, JNITypeFrom, JNITypeTo)
-  %typemap(jni) CppType JNI
-  %typemap(jtype) CppType JavaType
-  %typemap(jstype) CppType JavaType
-  %typemap(javain) CppType "$javainput"
-  %typemap(in) CppType {}
-  %typemap(javadirectorin) CppType "$jniinput";
-  %typemap(directorin, descriptor="L"JNITypeTo";", noblock=1) CppType {
-    if ($input) {
-      const jclass clazz = JCALL1(FindClass, jenv, JNITypeTo);
-      jmethodID methodID = jenv->GetMethodID(clazz, "<init>", "(L"JNITypeFrom";)V");
-      jobject a = jenv->NewObject(clazz, methodID, $input);
-      if (!a) return $null;
-      $input = a;
-    } else {
-      $input = NULL;
-    }
-    Swig::LocalRefGuard $1_refguard(jenv, $input);
-  }
-  %apply CppType { CppType };
-%enddef
-
-
-/********************************************/
-/*               EventListener              */
-/********************************************/
-
-TYPEMAP_DIRECTOR_INPUT("jobject", const std::string& jsonResponse, "org.json.JSONObject", "java/lang/String", "org/json/JSONObject")
-
-
-/********************************************/
-/*               NotificationListener       */
-/********************************************/
-
-%ignore kuzzleio::Realtime::getListener(const std::string& roomId);
-%typemap(jni) char* kuzzleio::notification_content::content "jstring"
-%typemap(jstype) char* kuzzleio::notification_content::content "org.json.JSONObject"
-
-%typemap(javaout) char* kuzzleio::notification_content::content {
-    org.json.JSONObject res = null;
-    try {
-      res = new org.json.JSONObject($jnicall);
-    } catch (org.json.JSONException e) {
-      throw new RuntimeException(e);
-    }
-
-    return res;
-  }
\ No newline at end of file
diff --git a/internal/wrappers/templates/android/json_wrap/realtime.i b/internal/wrappers/templates/android/json_wrap/realtime.i
deleted file mode 100644
index 8a020f2d..00000000
--- a/internal/wrappers/templates/android/json_wrap/realtime.i
+++ /dev/null
@@ -1,47 +0,0 @@
-%rename (_list) kuzzleio::Realtime::list(const std::string& index, const std::string& collection, query_options *options);
-%rename (_list) kuzzleio::Realtime::list(const std::string& index, const std::string& collection);
-%javamethodmodifiers kuzzleio::Realtime::list(const std::string& index, const std::string& collection, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Realtime::list(const std::string& index, const std::string& collection) "private";
-%javamethodmodifiers kuzzleio::Realtime::publish(const std::string& index, const std::string& collection, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Realtime::publish(const std::string& index, const std::string& collection, const std::string& body) "private";
-%javamethodmodifiers kuzzleio::Realtime::subscribe(const std::string& index, const std::string& collection, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Realtime::subscribe(const std::string& index, const std::string& collection, const std::string& body) "private";
-%javamethodmodifiers kuzzleio::Realtime::validate(const std::string& index, const std::string& collection, const std::string& body, query_options *options) "private";
-%javamethodmodifiers kuzzleio::Realtime::validate(const std::string& index, const std::string& collection, const std::string& body) "private";
-
-%typemap(javacode) kuzzleio::Realtime %{
-
-  public org.json.JSONObject list(String index, String collection, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = _list(index, collection, options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject list(String index, String collection) throws org.json.JSONException, KuzzleException {
-    return list(index, collection, null);
-  }
-
-  public void publish(String index, String collection, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    publish(index, collection, body.toString(), options);
-  }
-
-  public void publish(String index, String collection, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    publish(index, collection, body, null);    
-  }
-
-  public String subscribe(String index, String collection, org.json.JSONObject body, NotificationListener cb, RoomOptions options) throws org.json.JSONException, KuzzleException {
-    return subscribe(index, collection, body.toString(), cb, options);
-  }
-
-  public String subscribe(String index, String collection, org.json.JSONObject body, NotificationListener cb) throws org.json.JSONException, KuzzleException {
-    return subscribe(index, collection, body, cb, null);
-  }
-
-  public boolean validate(String index, String collection, org.json.JSONObject body, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    return validate(index, collection, body.toString(), options);
-  }
-
-  public boolean validate(String index, String collection, org.json.JSONObject body) throws org.json.JSONException, KuzzleException {
-    return validate(index, collection, body, null);    
-  }
-%}
\ No newline at end of file
diff --git a/internal/wrappers/templates/android/json_wrap/server.i b/internal/wrappers/templates/android/json_wrap/server.i
deleted file mode 100644
index f6431bec..00000000
--- a/internal/wrappers/templates/android/json_wrap/server.i
+++ /dev/null
@@ -1,97 +0,0 @@
-%rename (_getAllStats) kuzzleio::Server::getAllStats(query_options *options);
-%rename (_getAllStats) kuzzleio::Server::getAllStats();
-%javamethodmodifiers kuzzleio::Server::getAllStats(query_options *options) "private";
-%javamethodmodifiers kuzzleio::Server::getAllStats() "private";
-%rename (_getStats) kuzzleio::Server::getStats(time_t start, time_t end, query_options* options);
-%rename (_getStats) kuzzleio::Server::getAllStats(time_t start, time_t end);
-%javamethodmodifiers kuzzleio::Server::getStats(time_t start, time_t end, query_options* options) "private";
-%javamethodmodifiers kuzzleio::Server::getStats(time_t start, time_t end) "private";
-%rename (_getLastStats) kuzzleio::Server::getLastStats(query_options *options);
-%rename (_getLastStats) kuzzleio::Server::getLastStats();
-%javamethodmodifiers kuzzleio::Server::getLastStats(query_options *options) "private";
-%javamethodmodifiers kuzzleio::Server::getLastStats() "private";
-%rename (_getConfig) kuzzleio::Server::getConfig(query_options *options);
-%rename (_getConfig) kuzzleio::Server::getConfig();
-%javamethodmodifiers kuzzleio::Server::getConfig(query_options *options) "private";
-%javamethodmodifiers kuzzleio::Server::getConfig() "private";
-%rename (_info) kuzzleio::Server::info(query_options *options);
-%rename (_info) kuzzleio::Server::info();
-%javamethodmodifiers kuzzleio::Server::info(query_options *options) "private";
-%javamethodmodifiers kuzzleio::Server::info() "private";
-%rename (_now) kuzzleio::Server::now(query_options*);
-%rename (_now) kuzzleio::Server::now();
-%javamethodmodifiers kuzzleio::Server::now(query_options* options) "private";
-%javamethodmodifiers kuzzleio::Server::now() "private";
-
-%typemap(javacode) kuzzleio::Server %{
-  public org.json.JSONObject getAllStats(QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = _getAllStats(options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject getAllStats() throws org.json.JSONException, KuzzleException {
-    return getAllStats(null);
-  }
-
-  public org.json.JSONObject getStats(java.util.Date start, java.util.Date end, QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = _getStats(start.getTime(), end.getTime(), options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject getStats(java.util.Date start, java.util.Date end) throws org.json.JSONException, KuzzleException {
-    return getStats(start, end, null);
-  }
-
-  public org.json.JSONObject getLastStats(QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = _getLastStats(options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject getLastStats() throws org.json.JSONException, KuzzleException {
-    return getLastStats(null);
-  }
-
-  public org.json.JSONObject getConfig(QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = _getConfig(options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject getConfig() throws org.json.JSONException, KuzzleException {
-    return getConfig(null);
-  }
-
-  public org.json.JSONObject info(QueryOptions options) throws org.json.JSONException, KuzzleException {
-    String res = _info(options);
-
-    return new org.json.JSONObject(res);
-  }
-
-  public org.json.JSONObject info() throws org.json.JSONException, KuzzleException {
-    return info(null);
-  }
-
-  /**
-   * {@link #now(QueryOptions)}
-   */
-  public java.util.Date now() {
-    long res = _now();
-
-    return new java.util.Date(res);
-  }
-
-  /**
-   * Returns the current Kuzzle UTC timestamp
-   *
-   * @param options - Request options
-   * @return a Date
-   */
-  public java.util.Date now(QueryOptions options) {
-    long res = _now(options);
-
-    return new java.util.Date(res);
-  }
-%}
\ No newline at end of file
diff --git a/internal/wrappers/templates/android/kcore.i b/internal/wrappers/templates/android/kcore.i
deleted file mode 100644
index 8cc40fe6..00000000
--- a/internal/wrappers/templates/android/kcore.i
+++ /dev/null
@@ -1,30 +0,0 @@
-/* File : kcore.i */
-
-%module(directors="1") kuzzlesdk
-%{
-#include "exceptions.hpp"
-#include "event_emitter.hpp"
-#include "kuzzle.hpp"
-#include "collection.hpp"
-#include "index.hpp"
-#include "server.hpp"
-#include "document.hpp"
-#include "realtime.hpp"
-#include "auth.hpp"
-#include <assert.h>
-%}
-
-%define _Complex
-%enddef
-
-%include "kuzzlesdk.h"
-%include "kuzzle.h"
-%include "exceptions.hpp"
-%include "event_emitter.hpp"
-%include "kuzzle.hpp"
-%include "collection.hpp"
-%include "index.hpp"
-%include "server.hpp"
-%include "document.hpp"
-%include "realtime.hpp"
-%include "auth.hpp"
diff --git a/internal/wrappers/templates/android/typemap.i b/internal/wrappers/templates/android/typemap.i
deleted file mode 100644
index 95255358..00000000
--- a/internal/wrappers/templates/android/typemap.i
+++ /dev/null
@@ -1,35 +0,0 @@
-%include <typemaps.i> 
-
-%typemap(jni) std::string* "jobject"
-%typemap(jtype) std::string* "java.lang.String"
-%typemap(jstype) std::string* "java.lang.String"
-%typemap(javain) std::string* "$javainput"
-%typemap(in) std::string * (std::string strTemp) {
-  jobject oInput = $input;
-  if (oInput != NULL) {
-    jstring sInput = static_cast<jstring>( oInput );
-
-    const char * $1_pstr = (const char *)jenv->GetStringUTFChars(sInput, 0);
-    if (!$1_pstr) return $null;
-    strTemp.assign( $1_pstr );
-    jenv->ReleaseStringUTFChars( sInput, $1_pstr);
-    $1 = &strTemp;
-  } else {
-    $1 = NULL;
-  }
-}
-%apply std::string * { std::string* };
-
-
-%typemap(jni) Event& "jobject"
-%typemap(jtype) Event& "Event"
-%typemap(jstype) Event& "Event"
-%typemap(javain) Event& "$javainput"
-%typemap(in) Event& (Event tmp) {
-  jmethodID swigValueMethod = jenv->GetMethodID(jenv->GetObjectClass($input), "swigValue", "()I");
-  jint swigValue = jenv->CallIntMethod($input, swigValueMethod, 0);
-
-  Event e = (Event)swigValue;
-  $1 = &e;
-}
-%apply Event& event { Event& event };
diff --git a/internal/wrappers/templates/csharp/core.i b/internal/wrappers/templates/csharp/core.i
deleted file mode 100644
index 7e7f8a7b..00000000
--- a/internal/wrappers/templates/csharp/core.i
+++ /dev/null
@@ -1,77 +0,0 @@
-%rename(TokenValidity) token_validity;
-%rename(AckResponse) ack_response;
-%rename(queueTTL) queue_ttl;
-%rename(Options, match="class") options;
-%rename(QueryOptions) query_options;
-%rename(JsonObject) json_object;
-%rename(JsonResult) json_result;
-%rename(LoginResult) login_result;
-%rename(BoolResult) bool_result;
-%rename(Statistics) statistics;
-%rename(AllStatisticsResult) all_statistics_result;
-%rename(StatisticsResult) statistics_result;
-%rename(CollectionsList) collection_entry;
-%rename(CollectionsListResult) collection_entry_result;
-%rename(StringArrayResult) string_array_result;
-%rename(KuzzleResponse) kuzzle_response;
-%rename(KuzzleRequest) kuzzle_request;
-%rename(ShardsResult) shards_result;
-%rename(DateResult) date_result;
-%rename(UserData) user_data;
-%rename(User, match="class") user;
-%rename(RoomOptions) room_options;
-%rename(SearchFilters) search_filters;
-%rename(SearchResult) search_result;
-%rename(NotificationResult) notification_result;
-%rename(NotificationContent) notification_content;
-%rename(SubscribeToSelf) subscribe_to_self;
-%rename(Mapping, match="class") mapping;
-
-%rename(_auth, match="class") auth;
-%rename(_kuzzle, match="class") kuzzle;
-%rename(_realtime, match="class") realtime;
-%rename(_collection, match="class") collection;
-%rename(_document, match="class") document;
-%rename(_server, match="class") server;
-
-%ignore *::error;
-%ignore *::status;
-%ignore *::stack;
-
-%feature("director") NotificationListener;
-%feature("director") EventListener;
-%feature("director") SubscribeListener;
-
-%{
-#include "kuzzle.cpp"
-#include "collection.cpp"
-#include "auth.cpp"
-#include "index.cpp"
-#include "server.cpp"
-#include "document.cpp"
-#include "realtime.cpp"
-
-#define SWIG_FILE_WITH_INIT
-%}
-
-%include "stl.i"
-%include "kcore.i"
-
-%extend options {
-    options() {
-        options *o = kuzzle_new_options();
-        return o;
-    }
-
-    ~options() {
-        free($self);
-    }
-}
-
-%include "kuzzle.cpp"
-%include "collection.cpp"
-%include "document.cpp"
-%include "realtime.cpp"
-%include "auth.cpp"
-%include "index.cpp"
-%include "server.cpp"
diff --git a/internal/wrappers/templates/csharp/kcore.i b/internal/wrappers/templates/csharp/kcore.i
deleted file mode 100644
index 2b88794b..00000000
--- a/internal/wrappers/templates/csharp/kcore.i
+++ /dev/null
@@ -1,32 +0,0 @@
-/* File : kcore.i */
-
-%module(directors="1") kuzzlesdk
-%{
-#include "listeners.hpp"
-#include "exceptions.hpp"
-#include "event_emitter.hpp"
-#include "kuzzle.hpp"
-#include "collection.hpp"
-#include "index.hpp"
-#include "server.hpp"
-#include "document.hpp"
-#include "realtime.hpp"
-#include "auth.hpp"
-#include <assert.h>
-%}
-
-%define _Complex
-%enddef
-
-%include "kuzzlesdk.h"
-%include "kuzzle.h"
-%include "listeners.hpp"
-%include "exceptions.hpp"
-%include "event_emitter.hpp"
-%include "kuzzle.hpp"
-%include "collection.hpp"
-%include "index.hpp"
-%include "server.hpp"
-%include "document.hpp"
-%include "realtime.hpp"
-%include "auth.hpp"
diff --git a/internal/wrappers/templates/csharp/test.cs b/internal/wrappers/templates/csharp/test.cs
deleted file mode 100644
index 054280f3..00000000
--- a/internal/wrappers/templates/csharp/test.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-using System;
-using Kuzzleio;
-
-public class Example
-{
-    public static Kuzzle k;
-
-    public static void Main()
-    {
-        k = new Kuzzle("localhost", null);
-        k.server.now();
-    }
-}
\ No newline at end of file
diff --git a/internal/wrappers/templates/java/common.i b/internal/wrappers/templates/java/common.i
deleted file mode 100644
index 7e8e30e2..00000000
--- a/internal/wrappers/templates/java/common.i
+++ /dev/null
@@ -1,125 +0,0 @@
-%rename(TokenValidity) token_validity;
-%rename(AckResponse) ack_response;
-%rename(queueTTL) queue_ttl;
-%rename(Options, match="class") options;
-%rename(QueryOptions) query_options;
-%rename(JsonObject) json_object;
-%rename(JsonResult) json_result;
-%rename(LoginResult) login_result;
-%rename(BoolResult) bool_result;
-%rename(Statistics) statistics;
-%rename(AllStatisticsResult) all_statistics_result;
-%rename(StatisticsResult) statistics_result;
-%rename(CollectionsList) collection_entry;
-%rename(CollectionsListResult) collection_entry_result;
-%rename(StringArrayResult) string_array_result;
-%rename(KuzzleResponse) kuzzle_response;
-%rename(KuzzleRequest) kuzzle_request;
-%rename(ShardsResult) shards_result;
-%rename(DateResult) date_result;
-%rename(UserData) user_data;
-%rename(User, match="class") kuzzle_user;
-%rename(RoomOptions) room_options;
-%rename(SearchFilters) search_filters;
-%rename(SearchResult) search_result;
-%rename(NotificationResult) notification_result;
-%rename(NotificationContent) notification_content;
-%rename(SubscribeToSelf) subscribe_to_self;
-
-%rename(TokenValidity) token_validity;
-%rename(AckResponse) ack_response;
-%rename(queueTTL) queue_ttl;
-%rename(Options, match="class") options;
-%rename(QueryOptions) query_options;
-%rename(JsonObject) json_object;
-%rename(JsonResult) json_result;
-%rename(LoginResult) login_result;
-%rename(BoolResult) bool_result;
-%rename(Statistics) statistics;
-%rename(AllStatisticsResult) all_statistics_result;
-%rename(StatisticsResult) statistics_result;
-%rename(CollectionsList) collection_entry;
-%rename(CollectionsListResult) collection_entry_result;
-%rename(StringArrayResult) string_array_result;
-%rename(KuzzleResponse) kuzzle_response;
-%rename(KuzzleRequest) kuzzle_request;
-%rename(ShardsResult) shards_result;
-%rename(DateResult) date_result;
-%rename(UserData) user_data;
-%rename(User, match="class") user;
-%rename(RoomOptions) room_options;
-%rename(SearchFilters) search_filters;
-%rename(SearchResult) search_result;
-%rename(NotificationResult) notification_result;
-%rename(NotificationContent) notification_content;
-%rename(SubscribeToSelf) subscribe_to_self;
-
-// struct options
-%rename(queueMaxSize) queue_max_size;
-%rename(offlineMode) offline_mode;
-%rename(autoQueue) auto_queue;
-%rename(autoReconnect) auto_reconnect;
-%rename(autoReplay) auto_replay;
-%rename(autoReplay) auto_replay;
-%rename(autoResubscribe) auto_resubscribe;
-%rename(reconnectionDelay) reconnection_delay;
-%rename(replayInterval) replay_interval;
-
-// struct query_options
-%rename(scrollId) scroll_id;
-%rename(ifExist) if_exist;
-%rename(retryOnConflict) retry_on_conflict;
-
-// struct kuzzle_request
-%rename(membersLength) members_length;
-%rename(keysLength) keys_length;
-%rename(fieldsLength) fields_length;
-
-// struct role
-%rename(profileIds) profile_ids;
-%rename(profileIdsLength) profile_ids_length;
-
-// struct notification_result
-%rename(nType) n_type;
-%rename(roomId) room_id;
-
-// struct statistics
-%rename(completedRequests) completed_requests;
-%rename(failedRequests) failed_requests;
-%rename(ongoingRequests) ongoing_requests;
-
-// struct token_validity
-%rename(expiresAt) expires_at;
-
-// struct kuzzle_response
-%rename(requestId) request_id;
-%rename(roomId) room_id;
-
-%rename(delete) delete_;
-
-%ignore *::error;
-%ignore *::stack;
-
-
-%include "std_string.i"
-
-
-%{
-#include "collection.cpp"
-#include "auth.cpp"
-#include "index.cpp"
-#include "server.cpp"
-#include "document.cpp"
-%}
-
-%ignore getListener;
-%ignore getListeners;
-
-%include "std_function.i"
-%std_function(NotificationListener, void, onMessage, const kuzzleio::notification_result*);
-%std_function(EventListener, void, trigger, const std::string);
-
-%{
-#include "kuzzle.cpp"
-#include "realtime.cpp"
-%}
diff --git a/internal/wrappers/templates/java/core.i b/internal/wrappers/templates/java/core.i
deleted file mode 100644
index 9a21c08d..00000000
--- a/internal/wrappers/templates/java/core.i
+++ /dev/null
@@ -1,74 +0,0 @@
-%include "common.i"
-
-%include "exceptions.i"
-%include "std_string.i"
-%include "typemap.i"
-%include "kcore.i"
-
-%include "std_vector.i"
-
-%include "javadoc/kuzzle.i"
-%include "javadoc/document.i"
-%include "javadoc/room.i"
-%include "javadoc/collection.i"
-
-typedef long long time_t;
-
-%template(StringVector) std::vector<std::string>;
-
-%typemap(out) const StringVector& %{
-    return $1;
-%}
-
-%pragma(java) jniclasscode=%{
-  static {
-    try {
-      System.loadLibrary("kuzzle-wrapper-java");
-    } catch (UnsatisfiedLinkError e) {
-      try {
-        java.io.InputStream inputStream = kuzzlesdk.class.getResourceAsStream("/libkuzzle-wrapper-java.so");
-        java.nio.file.Path path = java.nio.file.FileSystems.getDefault().getPath("").toAbsolutePath();
-        String sharedObject = path.toString() + "/libs/libkuzzle-wrapper-java.so";
-
-        try {
-          java.io.File folder = new java.io.File(path.toString() + "/libs/");
-          folder.mkdir();
-        } catch(Exception ee) {}
-
-        java.io.OutputStream outputStream = new java.io.FileOutputStream(new java.io.File(sharedObject));
-
-        int read = 0;
-        byte[] bytes = new byte[1024];
-
-        while ((read = inputStream.read(bytes)) != -1) {
-          outputStream.write(bytes, 0, read);
-        }
-
-        System.load(path.toString() + "/libs/libkuzzle-wrapper-java.so");
-      } catch (Exception ex) {
-        System.err.println("Native code library failed to load. \n");
-        ex.printStackTrace();
-        System.exit(1);
-      }
-    }
-  }
-%}
-
-%extend kuzzleio::options {
-    options() {
-        options *o = kuzzle_new_options();
-        return o;
-    }
-
-    ~options() {
-        free($self);
-    }
-}
-
-%include "kuzzle.cpp"
-%include "collection.cpp"
-%include "document.cpp"
-%include "realtime.cpp"
-%include "auth.cpp"
-%include "index.cpp"
-%include "server.cpp"
diff --git a/internal/wrappers/templates/java/exceptions.i b/internal/wrappers/templates/java/exceptions.i
deleted file mode 100644
index 4b40de4c..00000000
--- a/internal/wrappers/templates/java/exceptions.i
+++ /dev/null
@@ -1,31 +0,0 @@
-%define CATCH(cppException, JNIException)
-  catch (cppException &e) {
-    jclass clazz = jenv->FindClass(JNIException);
-    jenv->ThrowNew(clazz, e.what());
-    return $null;
-  }
-%enddef
-
-%javaexception("io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, 
-                io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, 
-                io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException,
-                io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException,
-                io.kuzzle.sdk.SizeLimitException, io.kuzzle.sdk.UnauthorizedException,
-                io.kuzzle.sdk.KuzzleException") {
-    try {
-        $action
-    } CATCH (kuzzleio::BadRequestException, "io/kuzzle/sdk/BadRequestException")
-    CATCH (kuzzleio::ForbiddenException, "io/kuzzle/sdk/ForbiddenException")
-    CATCH (kuzzleio::GatewayTimeoutException, "io/kuzzle/sdk/GatewayTimeoutException")
-    CATCH (kuzzleio::InternalException, "io/kuzzle/sdk/InternalException")
-    CATCH (kuzzleio::NotFoundException, "io/kuzzle/sdk/NotFoundException")
-    CATCH (kuzzleio::PartialException, "io/kuzzle/sdk/PartialException")
-    CATCH (kuzzleio::PreconditionException, "io/kuzzle/sdk/PreconditionException")
-    CATCH (kuzzleio::ServiceUnavailableException, "io/kuzzle/sdk/ServiceUnavailableException")
-    CATCH (kuzzleio::SizeLimitException, "io/kuzzle/sdk/SizeLimitException")
-    CATCH (kuzzleio::UnauthorizedException, "io/kuzzle/sdk/UnauthorizedException")
-    CATCH (kuzzleio::KuzzleException, "io/kuzzle/sdk/KuzzleException")   
-}
-
-
-%typemap(javabase) kuzzleio::KuzzleException "java.lang.RuntimeException";
diff --git a/internal/wrappers/templates/java/javadoc/collection.i b/internal/wrappers/templates/java/javadoc/collection.i
deleted file mode 100644
index 274027d3..00000000
--- a/internal/wrappers/templates/java/javadoc/collection.i
+++ /dev/null
@@ -1,261 +0,0 @@
-%typemap(javaimports) kuzzleio::Collection "
-/* The type Collection. */"
-
-%javamethodmodifiers kuzzleio::Collection::Collection(Kuzzle *kuzzle, const std::string& collection, const std::string& index) "
-  /**
-   * Constructor
-   *
-   * @param kuzzle  Kuzzle instance
-   * @param collection  Data collection name
-   * @param index  Parent data index name
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::count(search_filters* filters, query_options* options) "
-  /**
-   * Returns the number of documents matching the provided set of filters.
-   * There is a small delay between documents creation and their existence in our search layer,
-   * usually a couple of seconds.
-   * That means that a document that was just been created won’t be returned by this function
-   *
-   * @param filters  Search filters
-   * @param options  Request options
-   * @returns the number of documents
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::count(search_filters* filters) "
-  /**
-   * {@link #count(SearchFilters filters, QueryOptions options)}
-   */
-  public";
-
-
-%javamethodmodifiers kuzzleio::Collection::deleteDocument(const std::string& id, query_options* options) "
-  /**
-   * Delete a single document
-   *
-   * @param id Document unique identifier
-   * @param options  Request options
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::deleteDocument(const std::string& id) "
-  /**
-   * {@link #deleteDocument(String id, QueryOptions options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::fetchDocument(const std::string& id, query_options* options) "
-  /**
-   * Fetch a document from Kuzzle
-   *
-   * @param id  Document unique identifier
-   * @param options  Request options
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::fetchDocument(const std::string& id) "
-  /**
-   * {@link #fetchDocument(String id, QueryOptions options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::mCreateDocument(std::vector<Document*>& documents, query_options* options) "
-  /**
-   * Create multiple documents
-   *
-   * @param documents  List of Document objects to create
-   * @param options  Request options
-   * @return a list of all document created 
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::mCreateDocument(std::vector<Document*>& documents) "
-  /**
-   * {@link #mCreateDocument(DocumentVector documents, QueryOptions options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::mCreateOrReplaceDocument(std::vector<Document*>& documents, query_options* options) "
-  /**
-   * Create or replace multiple documents
-   *
-   * @param documents  Array of Document objects to create or replace
-   * @param options  Request options
-   * @return a list of all created or updated documents
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::mCreateOrReplaceDocument(std::vector<Document*>& documents) "
-  /**
-   * {@link #mCreateOrReplaceDocument(DocumentVector documents, QueryOptions options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::mDeleteDocument(std::vector<std::string>& ids, query_options* options) "
-  /**
-   * Delete multiple documents using their unique IDs
-   *
-   * @param ids  Array of document IDs to delete
-   * @param options  Request options
-   * @return a list of all deleted ids's documents
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::mDeleteDocument(std::vector<std::string>& ids) "
-  /**
-   * {@link #mDeleteDocument(StringVector ids, QueryOptions options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::mGetDocument(std::vector<std::string>& ids, query_options* options) "
-  /**
-   * Fetch multiple documents
-   *
-   * @param ids  Array of document IDs to get
-   * @param options  Request options
-   * @return a list of Documents
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::mGetDocument(std::vector<std::string>& ids) "
-  /**
-   * {@link #mGetDocument(StringVector ids, QueryOptions options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::mReplaceDocument(std::vector<Document*>& documents, query_options* options) "
-  /**
-   * Replace multiple documents
-   *
-   * @param documents  Array of Document objects to replace
-   * @param options  Request options
-   * @return a list of all updated documents
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::mReplaceDocument(std::vector<Document*>& documents) "
-  /**
-   * {@link #mReplaceDocument(DocumentVector documents, QueryOptions options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::mUpdateDocument(std::vector<Document*>& documents, query_options* options) "
-  /**
-   * Update multiple documents
-   *
-   * @param documents  Array of Document objects to replace
-   * @param options  Request options
-   * @return a list of all updated documents
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::mUpdateDocument(std::vector<Document*>& documents) "
-  /**
-   * {@link #mUpdateDocument(DocumentVector documents, QueryOptions options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::publishMessage(json_object* content, query_options* options) "
-  /**
-   * Publish a real-time message
-   *
-   * @param content  Content to publish
-   * @param options  Request options
-   * @return boolean
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::publishMessage(json_object* content) "
-  /**
-   * {@link #publishMessage(JsonObject content, QueryOptions options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::replaceDocument(const std::string& id, Document* document, query_options* options) "
-  /**
-   * Replace an existing document with a new one.
-   *
-   * @param id  Document unique identifier
-   * @param document  New document
-   * @param options  Request options
-   * @return the document
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::replaceDocument(const std::string& id, Document* document) "
-  /**
-   * {@link #replaceDocument(String id, Document document, QueryOptions options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::scroll(const std::string& id, query_options* options) "
-  /**
-   * Gets the next page of results from a previous search or scroll request
-   * 
-   * @param id  Scroll unique identifier
-   * @param options  Request options
-   * @returns a SearchResult
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::scroll(const std::string& id) "
-  /**
-   * {@link #scroll(String id, QueryOptions options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::search(search_filters* filters, query_options* options) "
-  /**
-   * Executes a search on the data collection.
-   * /!\ There is a small delay between documents creation and their existence in our search layer,
-   * usually a couple of seconds.
-   * That means that a document that was just been created won’t be returned by this function.
-   *
-   * @param filters  Search filters to apply
-   * @param options  Request options
-   * @returns a SearchResult
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::search(search_filters* filters) "
-  /**
-   * {@link #search(SearchFilters filters, QueryOptions options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::subscribe(search_filters* filters, NotificationListener *listener, room_options* options) "
-  /**
-   * Subscribes to this data collection with a set of Kuzzle DSL filters.
-   *
-   * @param filters  Subscription filters
-   * @param options  Request options
-   * @param listener  Response callback listener
-   * @return an object with a onDone() callback triggered when the subscription is active
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::subscribe(search_filters* filters, NotificationListener *listener) "
-  /**
-   * {@link #subscribe(SearchFilters filters, NotificationListener listeners)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::updateDocument(const std::string& id, Document *document, query_options* options) "
-  /**
-   * Update parts of a document
-   *
-   * @param id  Document unique identifier
-   * @param content  Document content to update
-   * @param options  Request options
-   * @return the document
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::updateDocument(const std::string& id, Document *document) "
-  /**
-   * {@link #updateDocument(String id, Document document)}
-   */
-  public";
diff --git a/internal/wrappers/templates/java/javadoc/document.i b/internal/wrappers/templates/java/javadoc/document.i
deleted file mode 100644
index b1340c97..00000000
--- a/internal/wrappers/templates/java/javadoc/document.i
+++ /dev/null
@@ -1,170 +0,0 @@
-%typemap(javaimports) kuzzleio::Document "
-/* The type Document. */"
-
-%javamethodmodifiers kuzzleio::Document::Document(Collection *collection, const std::string& id, json_object* content) "
-  /**
-   * Kuzzle handles documents either as real-time messages or as stored documents.
-   * Document is the object representation of one of these documents.
-   *
-   * @param collection           - An instantiated Collection object
-   * @param id                   - Unique document identifier
-   * @param content              - The content of the document
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::Document(Collection *collection, const std::string& id) "
-  /**
-   * Kuzzle handles documents either as real-time messages or as stored documents.
-   * Document is the object representation of one of these documents.
-   *
-   * @param collection           - An instantiated Collection object
-   * @param id                   - Unique document identifier
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::Document(Collection *collection) "
-  /**
-   * Kuzzle handles documents either as real-time messages or as stored documents.
-   * Document is the object representation of one of these documents.
-   *
-   * @param collection - An instantiated Collection object
-   */
-  public";
-
-
-%javamethodmodifiers kuzzleio::Document::create(const std::string& index, const std::string& collection, const std::string& id, const std::string& body="", query_options *options) "
-  /**
-   * Create a new document in kuzzle
-   *
-   * @param index the index where to create the document
-   * @param collection the collection where to create the document
-   * @param id the document id
-   * @param body the content of the document
-   * @param options  Request options
-   * @return document id
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Collection::create(const std::string& index, const std::string& collection, const std::string& id, const std::string& body="") "
-  /**
-   * {@link #create(String index, String collection, String id, String body, QueryOptions options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::delete_(query_options *) "
-  /**
-   * Delete this document from Kuzzle
-   *
-   * @param options - Request options
-   * @return string - id of the deleted document
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::delete_() "
-  /**
-   * {@link #delete_(QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::exists(query_options *) "
-  /**
-   * Ask Kuzzle if this document exists
-   * 
-   * @param options - Request options
-   * @return bool
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::exists() "
-  /**
-   * {@link #exists(QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::publish(query_options *) "
-  /**
-   * Sends the content of this document as a real-time message.
-   *
-   * @param options - Request options
-   * @return bool
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::publish() "
-  /**
-   * {@link #publish(QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::refresh(query_options* options) "
-  /**
-   * Gets a refreshed copy of this document from Kuzzle
-   *
-   * @param options - Request options
-   * @return Document - refreshed document
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::refresh() "
-  /**
-   * {@link #refresh(QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::save(query_options* options) "
-  /**
-   * Saves this document into Kuzzle.
-   * If this is a new document, this function will create it in Kuzzle and the id property will be made available.
-   * Otherwise, this method will replace the latest version of this document in Kuzzle by the current content of this object.
-   *
-   * @param options - Request options
-   * @return Document - saved document
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::save() "
-  /**
-   * {@link #save(QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::setContent(json_object* content, bool replace) "
-  /**
-   * Sets this document content
-   *
-   * @param content - New content for this document
-   * @param replace - true: replace the current content, false (default): update/append it
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::setContent(json_object* content) "
-  /**
-   * {@link #setContent(JsonObject, boolean)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::getContent() "
-  /**
-   * Document content getter
-   *
-   * @return current document content
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::subscribe(NotificationListener* listener, room_options* options) "
-  /**
-   * Subscribe to changes occuring on this document.
-   * Throws an error if this document has not yet been created in Kuzzle.
-   *
-   * @param options - Room object constructor options
-   * @param listener - Response callback listener
-   * @return a Room
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Document::subscribe(NotificationListener* cb) "
-  /**
-   * {@link #subscribe(NotificationListener listener, room_options options)}
-   */
-  public";
diff --git a/internal/wrappers/templates/java/javadoc/kuzzle.i b/internal/wrappers/templates/java/javadoc/kuzzle.i
deleted file mode 100644
index ef77b959..00000000
--- a/internal/wrappers/templates/java/javadoc/kuzzle.i
+++ /dev/null
@@ -1,541 +0,0 @@
-%typemap(javaimports) kuzzleio::Kuzzle "
-/* The type Kuzzle. */"
-
-%javamethodmodifiers kuzzleio::Kuzzle::Kuzzle(const std::string&) "
-  /**
-   * Constructor
-   *
-   * @param host - Target Kuzzle host name or IP address
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::Kuzzle(const std::string&, options*) "
-  /**
-   * Constructor
-   *
-   * @param host - Target Kuzzle host name or IP address
-   * @param options - Request options
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::checkToken(const std::string& token) "
-  /**
-   * Check an authentication token validity
-   *
-   * @param token - Token to check (JWT)
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * @return a TokenValidity object
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::connect() "
-  /**
-   * Connects to a Kuzzle instance using the provided host and port.
-   *
-   * @return a string which represent an error or null
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::createIndex(const std::string&, query_options*) "
-  /**
-   * Create a new data index
-   *
-   * @param index - index name to create
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * @return a BoolResult object
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::createIndex(const std::string&) "
-  /**
-   * {@link #createIndex(String, QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::createMyCredentials(const std::string&, json_object*, query_options*) "
-  /**
-   * Create credentials of the specified strategy for the current user.
-   *
-   * @param strategy - impacted strategy name
-   * @param credentials - credentials to create
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * @return a JsonResult object
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::createMyCredentials(const std::string&, json_object*) "
-  /**
-   * {@link #createIndex(String, QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::deleteMyCredentials(const std::string&, query_options*) "
-  /**
-   * Delete credentials of the specified strategy for the current user.
-   *
-   * @param strategy- Name of the strategy to remove
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * @return a BoolResult object
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::deleteMyCredentials(const std::string&) "
-  /**
-   * {@link #deleteMyCredentials(String, QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::getMyCredentials(const std::string& strategy, query_options *options) "
-  /**
-   * Get credential information of the specified strategy for the current user.
-   *
-   * @param strategy - Strategy name to get
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * @return a JsonResult
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::getMyCredentials(const std::string& strategy) "
-  /**
-   * {@link #getMyCredentials(String, QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::updateMyCredentials(const std::string& strategy, json_object* credentials, query_options *options) "
-  /**
-   * Update credentials of the specified strategy for the current user.
-   *
-   * @param strategy - Strategy name to update
-   * @param credentials - Updated credentials content
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * @return a JsonResult
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::updateMyCredentials(const std::string& strategy, json_object* credentials) "
-  /**
-   * {@link #updateMyCredentials(String, JsonObject, QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::validateMyCredentials(const std::string& strategy, json_object* credentials, query_options* options) "
-  /**
-   * Validate credentials of the specified strategy for the current user.
-   *
-   * @param strategy - Strategy name to validate
-   * @param credentials - Credentials content
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * @return a Bool result
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::validateMyCredentials(const std::string& strategy, json_object* credentials) "
-  /**
-   * {@link #validateMyCredentials(String, JsonObject, QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::logout() "
-  /**
-   * Logout method
-   *
-   * @param listener - Response callback listener
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::login(const std::string&, json_object*, int) "
-  /**
-   * Log-in Strategy name to use for the authentication
-   *
-   * @param strategy - Strategy name to use for the authentication
-   * @param credentials - Login credentials
-   * @param expiresIn - Token expiration delay
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * @return StringResult
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::login(const std::string&, json_object*) "
-  /**
-   * Log-in Strategy name to use for the authentication
-   *
-   * @param strategy - Strategy name to use for the authentication
-   * @param credentials - Login credentials
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::login(const std::string&) "
-  /**
-   * Log-in Strategy name to use for the authentication
-   *
-   * @param strategy - Strategy name to use for the authentication
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::login(const std::string&) "
-  /**
-   * Get all Kuzzle usage statistics frames
-   *
-   * @param options - Request options
-   * @param listener - Response callback listener
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::getAllStatistics(query_options*) "
-  /**
-   * Get all Kuzzle usage statistics frames
-   *
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * @return a AllStatisticsResult
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::getAllStatistics() "
-  /**
-   * {@link #getAllStatistics(QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::getStatistics(unsigned long, query_options*) "
-  /**
-   * Get Kuzzle usage statistics
-   *
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * @return a StatisticsResult
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::getStatistics(unsigned long) "
-  /**
-   * {@link #getStatistics(QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::getAutoRefresh(const std::string&, query_options*) "
-  /**
-   * Gets the autoRefresh value for the provided data index name
-   *
-   * @param index - Data index name
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::getAutoRefresh(const std::string&) "
-  /**
-   * {@link #getAutoRefresh(String, QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::getAutoRefresh() "
-  /**
-   * {@link #getAutoRefresh(String, QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::getJwt() "
-  /**
-   * Authentication token getter
-   *
-   * @return a string which is the jwt
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::getMyRights(query_options*) "
-  /**
-   * Gets the rights array for the currently logged user.
-   *
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * @return a JsonResult
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::getMyRights() "
-  /**
-   * {@link #getMyRights(QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::getServerInfo(query_options*) "
-  /**
-   * Gets server info.
-   *
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * #return a JsonResult
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::getServerInfo() "
-  /**
-   * {@link #getServerInfo(QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::listCollections(const std::string&, query_options*) "
-  /**
-   * List data collections
-   *
-   * @param index - Parent data index name
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * @return a CollectionListResult
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::listCollections(const std::string&) "
-  /**
-   * {@link #listCollections(String, QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::listCollections() "
-  /**
-   * {@link #listCollections(String, QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::listIndexes(query_options*) "
-  /**
-   * List data indexes
-   *
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::listIndexes() "
-  /**
-   * {@link #listIndexes(QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::disconnect() "
-  /**
-   * Disconnect from Kuzzle and invalidate this instance.
-   * Does not fire a disconnected event.
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::logout() "
-  /**
-   * Logout method
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::removeListener(enum Event) "
-  /**
-   * Removes a listener from an event.
-   *
-   * @param event - Event name
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::query(kuzzle_request*, query_options*) "
-  /**
-   * This is a low-level method, exposed to allow advanced SDK users to bypass high-level methods.
-   * Base method used to send queries to Kuzzle
-   *
-   * @param query - Query content
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * @return a KuzzleResponse
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::query(kuzzle_request*) "
-  /**
-   * {@link #query(KuzzleRequest, QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::refreshIndex(const std::string& index, query_options* options) "
-  /**
-   * Forces the default data index to refresh on each modification
-   *
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::refreshIndex(const std::string& index) "
-  /**
-   * {@link #refreshIndex(String, QueryOptions)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::removeListener(enum Event) "
-  /**
-   * Removes a listener from an event.
-   *
-   * @param event - Event name
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::playQueue() "
-  /**
-   * Replays the requests queued during offline mode.
-   * Works only if the SDK is not in a disconnected state, and if the autoReplay option is set to false.
-   *
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::setAutoReplay(bool autoReplay) "
-  /**
-   * autoReplay option setter
-   *
-   * @param autoReplay - New autoReplay option value
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::setJwt(const std::string& jwt) "
-  /**
-   * Set a new JWT and trigger the 'loginAttempt' event.
-   *
-   * @param jwt - New authentication JSON Web Token
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::startQueuing() "
-  /**
-   * Starts the requests queuing. Works only during offline mode, and if the autoQueue option is set to false.
-   *
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::stopQueuing() "
-  /**
-   * Stops the requests queuing. Works only during offline mode, and if the autoQueue option is set to false.
-   *
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::unsetJwt() "
-  /**
-   * Unset the authentication token and cancel all subscriptions
-   *
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::updateSelf(user_data* content, query_options* options) "
-  /**
-   * Update the currently authenticated user informations
-   *
-   * @param content - Current user infos to update
-   * @param options - Request options
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   * @return updated user
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::updateSelf(user_data* content) "
-  /**
-   * {@link #updateSelf(UserData, Options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::whoAmI() "
-  /**
-   * Retrieves current user information
-   *
-   * @param listener - Response callback listener
-   * @throws io.kuzzle.sdk.BadRequestException, io.kuzzle.sdk.ForbiddenException, io.kuzzle.sdk.GatewayTimeoutException, io.kuzzle.sdk.InternalException, io.kuzzle.sdk.NotFoundException, io.kuzzle.sdk.PartialException, io.kuzzle.sdk.PreconditionException, io.kuzzle.sdk.ServiceUnavailableException, io.kuzzle.sdk.UnauthorizedException
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::flushQueue() "
-   /**
-   * Empties the offline queue without replaying it.
-   *
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::getVolatile() "
-   /**
-   * Global volatile data getter
-   *
-   * @return Global volatile data
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::setVolatile(json_object* volatiles) "
-  /**
-   * Global volatile data setter
-   *
-   * @param volatiles - New global volatile data content
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::addListener(Event event, EventListener* listener) "
-   /**
-   * Adds a listener to a Kuzzle global event. When an event is triggered,
-   * listeners are called in the order of their insertion.
-   *
-   * @param event - Name of the global event to subscribe to
-   * @param listener - Response callback listener
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::removeListener(Event event, EventListener* listener) "
-  /**
-   * Removes a listener from an event.
-   *
-   * @param event - Event name
-   * @param listener - Response callback listener
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::removeAllListeners(Event event) "
-  /**
-   * Removes all listeners, either from all events
-   *
-   * @param event - Event name
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Kuzzle::once(Event event, EventListener* listener) "
-  /**
-   * Adds a one time listener to an event.
-   * The next time the event is triggered, the listener is removed and then invoked.
-   *
-   * @param event - Event name
-   * @param listener - Response callback listener
-   * @return this
-   */
-  public";
-
-  %javamethodmodifiers kuzzleio::Kuzzle::listenerCount(Event event) "
-  /**
-   * Returns the number of callbacks who listen to an event.
-   *
-   * @param event - Event name
-   * @return this
-   */
-  public";
diff --git a/internal/wrappers/templates/java/javadoc/room.i b/internal/wrappers/templates/java/javadoc/room.i
deleted file mode 100644
index 82da9d64..00000000
--- a/internal/wrappers/templates/java/javadoc/room.i
+++ /dev/null
@@ -1,59 +0,0 @@
-%typemap(javaimports) kuzzleio::Room "
-/* The type Room. */"
-
-%javamethodmodifiers kuzzleio::Room::Room(Collection *collection, json_object* filters, room_options* options) "
-  /**
-   * The Room object is the result of a subscription request, allowing to manipulate the subscription itself.
-   *
-   * @param collection           - An instantiated Collection object
-   * @param filters              - Subscription filters
-   * @param options              - Subscription options
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Room::Room(Collection *collection, json_object* filters) "
-  /**
-   * {@link #Room(Collection collection, JsonObject filters, RoomOptions options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Room::Room(Collection *collection) "
-  /**
-   * {@link #Room(Collection collection, JsonObject filters, RoomOptions options)}
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Room::count() "
-  /**
-   * Returns the number of other subscriptions on that room.
-   *
-   * @returns the number of subscription
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Room::onDone(SubscribeListener* listener) "
-  /**
-   * Calls the provided callback when the subscription finishes.
-   *
-   * @params SubscribeListener
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Room::subscribe(NotificationListener* listener) "
-  /**
-   * Subscribes using the filters provided at the object creation.
-   *
-   * @params NotificationListener
-   * @return this
-   */
-  public";
-
-%javamethodmodifiers kuzzleio::Room::unsubscribe() "
-  /**
-   * Subscribes using the filters provided at the object creation.
-   *
-   * @params Cancels the current subscription.
-   * @return this
-   */
-  public";
\ No newline at end of file
diff --git a/internal/wrappers/templates/java/kcore.i b/internal/wrappers/templates/java/kcore.i
deleted file mode 100644
index 8cc40fe6..00000000
--- a/internal/wrappers/templates/java/kcore.i
+++ /dev/null
@@ -1,30 +0,0 @@
-/* File : kcore.i */
-
-%module(directors="1") kuzzlesdk
-%{
-#include "exceptions.hpp"
-#include "event_emitter.hpp"
-#include "kuzzle.hpp"
-#include "collection.hpp"
-#include "index.hpp"
-#include "server.hpp"
-#include "document.hpp"
-#include "realtime.hpp"
-#include "auth.hpp"
-#include <assert.h>
-%}
-
-%define _Complex
-%enddef
-
-%include "kuzzlesdk.h"
-%include "kuzzle.h"
-%include "exceptions.hpp"
-%include "event_emitter.hpp"
-%include "kuzzle.hpp"
-%include "collection.hpp"
-%include "index.hpp"
-%include "server.hpp"
-%include "document.hpp"
-%include "realtime.hpp"
-%include "auth.hpp"
diff --git a/internal/wrappers/templates/java/std_function.i b/internal/wrappers/templates/java/std_function.i
deleted file mode 100644
index f613d289..00000000
--- a/internal/wrappers/templates/java/std_function.i
+++ /dev/null
@@ -1,97 +0,0 @@
-%{
-  #include <functional>
-%}
-
-#define param(num,type) $typemap(jstype,type) arg ## num
-#define unpack(num,type) arg##num
-#define lvalref(num,type) type&& arg##num
-#define forward(num,type) std::forward<type>(arg##num)
-
-// Iterate over MACRO Variadic
-// https://stackoverflow.com/questions/1872220/is-it-possible-to-iterate-over-arguments-in-variadic-macros/11994395#11994395
-#define FE_0(...)
-#define FE_1(action,a1) action(0,a1)
-#define FE_2(action,a1,a2) action(0,a1), action(1,a2)
-#define FE_3(action,a1,a2,a3) action(0,a1), action(1,a2), action(2,a3)
-#define FE_4(action,a1,a2,a3,a4) action(0,a1), action(1,a2), action(2,a3), action(3,a4)
-#define FE_5(action,a1,a2,a3,a4,a5) action(0,a1), action(1,a2), action(2,a3), action(3,a4), action(4,a5)
-
-#define GET_MACRO(_1,_2,_3,_4,_5,NAME,...) NAME
-%define FOR_EACH(action,...) 
-  GET_MACRO(__VA_ARGS__, FE_5, FE_4, FE_3, FE_2, FE_1, FE_0)(action,__VA_ARGS__)
-%enddef
-
-%define %std_function(Name, Ret, AbstractMethodName, ...)
-
-%feature("director") Name##Impl;
-%typemap(javaclassmodifiers) Name##Impl "abstract class";
-
-%{
-  struct Name##Impl {
-    virtual ~Name##Impl() {}
-    virtual Ret AbstractMethodName(__VA_ARGS__) = 0;
-  };
-%}
-
-%javamethodmodifiers Name##Impl::AbstractMethodName "abstract protected";
-%typemap(javaout) Ret Name##Impl::AbstractMethodName ";"
-
-%typemap(javaclassmodifiers) std::function<Ret(__VA_ARGS__)> "public abstract class"
-%javamethodmodifiers std::function<Ret(__VA_ARGS__)>::operator() "public abstract"
-%typemap(javaout) Ret std::function<Ret(__VA_ARGS__)>::operator() ";"
-
-struct Name##Impl {
-  virtual ~Name##Impl();
-protected:
-  virtual Ret AbstractMethodName(__VA_ARGS__) = 0;
-};
-
-%typemap(maybereturn) SWIGTYPE "return ";
-%typemap(maybereturn) void "";
-
-%typemap(javain) std::function<Ret(__VA_ARGS__)>, std::function<Ret(__VA_ARGS__)>* "$javaclassname.getCPtr($javaclassname.makeNative($javainput))"
-%typemap(javacode) std::function<Ret(__VA_ARGS__)> %{
-  public Name() {
-    wrapper = new Name##Impl(){
-      public $typemap(jstype, Ret) AbstractMethodName(FOR_EACH(param, __VA_ARGS__)) {
-        $typemap(maybereturn, Ret)Name.this.AbstractMethodName(FOR_EACH(unpack, __VA_ARGS__));
-      }
-    };
-    proxy = new $javaclassname(wrapper){
-      public $typemap(jstype, Ret) AbstractMethodName(FOR_EACH(param, __VA_ARGS__)) {
-        $typemap(maybereturn, Ret)Name.this.AbstractMethodName(FOR_EACH(unpack, __VA_ARGS__));
-      }
-    };
-  }
-
-  static $javaclassname makeNative($javaclassname in) {
-    if (null == in.wrapper) return in;
-    return in.proxy;
-  }
-
-  private Name##Impl wrapper;
-  private $javaclassname proxy;
-%}
-
-%rename(Name) std::function<Ret(__VA_ARGS__)>;
-%rename(AbstractMethodName) std::function<Ret(__VA_ARGS__)>::operator();
-
-namespace std {
-  struct function<Ret(__VA_ARGS__)> {
-    function<Ret(__VA_ARGS__)>(const std::function<Ret(__VA_ARGS__)>&);
-
-    Ret operator()(__VA_ARGS__) const;
-
-    function<Ret(__VA_ARGS__)>(Ret(*const)(__VA_ARGS__));
-
-    %extend {
-      function<Ret(__VA_ARGS__)>(Name##Impl *in) {
-        return new std::function<Ret(__VA_ARGS__)>([=](FOR_EACH(lvalref,__VA_ARGS__)){
-              return in->AbstractMethodName(FOR_EACH(forward,__VA_ARGS__));
-        });
-      }
-    }
-  };
-}
-
-%enddef
\ No newline at end of file
diff --git a/internal/wrappers/templates/java/typemap.i b/internal/wrappers/templates/java/typemap.i
deleted file mode 100644
index ce568c42..00000000
--- a/internal/wrappers/templates/java/typemap.i
+++ /dev/null
@@ -1,48 +0,0 @@
-%rename (_now) kuzzleio::Server::now(query_options*);
-%rename (_now) kuzzleio::Server::now();
-
-%javamethodmodifiers kuzzleio::Server::now(query_options* options) "private";
-%javamethodmodifiers kuzzleio::Server::now() "private";
-%typemap(javacode) kuzzleio::Server %{
-  /**
-   * {@link #now(QueryOptions)}
-   * @return java.util.Date
-   */
-  public java.util.Date now() {
-    long res = _now();
-
-    return new java.util.Date(res);
-  }
-
-  /**
-   * Returns the current Kuzzle UTC timestamp
-   *
-   * @param options - Request options
-   * @return a DateResult
-   */
-  public java.util.Date now(QueryOptions options) {
-    long res = _now(options);
-
-    return new java.util.Date(res);
-  }
-%}
-
-%typemap(jni) std::string* "jobject"
-%typemap(jtype) std::string* "java.lang.String"
-%typemap(jstype) std::string* "java.lang.String"
-%typemap(javain) std::string* "$javainput"
-%typemap(in) std::string * (std::string strTemp) {
-  jobject oInput = $input;
-  if (oInput != NULL) {
-    jstring sInput = static_cast<jstring>( oInput );
-
-    const char * $1_pstr = (const char *)jenv->GetStringUTFChars(sInput, 0);
-    if (!$1_pstr) return $null;
-    strTemp.assign( $1_pstr );
-    jenv->ReleaseStringUTFChars( sInput, $1_pstr);
-    $1 = &strTemp;
-  } else {
-    $1 = NULL;
-  }
-}
-%apply std::string * { std::string* };
diff --git a/internal/wrappers/templates/python/core.i b/internal/wrappers/templates/python/core.i
deleted file mode 100644
index ac04f8d9..00000000
--- a/internal/wrappers/templates/python/core.i
+++ /dev/null
@@ -1,69 +0,0 @@
-%rename(TokenValidity) token_validity;
-%rename(AckResponse) ack_response;
-%rename(queueTTL) queue_ttl;
-%rename(Options, match="class") options;
-%rename(QueryOptions) query_options;
-%rename(JsonObject) json_object;
-%rename(JsonResult) json_result;
-%rename(LoginResult) login_result;
-%rename(BoolResult) bool_result;
-%rename(Statistics) statistics;
-%rename(AllStatisticsResult) all_statistics_result;
-%rename(StatisticsResult) statistics_result;
-%rename(CollectionsList) collection_entry;
-%rename(CollectionsListResult) collection_entry_result;
-%rename(StringArrayResult) string_array_result;
-%rename(KuzzleResponse) kuzzle_response;
-%rename(KuzzleRequest) kuzzle_request;
-%rename(ShardsResult) shards_result;
-%rename(DateResult) date_result;
-%rename(UserData) user_data;
-%rename(User, match="class") user;
-%rename(RoomOptions) room_options;
-%rename(SearchFilters) search_filters;
-%rename(SearchResult) search_result;
-%rename(NotificationResult) notification_result;
-%rename(NotificationContent) notification_content;
-%rename(SubscribeToSelf) subscribe_to_self;
-
-%ignore *::error;
-%ignore *::status;
-%ignore *::stack;
-
-%feature("director") NotificationListener;
-%feature("director") EventListener;
-%feature("director") SubscribeListener;
-
-%{
-#include "kuzzle.cpp"
-#include "collection.cpp"
-#include "auth.cpp"
-#include "index.cpp"
-#include "server.cpp"
-#include "document.cpp"
-#include "realtime.cpp"
-
-#define SWIG_FILE_WITH_INIT
-%}
-
-%include "stl.i"
-%include "kcore.i"
-
-%extend options {
-    options() {
-        options *o = kuzzle_new_options();
-        return o;
-    }
-
-    ~options() {
-        free($self);
-    }
-}
-
-%include "kuzzle.cpp"
-%include "collection.cpp"
-%include "document.cpp"
-%include "realtime.cpp"
-%include "auth.cpp"
-%include "index.cpp"
-%include "server.cpp"
diff --git a/internal/wrappers/templates/python/kcore.i b/internal/wrappers/templates/python/kcore.i
deleted file mode 100644
index 2b88794b..00000000
--- a/internal/wrappers/templates/python/kcore.i
+++ /dev/null
@@ -1,32 +0,0 @@
-/* File : kcore.i */
-
-%module(directors="1") kuzzlesdk
-%{
-#include "listeners.hpp"
-#include "exceptions.hpp"
-#include "event_emitter.hpp"
-#include "kuzzle.hpp"
-#include "collection.hpp"
-#include "index.hpp"
-#include "server.hpp"
-#include "document.hpp"
-#include "realtime.hpp"
-#include "auth.hpp"
-#include <assert.h>
-%}
-
-%define _Complex
-%enddef
-
-%include "kuzzlesdk.h"
-%include "kuzzle.h"
-%include "listeners.hpp"
-%include "exceptions.hpp"
-%include "event_emitter.hpp"
-%include "kuzzle.hpp"
-%include "collection.hpp"
-%include "index.hpp"
-%include "server.hpp"
-%include "document.hpp"
-%include "realtime.hpp"
-%include "auth.hpp"
diff --git a/internal/wrappers/templates/python/setup.py b/internal/wrappers/templates/python/setup.py
deleted file mode 100644
index 3de4f3a6..00000000
--- a/internal/wrappers/templates/python/setup.py
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/env python
-
-"""
-setup.py file for SWIG example
-"""
-
-import os
-from distutils.core import setup, Extension
-
-cwd = os.path.dirname(os.path.realpath(__file__))
-kuzzle_module = Extension('_kcore',
-                           sources=[ cwd + '/kcore_wrap.cxx' ],
-                           swig_opts=['-c++', '-py3']
-                           )
-
-setup (name = 'kcore',
-       version = '1.0',
-       author      = "Kuzzle",
-       description = """Kuzzle sdk""",
-       ext_modules = [kuzzle_module],
-       py_modules = ["kcore"],
-       )
diff --git a/internal/wrappers/templates/python/test.py b/internal/wrappers/templates/python/test.py
deleted file mode 100644
index 5d817a26..00000000
--- a/internal/wrappers/templates/python/test.py
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/usr/bin/env python
-
-import kcore
-from kcore import Kuzzle
-
-kuzzle = Kuzzle("localhost")
-
-print(kuzzle)
-print(kuzzle.server.now())
\ No newline at end of file
diff --git a/kuzzle/disconnect.go b/kuzzle/disconnect.go
index 3f1b25a7..308e6269 100644
--- a/kuzzle/disconnect.go
+++ b/kuzzle/disconnect.go
@@ -14,17 +14,22 @@
 
 package kuzzle
 
-import "github.com/kuzzleio/sdk-go/types"
+import (
+	"github.com/kuzzleio/sdk-go/event"
+	"github.com/kuzzleio/sdk-go/types"
+)
 
 // Disconnect from Kuzzle and invalidate this instance.
 // Does not fire a disconnected event.
 func (k *Kuzzle) Disconnect() error {
-	err := k.socket.Close()
+	err := k.protocol.Close()
+	k.stopRetryingToConnect = true
 
 	if err != nil {
 		return types.NewError(err.Error())
 	}
 	k.wasConnected = false
+	k.EmitEvent(event.Disconnected, nil)
 
 	return nil
 }
diff --git a/kuzzle/disconnect_test.go b/kuzzle/disconnect_test.go
index 34006a16..79b79d1e 100644
--- a/kuzzle/disconnect_test.go
+++ b/kuzzle/disconnect_test.go
@@ -12,17 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package kuzzle_test
+package kuzzle
 
 import (
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
-	"github.com/kuzzleio/sdk-go/kuzzle"
+
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 )
 
 func ExampleKuzzle_Disconnect() {
 	conn := websocket.NewWebSocket("localhost:7512", nil)
-	k, _ := kuzzle.NewKuzzle(conn, nil)
+	k, _ := NewKuzzle(conn, nil)
 
 	err := k.Disconnect()
 	if err != nil {
diff --git a/kuzzle/kuzzle.go b/kuzzle/kuzzle.go
index 875d8b73..9a4155ae 100644
--- a/kuzzle/kuzzle.go
+++ b/kuzzle/kuzzle.go
@@ -21,21 +21,30 @@ import (
 
 	"github.com/kuzzleio/sdk-go/auth"
 	"github.com/kuzzleio/sdk-go/collection"
-	"github.com/kuzzleio/sdk-go/connection"
 	"github.com/kuzzleio/sdk-go/document"
 	"github.com/kuzzleio/sdk-go/event"
 	"github.com/kuzzleio/sdk-go/index"
 	"github.com/kuzzleio/sdk-go/ms"
+	"github.com/kuzzleio/sdk-go/protocol"
 	"github.com/kuzzleio/sdk-go/realtime"
 	"github.com/kuzzleio/sdk-go/security"
 	"github.com/kuzzleio/sdk-go/server"
 	"github.com/kuzzleio/sdk-go/types"
 )
 
-const version = "1.0.0"
+const (
+	version           = "2.0.0"
+	MAX_CONNECT_RETRY = 10
+)
+
+type OfflineQueueLoader interface {
+	Load() []*types.QueryObject
+}
+
+type QueueFilter func([]byte) bool
 
 type Kuzzle struct {
-	socket connection.Connection
+	protocol protocol.Protocol
 
 	wasConnected   bool
 	lastUrl        string
@@ -46,6 +55,25 @@ type Kuzzle struct {
 	RequestHistory map[string]time.Time
 	volatile       types.VolatileData
 
+	eventListeners     map[int]map[chan<- json.RawMessage]bool
+	eventListenersOnce map[int]map[chan<- json.RawMessage]bool
+
+	autoReconnect         bool
+	autoQueue             bool
+	autoReplay            bool
+	autoResubscribe       bool
+	offlineQueue          []*types.QueryObject
+	offlineQueueLoader    OfflineQueueLoader
+	queueFilter           QueueFilter
+	queueMaxSize          int
+	queueTTL              time.Duration
+	reconnectionDelay     time.Duration
+	replayInterval        time.Duration
+	retryingToConnect     bool
+	stopRetryingToConnect bool
+	queuing               bool
+	nbConnectionRetried   int
+
 	MemoryStorage *ms.Ms
 	Security      *security.Security
 	Realtime      *realtime.Realtime
@@ -57,7 +85,7 @@ type Kuzzle struct {
 }
 
 // NewKuzzle is the Kuzzle constructor
-func NewKuzzle(c connection.Connection, options types.Options) (*Kuzzle, error) {
+func NewKuzzle(c protocol.Protocol, options types.Options) (*Kuzzle, error) {
 	if c == nil {
 		return nil, types.NewError("Connection is nil")
 	}
@@ -67,18 +95,35 @@ func NewKuzzle(c connection.Connection, options types.Options) (*Kuzzle, error)
 	}
 
 	k := &Kuzzle{
-		socket:  c,
-		version: version,
+		protocol:           c,
+		version:            version,
+		eventListeners:     make(map[int]map[chan<- json.RawMessage]bool),
+		eventListenersOnce: make(map[int]map[chan<- json.RawMessage]bool),
+		autoQueue:          options.AutoQueue(),
+		autoReplay:         options.AutoReplay(),
+		autoReconnect:      options.AutoReconnect(),
+		autoResubscribe:    options.AutoResubscribe(),
+		offlineQueue:       []*types.QueryObject{},
+		queueMaxSize:       options.QueueMaxSize(),
+		queueTTL:           options.QueueTTL(),
+		reconnectionDelay:  options.ReconnectionDelay(),
+		replayInterval:     options.ReplayInterval(),
+		queuing:            false,
 	}
 
-	k.RequestHistory = k.socket.RequestHistory()
+	if options.OfflineMode() == types.Auto {
+		k.autoQueue = true
+		k.autoReplay = true
+		k.autoReconnect = true
+		k.autoResubscribe = true
+	}
+
+	k.RequestHistory = k.protocol.RequestHistory()
 	k.MemoryStorage = &ms.Ms{k}
 	k.Security = security.NewSecurity(k)
 	k.Auth = auth.NewAuth(k)
 	k.Realtime = realtime.NewRealtime(k)
 
-	k.RequestHistory = k.socket.RequestHistory()
-
 	k.Server = server.NewServer(k)
 	k.Collection = collection.NewCollection(k)
 	k.Document = document.NewDocument(k)
@@ -87,36 +132,74 @@ func NewKuzzle(c connection.Connection, options types.Options) (*Kuzzle, error)
 	return k, nil
 }
 
-// Connect connects to a Kuzzle instance using the provided host and port.
+// Connect connects to a Kuzzle instance.
 func (k *Kuzzle) Connect() error {
-	wasConnected, err := k.socket.Connect()
-	if err == nil {
-		if k.lastUrl != k.socket.Host() {
-			k.wasConnected = false
-			k.lastUrl = k.socket.Host()
+	if k.autoQueue {
+		k.queuing = true
+	}
+
+	wasConnected, err := k.protocol.Connect()
+
+	if err != nil {
+		if k.autoReconnect && !k.retryingToConnect && !k.stopRetryingToConnect && k.nbConnectionRetried < MAX_CONNECT_RETRY {
+			k.retryingToConnect = true
+			time.Sleep(k.reconnectionDelay * time.Millisecond)
+			k.retryingToConnect = false
+			k.nbConnectionRetried++
+			return k.Connect()
 		}
 
-		if wasConnected {
-			if k.jwt != "" {
-				go func() {
-					res, err := k.Auth.CheckToken(k.jwt)
-
-					if err != nil {
-						k.jwt = ""
-						k.socket.EmitEvent(event.TokenExpired, nil)
-						return
-					}
-
-					if !res.Valid {
-						k.jwt = ""
-						k.socket.EmitEvent(event.TokenExpired, nil)
-					}
-				}()
-			}
+		return types.NewError(err.Error())
+	}
+
+	k.nbConnectionRetried = 0
+	k.stopRetryingToConnect = false
+	k.queuing = false
+
+	if k.lastUrl != k.protocol.Host() {
+		k.wasConnected = false
+		k.lastUrl = k.protocol.Host()
+	}
+
+	if wasConnected {
+		if k.jwt != "" {
+			go func() {
+				res, err := k.Auth.CheckToken(k.jwt)
+
+				if err != nil || !res.Valid {
+					k.jwt = ""
+					k.protocol.EmitEvent(event.TokenExpired, nil)
+				}
+				k.EmitEvent(event.Reconnected, nil)
+			}()
+		} else {
+			k.EmitEvent(event.Reconnected, nil)
 		}
-		return nil
+	} else {
+		k.EmitEvent(event.Connected, nil)
 	}
-	return types.NewError(err.Error())
+
+	if k.autoQueue {
+		k.queuing = false
+	}
+	if k.autoReplay {
+		k.PlayQueue()
+	}
+
+	// on network error
+	ee := make(chan json.RawMessage)
+	go func() {
+		for err := range <-ee {
+			if k.autoQueue {
+				k.queuing = true
+			}
+
+			k.EmitEvent(event.NetworkError, err)
+		}
+	}()
+	k.protocol.AddListener(event.NetworkError, ee)
+
+	return nil
 }
 
 // Jwt get internal jwtToken used to request kuzzle.
@@ -128,7 +211,7 @@ func (k *Kuzzle) SetJwt(token string) {
 	k.jwt = token
 
 	if token != "" {
-		k.socket.EmitEvent(event.LoginAttempt, &types.LoginAttempt{Success: true})
+		k.protocol.EmitEvent(event.LoginAttempt, &types.LoginAttempt{Success: true})
 	}
 }
 
@@ -136,125 +219,110 @@ func (k *Kuzzle) SetJwt(token string) {
 func (k *Kuzzle) UnsetJwt() {
 	k.jwt = ""
 
-	k.socket.CancelSubs()
+	k.protocol.CancelSubs()
 }
 
-func (k *Kuzzle) RegisterSub(channel, roomId string, filters json.RawMessage, subscribeToSelf bool, notifChan chan<- types.KuzzleNotification, onReconnectChannel chan<- interface{}) {
-	k.socket.RegisterSub(channel, roomId, filters, subscribeToSelf, notifChan, onReconnectChannel)
+func (k *Kuzzle) RegisterSub(channel, roomId string, filters json.RawMessage, subscribeToSelf bool, notifChan chan<- types.NotificationResult, onReconnectChannel chan<- interface{}) {
+	k.protocol.RegisterSub(channel, roomId, filters, subscribeToSelf, notifChan, onReconnectChannel)
 }
 
 func (k *Kuzzle) UnregisterSub(roomId string) {
-	k.socket.UnregisterSub(roomId)
-}
-
-// State returns the Kuzzle socket state
-func (k *Kuzzle) State() int {
-	return k.socket.State()
+	k.protocol.UnregisterSub(roomId)
 }
 
 // AutoQueue returns the Kuzzle socket AutoQueue field value
 func (k *Kuzzle) AutoQueue() bool {
-	return k.socket.AutoQueue()
+	return k.autoQueue
 }
 
 // AutoReconnect returns the Kuzzle socket AutoReconnect field value
 func (k *Kuzzle) AutoReconnect() bool {
-	return k.socket.AutoReconnect()
+	return k.autoReconnect
 }
 
 // AutoResubscribe returns the Kuzzle socket AutoQueue field value
 func (k *Kuzzle) AutoResubscribe() bool {
-	return k.socket.AutoResubscribe()
+	return k.autoResubscribe
 }
 
 // AutoReplay returns the Kuzzle socket AutoReplay field value
 func (k *Kuzzle) AutoReplay() bool {
-	return k.socket.AutoReplay()
-}
-
-// Host returns the Kuzzle socket Host field value
-func (k *Kuzzle) Host() string {
-	return k.socket.Host()
+	return k.autoReplay
 }
 
 // OfflineQueue returns the Kuzzle socket OfflineQueue field value
 func (k *Kuzzle) OfflineQueue() []*types.QueryObject {
-	return k.socket.OfflineQueue()
+	return k.offlineQueue
 }
 
 // OfflineQueueLoader returns the Kuzzle socket OfflineQueueLoader field value
-func (k *Kuzzle) OfflineQueueLoader() connection.OfflineQueueLoader {
-	return k.socket.OfflineQueueLoader()
-}
-
-// Port returns the Kuzzle socket Port field value
-func (k *Kuzzle) Port() int {
-	return k.socket.Port()
+func (k *Kuzzle) OfflineQueueLoader() OfflineQueueLoader {
+	return k.offlineQueueLoader
 }
 
 // QueueFilter returns the Kuzzle socket QueueFilter field value
-func (k *Kuzzle) QueueFilter() connection.QueueFilter {
-	return k.socket.QueueFilter()
+func (k *Kuzzle) QueueFilter() QueueFilter {
+	return k.queueFilter
 }
 
 // QueueMaxSize returns the Kuzzle socket QueueMaxSize field value
 func (k *Kuzzle) QueueMaxSize() int {
-	return k.socket.QueueMaxSize()
+	return k.queueMaxSize
 }
 
 // QueueTTL returns the Kuzzle socket QueueTTL field value
 func (k *Kuzzle) QueueTTL() time.Duration {
-	return k.socket.QueueTTL()
+	return k.queueTTL
 }
 
 // ReplayInterval returns the Kuzzle socket ReplayInterval field value
 func (k *Kuzzle) ReplayInterval() time.Duration {
-	return k.socket.ReplayInterval()
+	return k.replayInterval
 }
 
 // ReconnectionDelay returns the Kuzzle socket ReconnectionDelay field value
 func (k *Kuzzle) ReconnectionDelay() time.Duration {
-	return k.socket.ReconnectionDelay()
+	return k.reconnectionDelay
 }
 
 // SslConnection returns the Kuzzle socket SslConnection field value
 func (k *Kuzzle) SslConnection() bool {
-	return k.socket.SslConnection()
+	return k.protocol.SslConnection()
 }
 
 // SetAutoQueue sets the Kuzzle socket AutoQueue field with the given value
 func (k *Kuzzle) SetAutoQueue(v bool) {
-	k.socket.SetAutoQueue(v)
+	k.autoQueue = v
 }
 
 // SetAutoReplay sets the Kuzzle socket AutoReplay field with the given value
 func (k *Kuzzle) SetAutoReplay(v bool) {
-	k.socket.SetAutoReplay(v)
+	k.autoReplay = v
 }
 
 // SetOfflineQueueLoader sets the Kuzzle socket OfflineQueueLoader field with given value
-func (k *Kuzzle) SetOfflineQueueLoader(v connection.OfflineQueueLoader) {
-	k.socket.SetOfflineQueueLoader(v)
+func (k *Kuzzle) SetOfflineQueueLoader(v OfflineQueueLoader) {
+	k.offlineQueueLoader = v
 }
 
 // SetQueueFilter sets the Kuzzle socket QueueFilter field with given value
-func (k *Kuzzle) SetQueueFilter(v connection.QueueFilter) {
-	k.socket.SetQueueFilter(v)
+func (k *Kuzzle) SetQueueFilter(v QueueFilter) {
+	k.queueFilter = v
 }
 
 // SetQueueMaxSize sets the Kuzzle socket QueueMaxSize field with the given value
 func (k *Kuzzle) SetQueueMaxSize(v int) {
-	k.socket.SetQueueMaxSize(v)
+	k.queueMaxSize = v
 }
 
 // SetQueueTTL sets the Kuzzle socket QueueTTL field with the given value
 func (k *Kuzzle) SetQueueTTL(v time.Duration) {
-	k.socket.SetQueueTTL(v)
+	k.queueTTL = v
 }
 
 // SetReplayInterval sets the Kuzzle socket ReplayInterval field with the given value
 func (k *Kuzzle) SetReplayInterval(v time.Duration) {
-	k.socket.SetReplayInterval(v)
+	k.replayInterval = v
 }
 
 func (k *Kuzzle) Volatile() types.VolatileData {
@@ -266,5 +334,13 @@ func (k *Kuzzle) SetVolatile(v types.VolatileData) {
 }
 
 func (k *Kuzzle) EmitEvent(e int, arg interface{}) {
-	k.socket.EmitEvent(e, arg)
+	json, _ := json.Marshal(arg)
+	for c := range k.eventListeners[e] {
+		c <- json
+	}
+	for c := range k.eventListenersOnce[e] {
+		c <- json
+		close(c)
+		delete(k.eventListenersOnce[e], c)
+	}
 }
diff --git a/kuzzle/kuzzle_test.go b/kuzzle/kuzzle_test.go
index cc5c3da0..550b6c50 100644
--- a/kuzzle/kuzzle_test.go
+++ b/kuzzle/kuzzle_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/kuzzle/listener.go b/kuzzle/listener.go
index a9369bd0..0aa73318 100644
--- a/kuzzle/listener.go
+++ b/kuzzle/listener.go
@@ -14,30 +14,51 @@
 
 package kuzzle
 
+import (
+	"encoding/json"
+)
+
 // AddListener Adds a listener to a Kuzzle global event. When an event is fired, listeners are called in the order of their insertion.
-func (k *Kuzzle) AddListener(event int, channel chan<- interface{}) {
-	k.socket.AddListener(event, channel)
+func (k *Kuzzle) AddListener(event int, channel chan<- json.RawMessage) {
+	if k.eventListeners[event] == nil {
+		k.eventListeners[event] = make(map[chan<- json.RawMessage]bool)
+	}
+	k.eventListeners[event][channel] = true
 }
 
 // On is an alias to the AddListener function
-func (k *Kuzzle) On(event int, channel chan<- interface{}) {
-	k.socket.AddListener(event, channel)
+func (k *Kuzzle) On(event int, channel chan<- json.RawMessage) {
+	k.AddListener(event, channel)
 }
 
 // RemoveAllListeners removes all listener by event type or all listener if event == -1
 func (k *Kuzzle) RemoveAllListeners(event int) {
-	k.socket.RemoveAllListeners(event)
+	for key := range k.eventListeners {
+		if event == key || event == -1 {
+			delete(k.eventListeners, key)
+		}
+	}
+
+	for key := range k.eventListenersOnce {
+		if event == key || event == -1 {
+			delete(k.eventListenersOnce, key)
+		}
+	}
 }
 
 // RemoveListener removes a listener
-func (k *Kuzzle) RemoveListener(event int, channel chan<- interface{}) {
-	k.socket.RemoveListener(event, channel)
+func (k *Kuzzle) RemoveListener(event int, channel chan<- json.RawMessage) {
+	delete(k.eventListeners[event], channel)
+	delete(k.eventListenersOnce[event], channel)
 }
 
-func (k *Kuzzle) Once(event int, channel chan<- interface{}) {
-	k.socket.Once(event, channel)
+func (k *Kuzzle) Once(event int, channel chan<- json.RawMessage) {
+	if k.eventListenersOnce[event] == nil {
+		k.eventListenersOnce[event] = make(map[chan<- json.RawMessage]bool)
+	}
+	k.eventListenersOnce[event][channel] = true
 }
 
 func (k *Kuzzle) ListenerCount(event int) int {
-	return k.socket.ListenerCount(event)
+	return len(k.eventListenersOnce[event]) + len(k.eventListeners[event])
 }
diff --git a/kuzzle/listener_test.go b/kuzzle/listener_test.go
index fdbfdb01..ef3cce00 100644
--- a/kuzzle/listener_test.go
+++ b/kuzzle/listener_test.go
@@ -12,104 +12,73 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package kuzzle_test
+package kuzzle
 
 import (
+	"encoding/json"
 	"testing"
 
 	"github.com/kuzzleio/sdk-go/internal"
-	"github.com/kuzzleio/sdk-go/kuzzle"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestAddListener(t *testing.T) {
-	called := false
+	c := &internal.MockedConnection{}
+	k, _ := NewKuzzle(c, nil)
 
-	c := &internal.MockedConnection{
-		MockAddListener: func(e int, c chan<- interface{}) {
-			called = true
-		},
-	}
-	k, _ := kuzzle.NewKuzzle(c, nil)
-
-	ch := make(chan interface{})
+	ch := make(chan json.RawMessage)
 
 	k.AddListener(0, ch)
-	assert.Equal(t, true, called)
+	assert.Equal(t, 1, len(k.eventListeners[0]))
 }
 
 func TestRemoveListener(t *testing.T) {
-	called := false
-
-	c := &internal.MockedConnection{
-		MockRemoveListener: func(e int, c chan<- interface{}) {
-			called = true
-		},
-	}
-	k, _ := kuzzle.NewKuzzle(c, nil)
+	c := &internal.MockedConnection{}
+	k, _ := NewKuzzle(c, nil)
 
-	ch := make(chan interface{})
+	ch := make(chan json.RawMessage)
 
+	k.AddListener(0, ch)
+	k.AddListener(1, ch)
 	k.RemoveListener(0, ch)
-	assert.Equal(t, true, called)
+
+	assert.Equal(t, 0, len(k.eventListeners[0]))
 }
 func TestRemoveAllListener(t *testing.T) {
-	called := false
+	c := &internal.MockedConnection{}
+	k, _ := NewKuzzle(c, nil)
+
+	ch := make(chan json.RawMessage)
+	ch2 := make(chan json.RawMessage)
 
-	c := &internal.MockedConnection{
-		MockRemoveAllListeners: func(e int) {
-			called = true
-		},
-	}
-	k, _ := kuzzle.NewKuzzle(c, nil)
+	k.AddListener(0, ch)
+	k.AddListener(42, ch)
+	k.AddListener(42, ch2)
+	k.RemoveAllListeners(42)
 
-	k.RemoveAllListeners(0)
-	assert.Equal(t, true, called)
+	assert.Equal(t, 0, len(k.eventListeners[42]))
+	assert.Equal(t, 1, len(k.eventListeners[0]))
 }
 
 func TestOnce(t *testing.T) {
-	called := false
+	c := &internal.MockedConnection{}
+	k, _ := NewKuzzle(c, nil)
 
-	c := &internal.MockedConnection{
-		MockOnce: func(e int, c chan<- interface{}) {
-			called = true
-		},
-	}
-	k, _ := kuzzle.NewKuzzle(c, nil)
-
-	ch := make(chan interface{})
+	ch := make(chan json.RawMessage)
 
 	k.Once(0, ch)
-	assert.Equal(t, true, called)
+	assert.True(t, k.eventListenersOnce[0][ch])
 }
 
-func TestOn(t *testing.T) {
-	called := false
-
-	c := &internal.MockedConnection{
-		MockAddListener: func(e int, c chan<- interface{}) {
-			called = true
-		},
-	}
-	k, _ := kuzzle.NewKuzzle(c, nil)
+func TestListenerCount(t *testing.T) {
+	c := &internal.MockedConnection{}
+	k, _ := NewKuzzle(c, nil)
 
-	ch := make(chan interface{})
+	ch := make(chan json.RawMessage)
+	ch2 := make(chan json.RawMessage)
 
-	k.On(0, ch)
-	assert.Equal(t, true, called)
-}
+	k.AddListener(0, ch)
+	k.AddListener(0, ch2)
 
-func TestListenerCount(t *testing.T) {
-	called := false
-
-	c := &internal.MockedConnection{
-		MockListenerCount: func(e int) int {
-			called = true
-			return -1
-		},
-	}
-	k, _ := kuzzle.NewKuzzle(c, nil)
-
-	k.ListenerCount(0)
-	assert.Equal(t, true, called)
+	assert.Equal(t, 2, k.ListenerCount(0))
 }
diff --git a/kuzzle/query.go b/kuzzle/query.go
index c9aebace..42a7cfee 100644
--- a/kuzzle/query.go
+++ b/kuzzle/query.go
@@ -17,19 +17,15 @@ package kuzzle
 import (
 	"encoding/json"
 	"fmt"
+	"time"
 
-	"github.com/kuzzleio/sdk-go/state"
+	"github.com/kuzzleio/sdk-go/event"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/satori/go.uuid"
 )
 
 // Query this is a low-level method, exposed to allow advanced SDK users to bypass high-level methods.
 func (k *Kuzzle) Query(query *types.KuzzleRequest, options types.QueryOptions, responseChannel chan<- *types.KuzzleResponse) {
-	if k.State() == state.Disconnected || k.State() == state.Offline || k.State() == state.Ready {
-		responseChannel <- &types.KuzzleResponse{Error: types.NewError("This Kuzzle object has been invalidated. Did you try to access it after a disconnect call?", 400)}
-		return
-	}
-
 	u, _ := uuid.NewV4()
 	requestId := u.String()
 
@@ -111,7 +107,32 @@ func (k *Kuzzle) Query(query *types.KuzzleRequest, options types.QueryOptions, r
 		return
 	}
 
-	err = k.socket.Send(finalRequest, options, responseChannel, requestId)
+	queuable := options == nil || options.Queuable()
+	queuable = queuable && k.queueFilter(finalRequest)
+
+	if k.queuing {
+		if queuable {
+			k.cleanQueue()
+			qo := &types.QueryObject{
+				Timestamp: time.Now(),
+				ResChan:   responseChannel,
+				Query:     finalRequest,
+				RequestId: requestId,
+				Options:   options,
+			}
+			k.offlineQueue = append(k.offlineQueue, qo)
+			k.EmitEvent(event.OfflineQueuePush, qo)
+			return
+		}
+
+		k.EmitEvent(event.Discarded, finalRequest)
+		if responseChannel != nil {
+			responseChannel <- &types.KuzzleResponse{Status: 400, Error: types.NewError("Unable to execute request: not connected to a Kuzzle server.\nDiscarded request: "+string(finalRequest), 400)}
+		}
+		return
+	}
+
+	err = k.protocol.Send(finalRequest, options, responseChannel, requestId)
 
 	if err != nil {
 		if responseChannel != nil {
diff --git a/kuzzle/query_test.go b/kuzzle/query_test.go
index 795daa09..c72e7acc 100644
--- a/kuzzle/query_test.go
+++ b/kuzzle/query_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
@@ -93,7 +93,7 @@ func TestQueryWithOptions(t *testing.T) {
 
 func TestQueryWithVolatile(t *testing.T) {
 	var k *kuzzle.Kuzzle
-	var volatileData = types.VolatileData(`{"modifiedBy":"awesome me","reason":"it needed to be modified","sdkVersion":"1.0.0"}`)
+	var volatileData = types.VolatileData(`{"modifiedBy":"awesome me","reason":"it needed to be modified","sdkVersion":"2.0.0"}`)
 
 	c := &internal.MockedConnection{
 		MockSend: func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
diff --git a/kuzzle/queue.go b/kuzzle/queue.go
index f858cf5d..ca96d1fb 100644
--- a/kuzzle/queue.go
+++ b/kuzzle/queue.go
@@ -14,22 +14,121 @@
 
 package kuzzle
 
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/kuzzleio/sdk-go/event"
+	"github.com/kuzzleio/sdk-go/types"
+)
+
 // FlushQueue empties the offline queue without replaying it.
 func (k *Kuzzle) FlushQueue() {
-	k.socket.ClearQueue()
+	k.offlineQueue = nil
 }
 
-// PlayQueue replays the requests queued during offline mode. Works only if the SDK is not in a disconnected state, and if the autoReplay option is set to false.
+// PlayQueue replays the requests queued during offline mode.
 func (k *Kuzzle) PlayQueue() {
-	k.socket.PlayQueue()
+	if k.protocol.IsReady() {
+		k.cleanQueue()
+		k.dequeue()
+	}
 }
 
 // StartQueuing start the requests queuing.
 func (k *Kuzzle) StartQueuing() {
-	k.socket.StartQueuing()
+	k.queuing = true
 }
 
 // StopQueuing stop the requests queuing.
 func (k *Kuzzle) StopQueuing() {
-	k.socket.StopQueuing()
+	k.queuing = false
+}
+
+// Clean up the queue, ensuring the queryTTL and queryMaxSize properties are respected
+func (k *Kuzzle) cleanQueue() {
+	now := time.Now()
+	now = now.Add(-k.queueTTL * time.Millisecond)
+
+	// Clean queue of timed out query
+	if k.queueTTL > 0 {
+		var query *types.QueryObject
+		for _, query = range k.offlineQueue {
+			if query.Timestamp.Before(now) {
+				k.offlineQueue = k.offlineQueue[1:]
+			} else {
+				break
+			}
+		}
+	}
+
+	if k.queueMaxSize > 0 && len(k.offlineQueue) > k.queueMaxSize {
+		for len(k.offlineQueue) > k.queueMaxSize {
+			eventListener := k.eventListeners[event.OfflineQueuePop]
+			for c := range eventListener {
+				json, _ := json.Marshal(k.offlineQueue[0])
+				c <- json
+			}
+
+			eventListener = k.eventListenersOnce[event.OfflineQueuePop]
+			for c := range eventListener {
+				json, _ := json.Marshal(k.offlineQueue[0])
+				c <- json
+				delete(k.eventListenersOnce[event.OfflineQueuePop], c)
+			}
+
+			k.offlineQueue = k.offlineQueue[1:]
+		}
+	}
+}
+
+func (k *Kuzzle) mergeOfflineQueueWithLoader() error {
+	type query struct {
+		requestId  string `json:"requestId"`
+		controller string `json:"controller"`
+		action     string `json:"action"`
+	}
+
+	additionalOfflineQueue := k.offlineQueueLoader.Load()
+
+	for _, additionalQuery := range additionalOfflineQueue {
+		for _, offlineQuery := range k.offlineQueue {
+			q := query{}
+			json.Unmarshal(additionalQuery.Query, &q)
+			if q.requestId != "" || q.action != "" || q.controller != "" {
+				offlineQ := query{}
+				json.Unmarshal(offlineQuery.Query, &offlineQ)
+				if q.requestId != offlineQ.requestId {
+					k.offlineQueue = append(k.offlineQueue, additionalQuery)
+				} else {
+					additionalOfflineQueue = additionalOfflineQueue[:1]
+				}
+			} else {
+				return types.NewError("Invalid offline queue request. One or more missing properties: requestId, action, controller.")
+			}
+		}
+	}
+	return nil
+}
+
+func (k *Kuzzle) dequeue() error {
+	if k.offlineQueueLoader != nil {
+		err := k.mergeOfflineQueueWithLoader()
+		if err != nil {
+			return err
+		}
+	}
+	// Example from sdk where we have a good use of _
+	if len(k.offlineQueue) > 0 {
+		for _, query := range k.offlineQueue {
+			k.protocol.Send(query.Query, query.Options, query.ResChan, query.RequestId)
+			k.offlineQueue = k.offlineQueue[:1]
+			k.EmitEvent(event.OfflineQueuePop, query)
+			time.Sleep(k.replayInterval * time.Millisecond)
+			k.offlineQueue = k.offlineQueue[:1]
+		}
+	} else {
+		k.queuing = false
+	}
+	return nil
 }
diff --git a/kuzzle/queue_test.go b/kuzzle/queue_test.go
index 315a62ff..21761197 100644
--- a/kuzzle/queue_test.go
+++ b/kuzzle/queue_test.go
@@ -12,22 +12,22 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package kuzzle_test
+package kuzzle
 
 import (
-	"github.com/kuzzleio/sdk-go/connection/websocket"
+	"testing"
+
 	"github.com/kuzzleio/sdk-go/internal"
-	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
-	"testing"
 )
 
 func TestFlushQueue(t *testing.T) {
 	c := &internal.MockedConnection{}
-	k, _ := kuzzle.NewKuzzle(c, nil)
+	k, _ := NewKuzzle(c, nil)
 
-	c.AddToOfflineQueue(&types.QueryObject{RequestId: "test"})
+	k.offlineQueue = append(k.offlineQueue, &types.QueryObject{RequestId: "test"})
 	assert.NotEmpty(t, k.OfflineQueue())
 
 	k.FlushQueue()
@@ -36,7 +36,7 @@ func TestFlushQueue(t *testing.T) {
 
 func ExampleKuzzle_FlushQueue() {
 	conn := websocket.NewWebSocket("localhost:7512", nil)
-	k, _ := kuzzle.NewKuzzle(conn, nil)
+	k, _ := NewKuzzle(conn, nil)
 
 	k.FlushQueue()
 }
diff --git a/ms/append_test.go b/ms/append_test.go
index 8f3abc15..6d947e8c 100755
--- a/ms/append_test.go
+++ b/ms/append_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/bitcount_test.go b/ms/bitcount_test.go
index 62ec844e..94537861 100755
--- a/ms/bitcount_test.go
+++ b/ms/bitcount_test.go
@@ -17,12 +17,13 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
+	"testing"
+
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
-	"testing"
 )
 
 func TestBitcountError(t *testing.T) {
diff --git a/ms/bitop_test.go b/ms/bitop_test.go
index 00bf4658..5c14fb5f 100755
--- a/ms/bitop_test.go
+++ b/ms/bitop_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/bitpos_test.go b/ms/bitpos_test.go
index 740872c8..b33c4f09 100755
--- a/ms/bitpos_test.go
+++ b/ms/bitpos_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/dbsize_test.go b/ms/dbsize_test.go
index 22de6d36..b5e2e7bc 100755
--- a/ms/dbsize_test.go
+++ b/ms/dbsize_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/decr_test.go b/ms/decr_test.go
index ebbc0643..6cd84117 100755
--- a/ms/decr_test.go
+++ b/ms/decr_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/decrby_test.go b/ms/decrby_test.go
index d1ca6005..6b7a8641 100755
--- a/ms/decrby_test.go
+++ b/ms/decrby_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/del_test.go b/ms/del_test.go
index 894b1297..e1683ecf 100755
--- a/ms/del_test.go
+++ b/ms/del_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/exists_test.go b/ms/exists_test.go
index ab3bf06f..fb8ac412 100755
--- a/ms/exists_test.go
+++ b/ms/exists_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/expire_test.go b/ms/expire_test.go
index 3651ca17..93cf8c67 100755
--- a/ms/expire_test.go
+++ b/ms/expire_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/expireat_test.go b/ms/expireat_test.go
index 742a0d82..84343c44 100755
--- a/ms/expireat_test.go
+++ b/ms/expireat_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/flushdb_test.go b/ms/flushdb_test.go
index 797f6237..d1236ea2 100755
--- a/ms/flushdb_test.go
+++ b/ms/flushdb_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/ms/geoadd_test.go b/ms/geoadd_test.go
index 6223b0e7..11a16113 100755
--- a/ms/geoadd_test.go
+++ b/ms/geoadd_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/geodist_test.go b/ms/geodist_test.go
index 4bbb7723..80af2fbc 100755
--- a/ms/geodist_test.go
+++ b/ms/geodist_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/geohash_test.go b/ms/geohash_test.go
index 883cf7ef..047d239f 100755
--- a/ms/geohash_test.go
+++ b/ms/geohash_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/geopos_test.go b/ms/geopos_test.go
index 43f6696e..ac12a945 100755
--- a/ms/geopos_test.go
+++ b/ms/geopos_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/georadius_test.go b/ms/georadius_test.go
index c7ede63a..cc7aece0 100755
--- a/ms/georadius_test.go
+++ b/ms/georadius_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/georadiusbymember_test.go b/ms/georadiusbymember_test.go
index ba95c6dc..c77ef2b2 100755
--- a/ms/georadiusbymember_test.go
+++ b/ms/georadiusbymember_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/get_test.go b/ms/get_test.go
index f9c51712..90ed8411 100755
--- a/ms/get_test.go
+++ b/ms/get_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/getbit_test.go b/ms/getbit_test.go
index e73f2e0b..fcbcdaa5 100755
--- a/ms/getbit_test.go
+++ b/ms/getbit_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/getrange_test.go b/ms/getrange_test.go
index 38f87d4e..ec57663e 100755
--- a/ms/getrange_test.go
+++ b/ms/getrange_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/getset_test.go b/ms/getset_test.go
index 6c2818b2..c8abca14 100755
--- a/ms/getset_test.go
+++ b/ms/getset_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/hdel_test.go b/ms/hdel_test.go
index af61b6fe..e584f2c1 100755
--- a/ms/hdel_test.go
+++ b/ms/hdel_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/hexists_test.go b/ms/hexists_test.go
index f1ade893..7ddfba4a 100755
--- a/ms/hexists_test.go
+++ b/ms/hexists_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/hget_test.go b/ms/hget_test.go
index 39429b94..bc859f84 100755
--- a/ms/hget_test.go
+++ b/ms/hget_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/hgetall_test.go b/ms/hgetall_test.go
index 1fcc8dba..7c186e05 100755
--- a/ms/hgetall_test.go
+++ b/ms/hgetall_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/hincrby_test.go b/ms/hincrby_test.go
index c410953e..9fd3a983 100755
--- a/ms/hincrby_test.go
+++ b/ms/hincrby_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/hincrbyfloat_test.go b/ms/hincrbyfloat_test.go
index 296ff06e..8072b366 100755
--- a/ms/hincrbyfloat_test.go
+++ b/ms/hincrbyfloat_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/hkeys_test.go b/ms/hkeys_test.go
index bc28e4c3..a9453491 100755
--- a/ms/hkeys_test.go
+++ b/ms/hkeys_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/hlen_test.go b/ms/hlen_test.go
index 8130b09b..79e665c0 100755
--- a/ms/hlen_test.go
+++ b/ms/hlen_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/hmget_test.go b/ms/hmget_test.go
index 362173f4..d9bb777f 100755
--- a/ms/hmget_test.go
+++ b/ms/hmget_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/hmset_test.go b/ms/hmset_test.go
index 2aa83c5e..90cfcd62 100755
--- a/ms/hmset_test.go
+++ b/ms/hmset_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/ms/hscan_test.go b/ms/hscan_test.go
index e64d61e4..80651e3d 100755
--- a/ms/hscan_test.go
+++ b/ms/hscan_test.go
@@ -17,10 +17,10 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
 	MemoryStorage "github.com/kuzzleio/sdk-go/ms"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/hset_test.go b/ms/hset_test.go
index 346d3316..594b7861 100755
--- a/ms/hset_test.go
+++ b/ms/hset_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/hsetnx_test.go b/ms/hsetnx_test.go
index 295b112a..cdece667 100755
--- a/ms/hsetnx_test.go
+++ b/ms/hsetnx_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/hstrlen_test.go b/ms/hstrlen_test.go
index a58b318b..0048e22b 100755
--- a/ms/hstrlen_test.go
+++ b/ms/hstrlen_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/hvals_test.go b/ms/hvals_test.go
index 5e38161c..0c4f726a 100755
--- a/ms/hvals_test.go
+++ b/ms/hvals_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/incr_test.go b/ms/incr_test.go
index 96077a71..b60921ea 100755
--- a/ms/incr_test.go
+++ b/ms/incr_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/incrby_test.go b/ms/incrby_test.go
index 0cbb3f8e..e0b1a614 100755
--- a/ms/incrby_test.go
+++ b/ms/incrby_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/incrbyfloat_test.go b/ms/incrbyfloat_test.go
index 49bc3752..965abc69 100755
--- a/ms/incrbyfloat_test.go
+++ b/ms/incrbyfloat_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/keys_test.go b/ms/keys_test.go
index d8876740..7430eab3 100755
--- a/ms/keys_test.go
+++ b/ms/keys_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/lindex_test.go b/ms/lindex_test.go
index b0eab5f5..960f871a 100755
--- a/ms/lindex_test.go
+++ b/ms/lindex_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/linsert_test.go b/ms/linsert_test.go
index 026c52c5..7cf97ad9 100755
--- a/ms/linsert_test.go
+++ b/ms/linsert_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/llen_test.go b/ms/llen_test.go
index d46a89a9..1fb53acb 100755
--- a/ms/llen_test.go
+++ b/ms/llen_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/lpop_test.go b/ms/lpop_test.go
index 90995050..a32d7ef5 100755
--- a/ms/lpop_test.go
+++ b/ms/lpop_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/lpush_test.go b/ms/lpush_test.go
index bfb2dbca..9c487171 100755
--- a/ms/lpush_test.go
+++ b/ms/lpush_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/lpushx_test.go b/ms/lpushx_test.go
index b3020121..53ff98a9 100755
--- a/ms/lpushx_test.go
+++ b/ms/lpushx_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/lrange_test.go b/ms/lrange_test.go
index 4502c296..4ea2d660 100755
--- a/ms/lrange_test.go
+++ b/ms/lrange_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/lrem_test.go b/ms/lrem_test.go
index 00dbb907..7bb40a35 100755
--- a/ms/lrem_test.go
+++ b/ms/lrem_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/lset_test.go b/ms/lset_test.go
index b10a6ce1..fa1bfad1 100755
--- a/ms/lset_test.go
+++ b/ms/lset_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/ms/ltrim_test.go b/ms/ltrim_test.go
index 007faf5f..08ecee51 100755
--- a/ms/ltrim_test.go
+++ b/ms/ltrim_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/ms/mget_test.go b/ms/mget_test.go
index 8e751506..266d3e98 100755
--- a/ms/mget_test.go
+++ b/ms/mget_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/mset_test.go b/ms/mset_test.go
index 4f35fa1d..273f4f8a 100755
--- a/ms/mset_test.go
+++ b/ms/mset_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/ms/msetnx_test.go b/ms/msetnx_test.go
index f2538e9b..fc71b173 100755
--- a/ms/msetnx_test.go
+++ b/ms/msetnx_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/object_test.go b/ms/object_test.go
index e4f0a451..12a470a3 100755
--- a/ms/object_test.go
+++ b/ms/object_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/persist_test.go b/ms/persist_test.go
index fb92fd86..23f89a3c 100755
--- a/ms/persist_test.go
+++ b/ms/persist_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/pexpire.go b/ms/pexpire.go
index 09d0382a..23f89dcd 100755
--- a/ms/pexpire.go
+++ b/ms/pexpire.go
@@ -16,6 +16,7 @@ package ms
 
 import (
 	"encoding/json"
+
 	"github.com/kuzzleio/sdk-go/types"
 )
 
diff --git a/ms/pexpire_test.go b/ms/pexpire_test.go
index 8109a26a..da022b22 100755
--- a/ms/pexpire_test.go
+++ b/ms/pexpire_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/pexpireat_test.go b/ms/pexpireat_test.go
index c4e5542b..5a0fedc4 100755
--- a/ms/pexpireat_test.go
+++ b/ms/pexpireat_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/ms/pfadd_test.go b/ms/pfadd_test.go
index b2bd8e38..22a93a9b 100755
--- a/ms/pfadd_test.go
+++ b/ms/pfadd_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/pfcount_test.go b/ms/pfcount_test.go
index 210a6541..752c4ee8 100755
--- a/ms/pfcount_test.go
+++ b/ms/pfcount_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/pfmerge_test.go b/ms/pfmerge_test.go
index 0a1f7931..53547b2e 100755
--- a/ms/pfmerge_test.go
+++ b/ms/pfmerge_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/ms/ping_test.go b/ms/ping_test.go
index 6e0aebdf..90b5c4c4 100755
--- a/ms/ping_test.go
+++ b/ms/ping_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/psetex_test.go b/ms/psetex_test.go
index cb1f29a7..4cf8eff4 100755
--- a/ms/psetex_test.go
+++ b/ms/psetex_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/ms/pttl_test.go b/ms/pttl_test.go
index 2b0b2e77..02b4e2e3 100755
--- a/ms/pttl_test.go
+++ b/ms/pttl_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/randomkey_test.go b/ms/randomkey_test.go
index 1fd2d832..ebbc3db1 100755
--- a/ms/randomkey_test.go
+++ b/ms/randomkey_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/rename_test.go b/ms/rename_test.go
index 4410ed13..4b178214 100755
--- a/ms/rename_test.go
+++ b/ms/rename_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/ms/renamenx_test.go b/ms/renamenx_test.go
index cfeb32bc..5b1c87f7 100755
--- a/ms/renamenx_test.go
+++ b/ms/renamenx_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/rpop_test.go b/ms/rpop_test.go
index ec52c1ce..0e77be65 100755
--- a/ms/rpop_test.go
+++ b/ms/rpop_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/rpoplpush_test.go b/ms/rpoplpush_test.go
index 55b46609..e7daafff 100755
--- a/ms/rpoplpush_test.go
+++ b/ms/rpoplpush_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/rpush_test.go b/ms/rpush_test.go
index a0aa481e..fe24ac6a 100755
--- a/ms/rpush_test.go
+++ b/ms/rpush_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/rpushx_test.go b/ms/rpushx_test.go
index 6a08ea3f..bf88549f 100755
--- a/ms/rpushx_test.go
+++ b/ms/rpushx_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/sadd_test.go b/ms/sadd_test.go
index cfe029ca..972e4ec6 100755
--- a/ms/sadd_test.go
+++ b/ms/sadd_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/scan_test.go b/ms/scan_test.go
index 69048770..11d54fcd 100755
--- a/ms/scan_test.go
+++ b/ms/scan_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/scard_test.go b/ms/scard_test.go
index dc2e341d..4c4035e2 100755
--- a/ms/scard_test.go
+++ b/ms/scard_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/sdiff_test.go b/ms/sdiff_test.go
index eb030216..aeea5e92 100755
--- a/ms/sdiff_test.go
+++ b/ms/sdiff_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/sdiffstore_test.go b/ms/sdiffstore_test.go
index 1c1afc3c..4f8f320c 100755
--- a/ms/sdiffstore_test.go
+++ b/ms/sdiffstore_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/set_test.go b/ms/set_test.go
index b18328b2..471b11ab 100755
--- a/ms/set_test.go
+++ b/ms/set_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/ms/setex_test.go b/ms/setex_test.go
index 06fb0cce..f14d1200 100755
--- a/ms/setex_test.go
+++ b/ms/setex_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/ms/setnx_test.go b/ms/setnx_test.go
index 38891e99..f62b2e4b 100755
--- a/ms/setnx_test.go
+++ b/ms/setnx_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/sinter_test.go b/ms/sinter_test.go
index d81fc948..946e72ad 100755
--- a/ms/sinter_test.go
+++ b/ms/sinter_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/sinterstore_test.go b/ms/sinterstore_test.go
index 83bc5c50..d06af3a4 100755
--- a/ms/sinterstore_test.go
+++ b/ms/sinterstore_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/sismember_test.go b/ms/sismember_test.go
index 690af850..c8ee86b9 100755
--- a/ms/sismember_test.go
+++ b/ms/sismember_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/smembers_test.go b/ms/smembers_test.go
index 97ea3de2..6c7f9720 100755
--- a/ms/smembers_test.go
+++ b/ms/smembers_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/smove_test.go b/ms/smove_test.go
index f7b5a0a1..b5032535 100755
--- a/ms/smove_test.go
+++ b/ms/smove_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/sort_test.go b/ms/sort_test.go
index 81ec01bc..df03d7ed 100755
--- a/ms/sort_test.go
+++ b/ms/sort_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/spop_test.go b/ms/spop_test.go
index 8e26c8d2..4cc41140 100755
--- a/ms/spop_test.go
+++ b/ms/spop_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/srandmember_test.go b/ms/srandmember_test.go
index eb54c54e..ec947f23 100755
--- a/ms/srandmember_test.go
+++ b/ms/srandmember_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/srem_test.go b/ms/srem_test.go
index ddde65f0..4989a9e8 100755
--- a/ms/srem_test.go
+++ b/ms/srem_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/sscan_test.go b/ms/sscan_test.go
index 0f0c84e2..ed5b203a 100755
--- a/ms/sscan_test.go
+++ b/ms/sscan_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/strlen_test.go b/ms/strlen_test.go
index 25503541..beaa77c1 100755
--- a/ms/strlen_test.go
+++ b/ms/strlen_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/sunion_test.go b/ms/sunion_test.go
index c0fed246..d47ff264 100755
--- a/ms/sunion_test.go
+++ b/ms/sunion_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/sunionstore_test.go b/ms/sunionstore_test.go
index a364d4d7..826a1b88 100755
--- a/ms/sunionstore_test.go
+++ b/ms/sunionstore_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/time_test.go b/ms/time_test.go
index 99c10303..9e199a4b 100755
--- a/ms/time_test.go
+++ b/ms/time_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/touch_test.go b/ms/touch_test.go
index d2025e78..7b343b27 100755
--- a/ms/touch_test.go
+++ b/ms/touch_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/ttl_test.go b/ms/ttl_test.go
index a91154bd..48640d61 100755
--- a/ms/ttl_test.go
+++ b/ms/ttl_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/type_test.go b/ms/type_test.go
index 88456631..5b47db4c 100755
--- a/ms/type_test.go
+++ b/ms/type_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zadd_test.go b/ms/zadd_test.go
index bf29690d..5288ea32 100755
--- a/ms/zadd_test.go
+++ b/ms/zadd_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zcard_test.go b/ms/zcard_test.go
index b0bc29f6..ef544885 100755
--- a/ms/zcard_test.go
+++ b/ms/zcard_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zcount_test.go b/ms/zcount_test.go
index c5164426..3fe9ecf2 100755
--- a/ms/zcount_test.go
+++ b/ms/zcount_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zincrby_test.go b/ms/zincrby_test.go
index 8f1787b9..3e550d49 100755
--- a/ms/zincrby_test.go
+++ b/ms/zincrby_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zinterstore_test.go b/ms/zinterstore_test.go
index 1bd1f6eb..4f1313d7 100755
--- a/ms/zinterstore_test.go
+++ b/ms/zinterstore_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zlexcount_test.go b/ms/zlexcount_test.go
index e38ce658..cda321e7 100755
--- a/ms/zlexcount_test.go
+++ b/ms/zlexcount_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zrange_test.go b/ms/zrange_test.go
index 1b9c4c03..81a53e49 100755
--- a/ms/zrange_test.go
+++ b/ms/zrange_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zrangebylex_test.go b/ms/zrangebylex_test.go
index 88d97a46..7e0d1a29 100755
--- a/ms/zrangebylex_test.go
+++ b/ms/zrangebylex_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zrangebyscore_test.go b/ms/zrangebyscore_test.go
index 048361ac..e20423da 100755
--- a/ms/zrangebyscore_test.go
+++ b/ms/zrangebyscore_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zrank_test.go b/ms/zrank_test.go
index 2099747f..b86694f0 100755
--- a/ms/zrank_test.go
+++ b/ms/zrank_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zrem_test.go b/ms/zrem_test.go
index 5aed2d56..3dbbf2ce 100755
--- a/ms/zrem_test.go
+++ b/ms/zrem_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zremrangebylex_test.go b/ms/zremrangebylex_test.go
index 2688d093..41017ddb 100755
--- a/ms/zremrangebylex_test.go
+++ b/ms/zremrangebylex_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zremrangebyrank_test.go b/ms/zremrangebyrank_test.go
index 8ffd0e9a..99fffc86 100755
--- a/ms/zremrangebyrank_test.go
+++ b/ms/zremrangebyrank_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zremrangebyscore_test.go b/ms/zremrangebyscore_test.go
index 0b099568..7a98d490 100755
--- a/ms/zremrangebyscore_test.go
+++ b/ms/zremrangebyscore_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zrevrange_test.go b/ms/zrevrange_test.go
index b4261965..20171902 100755
--- a/ms/zrevrange_test.go
+++ b/ms/zrevrange_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zrevrangebylex_test.go b/ms/zrevrangebylex_test.go
index bbd15d13..5ee1c801 100755
--- a/ms/zrevrangebylex_test.go
+++ b/ms/zrevrangebylex_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zrevrangebyscore_test.go b/ms/zrevrangebyscore_test.go
index 41603912..557f361b 100755
--- a/ms/zrevrangebyscore_test.go
+++ b/ms/zrevrangebyscore_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zrevrank_test.go b/ms/zrevrank_test.go
index d29809f8..a7b4df53 100755
--- a/ms/zrevrank_test.go
+++ b/ms/zrevrank_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zscan_test.go b/ms/zscan_test.go
index 712041ad..92cb9245 100755
--- a/ms/zscan_test.go
+++ b/ms/zscan_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zscore_test.go b/ms/zscore_test.go
index a84f6def..cbd72171 100755
--- a/ms/zscore_test.go
+++ b/ms/zscore_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/ms/zunionstore_test.go b/ms/zunionstore_test.go
index b5c904f1..6d313b18 100755
--- a/ms/zunionstore_test.go
+++ b/ms/zunionstore_test.go
@@ -17,9 +17,9 @@ package ms_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 	"testing"
diff --git a/connection/connection.go b/protocol/protocol.go
similarity index 52%
rename from connection/connection.go
rename to protocol/protocol.go
index af8181f7..14799e0d 100644
--- a/connection/connection.go
+++ b/protocol/protocol.go
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package connection
+package protocol
 
 import (
 	"encoding/json"
@@ -21,55 +21,26 @@ import (
 	"github.com/kuzzleio/sdk-go/types"
 )
 
-// Connection provides functions to manage many connection type (websocket...)
-type Connection interface {
-	AddListener(event int, channel chan<- interface{})
-	RemoveListener(event int, channel chan<- interface{})
+// Protocol provides functions to manage many connection type (websocket...)
+type Protocol interface {
+	AddListener(event int, channel chan<- json.RawMessage)
+	RemoveListener(event int, channel chan<- json.RawMessage)
 	RemoveAllListeners(event int)
-	Once(event int, channel chan<- interface{})
+	Once(event int, channel chan<- json.RawMessage)
 	ListenerCount(event int) int
 	Connect() (bool, error)
 	Send([]byte, types.QueryOptions, chan<- *types.KuzzleResponse, string) error
 	Close() error
 	State() int
 	EmitEvent(int, interface{})
-	RegisterSub(string, string, json.RawMessage, bool, chan<- types.KuzzleNotification, chan<- interface{})
+	RegisterSub(string, string, json.RawMessage, bool, chan<- types.NotificationResult, chan<- interface{})
 	UnregisterSub(string)
 	CancelSubs()
 	RequestHistory() map[string]time.Time
-	StartQueuing()
-	StopQueuing()
-	PlayQueue()
-	ClearQueue()
+	IsReady() bool
 
 	// property getters
-	AutoQueue() bool
-	AutoReconnect() bool
-	AutoResubscribe() bool
-	AutoReplay() bool
 	Host() string
-	OfflineQueue() []*types.QueryObject
-	OfflineQueueLoader() OfflineQueueLoader
 	Port() int
-	QueueFilter() QueueFilter
-	QueueMaxSize() int
-	QueueTTL() time.Duration
-	ReplayInterval() time.Duration
-	ReconnectionDelay() time.Duration
 	SslConnection() bool
-
-	// property setters
-	SetAutoQueue(bool)
-	SetAutoReplay(bool)
-	SetOfflineQueueLoader(OfflineQueueLoader)
-	SetQueueFilter(QueueFilter)
-	SetQueueMaxSize(int)
-	SetQueueTTL(time.Duration)
-	SetReplayInterval(time.Duration)
-}
-
-type OfflineQueueLoader interface {
-	Load() []*types.QueryObject
 }
-
-type QueueFilter func([]byte) bool
diff --git a/protocol/websocket/web_socket.go b/protocol/websocket/web_socket.go
new file mode 100644
index 00000000..97a158b5
--- /dev/null
+++ b/protocol/websocket/web_socket.go
@@ -0,0 +1,388 @@
+// Copyright 2015-2018 Kuzzle
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package websocket
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/gorilla/websocket"
+	"github.com/kuzzleio/sdk-go/event"
+	"github.com/kuzzleio/sdk-go/state"
+	"github.com/kuzzleio/sdk-go/types"
+	"net/http"
+	"net/url"
+	"sync"
+	"time"
+)
+
+const (
+	MAX_EMIT_TIMEOUT = 10
+)
+
+type subscription struct {
+	roomID              string
+	channel             string
+	filters             json.RawMessage
+	notificationChannel chan<- types.NotificationResult
+	onReconnectChannel  chan<- interface{}
+	subscribeToSelf     bool
+}
+
+type WebSocket struct {
+	ws      *websocket.Conn
+	mu      *sync.Mutex
+	queuing bool
+	state   int
+
+	listenChan         chan []byte
+	channelsResult     sync.Map
+	subscriptions      sync.Map
+	lastUrl            string
+	wasConnected       bool
+	eventListeners     map[int]map[chan<- json.RawMessage]bool
+	eventListenersOnce map[int]map[chan<- json.RawMessage]bool
+
+	requestHistory map[string]time.Time
+
+	host    string
+	port    int
+	ssl     bool
+	headers *http.Header
+}
+
+// NewWebSocket instanciates a new webSocket connection object
+func NewWebSocket(host string, options types.Options) *WebSocket {
+	var opts types.Options
+
+	if options == nil {
+		opts = types.NewOptions()
+	} else {
+		opts = options
+	}
+
+	ws := &WebSocket{
+		mu:                 &sync.Mutex{},
+		channelsResult:     sync.Map{},
+		subscriptions:      sync.Map{},
+		eventListeners:     make(map[int]map[chan<- json.RawMessage]bool),
+		eventListenersOnce: make(map[int]map[chan<- json.RawMessage]bool),
+		requestHistory:     make(map[string]time.Time),
+		state:              state.Ready,
+		host:               host,
+		port:               opts.Port(),
+		ssl:                opts.SslConnection(),
+		headers:            opts.Headers(),
+	}
+	ws.host = host
+
+	ws.state = state.Offline
+
+	return ws
+}
+
+//Connect connects to a kuzzle instance
+func (ws *WebSocket) Connect() (bool, error) {
+	if ws.state != state.Offline {
+		return false, nil
+	}
+
+	ws.state = state.Connecting
+
+	addr := fmt.Sprintf("%s:%d", ws.host, ws.port)
+
+	ws.wasConnected = ws.lastUrl == addr
+	ws.lastUrl = addr
+
+	var scheme string
+
+	if ws.ssl {
+		scheme = "wss"
+	} else {
+		scheme = "ws"
+	}
+
+	u := url.URL{Scheme: scheme, Host: addr}
+
+	var headers http.Header
+
+	if ws.headers != nil {
+		headers = *ws.headers
+	}
+
+	socket, _, err := websocket.DefaultDialer.Dial(u.String(), headers)
+
+	if err != nil {
+		ws.state = state.Offline
+		ws.EmitEvent(event.NetworkError, err)
+
+		return false, err
+	}
+
+	ws.ws = socket
+	ws.state = state.Connected
+	ws.queuing = false
+
+	if ws.wasConnected {
+		ws.EmitEvent(event.Reconnected, nil)
+	} else {
+		ws.EmitEvent(event.Connected, nil)
+	}
+
+	ws.listenChan = make(chan []byte)
+
+	go ws.listen()
+
+	go func() {
+		for {
+			_, message, err := ws.ws.ReadMessage()
+			ws.listenChan <- message
+			// TODO: either send a Disconnected event on a proper disconnection,
+			// or a NetworkError one if the socket has been unexpectedly closed
+			if err != nil {
+				close(ws.listenChan)
+				ws.ws.Close()
+				ws.state = state.Offline
+				ws.EmitEvent(event.Disconnected, nil)
+				return
+			}
+		}
+	}()
+
+	return ws.wasConnected, err
+}
+
+func (ws *WebSocket) Send(query []byte, options types.QueryOptions, responseChannel chan<- *types.KuzzleResponse, requestId string) error {
+	if ws.state == state.Connected {
+		return ws.emitRequest(&types.QueryObject{
+			Query:     query,
+			ResChan:   responseChannel,
+			RequestId: requestId,
+		})
+	}
+
+	ws.discardRequest(responseChannel, query)
+	return nil
+}
+
+func (ws *WebSocket) discardRequest(responseChannel chan<- *types.KuzzleResponse, query []byte) {
+	if responseChannel != nil {
+		responseChannel <- &types.KuzzleResponse{Status: 400, Error: types.NewError("Unable to execute request: not connected to a Kuzzle server.\nDiscarded request: "+string(query), 400)}
+	}
+}
+
+func (ws *WebSocket) RegisterSub(channel, roomID string, filters json.RawMessage, subscribeToSelf bool, notifChan chan<- types.NotificationResult, onReconnectChannel chan<- interface{}) {
+	subs, found := ws.subscriptions.Load(channel)
+
+	if !found {
+		subs = map[string]subscription{}
+	}
+
+	subs.(map[string]subscription)[roomID] = subscription{
+		channel:             channel,
+		roomID:              roomID,
+		notificationChannel: notifChan,
+		onReconnectChannel:  onReconnectChannel,
+		filters:             filters,
+		subscribeToSelf:     subscribeToSelf,
+	}
+
+	ws.subscriptions.Store(channel, subs)
+}
+
+func (ws *WebSocket) UnregisterSub(roomID string) {
+	ws.subscriptions.Range(func(k, v interface{}) bool {
+		for k, sub := range v.(map[string]subscription) {
+			if sub.roomID == roomID {
+				if sub.onReconnectChannel != nil {
+					close(sub.onReconnectChannel)
+				}
+				if sub.notificationChannel != nil {
+					close(sub.notificationChannel)
+				}
+				delete(v.(map[string]subscription), k)
+			}
+		}
+		return true
+	})
+}
+
+func (ws *WebSocket) CancelSubs() {
+	ws.subscriptions.Range(func(roomId, s interface{}) bool {
+		for _, sub := range s.(map[string]subscription) {
+			if sub.onReconnectChannel != nil {
+				close(sub.onReconnectChannel)
+			}
+			ws.subscriptions.Delete(roomId)
+		}
+		return true
+	})
+}
+
+func (ws *WebSocket) listen() {
+	for msg := range ws.listenChan {
+		var message types.KuzzleResponse
+		json.Unmarshal(msg, &message)
+
+		if s, found := ws.subscriptions.Load(message.RoomId); found {
+			var notification types.NotificationResult
+			_, fromSelf := ws.requestHistory[message.RequestId]
+
+			json.Unmarshal(msg, &notification)
+
+			for _, sub := range s.(map[string]subscription) {
+				if sub.notificationChannel != nil && (!fromSelf || sub.subscribeToSelf) {
+					sub.notificationChannel <- notification
+				}
+			}
+
+		} else if c, found := ws.channelsResult.Load(message.RequestId); found {
+			if message.Error.Error() != "" && message.Error.Message == "Token expired" {
+				ws.EmitEvent(event.TokenExpired, nil)
+			}
+
+			// If this is a response to a query we simply broadcast the response to the corresponding channel
+			c.(chan<- *types.KuzzleResponse) <- &message
+			close(c.(chan<- *types.KuzzleResponse))
+			ws.channelsResult.Delete(message.RequestId)
+		} else if c, found := ws.channelsResult.Load(message.RoomId); found {
+			c.(chan<- *types.KuzzleResponse) <- &message
+			close(c.(chan<- *types.KuzzleResponse))
+			ws.channelsResult.Delete(message.RequestId)
+		} else {
+			ws.EmitEvent(event.Discarded, &message)
+		}
+	}
+}
+
+// Adds a listener to a Kuzzle global event. When an event is fired, listeners are called in the order of their insertion.
+func (ws *WebSocket) AddListener(event int, channel chan<- json.RawMessage) {
+	if ws.eventListeners[event] == nil {
+		ws.eventListeners[event] = make(map[chan<- json.RawMessage]bool)
+	}
+	ws.eventListeners[event][channel] = true
+}
+
+// Removes all listeners, either from all events and close channels
+func (ws *WebSocket) RemoveAllListeners(event int) {
+	for k := range ws.eventListeners {
+		if event == k || event == -1 {
+			delete(ws.eventListeners, k)
+		}
+	}
+
+	for k := range ws.eventListenersOnce {
+		if event == k || event == -1 {
+			delete(ws.eventListenersOnce, k)
+		}
+	}
+}
+
+// Removes a listener from an event.
+func (ws *WebSocket) RemoveListener(event int, c chan<- json.RawMessage) {
+	delete(ws.eventListeners[event], c)
+	delete(ws.eventListenersOnce[event], c)
+}
+
+func (ws *WebSocket) Once(event int, channel chan<- json.RawMessage) {
+	if ws.eventListenersOnce[event] == nil {
+		ws.eventListenersOnce[event] = make(map[chan<- json.RawMessage]bool)
+	}
+	ws.eventListenersOnce[event][channel] = true
+}
+
+func (ws *WebSocket) ListenerCount(event int) int {
+	return len(ws.eventListenersOnce[event]) + len(ws.eventListeners[event])
+}
+
+// Emit an event to all registered listeners
+func (ws *WebSocket) EmitEvent(event int, arg interface{}) {
+	for c := range ws.eventListeners[event] {
+		json, _ := json.Marshal(arg)
+		c <- json
+	}
+	for c := range ws.eventListenersOnce[event] {
+		json, _ := json.Marshal(arg)
+		c <- json
+		close(c)
+		delete(ws.eventListenersOnce[event], c)
+	}
+}
+
+func (ws *WebSocket) IsReady() bool {
+	return ws != nil && ws.state == state.Connected
+}
+
+func (ws *WebSocket) emitRequest(query *types.QueryObject) error {
+	now := time.Now()
+	now = now.Add(-MAX_EMIT_TIMEOUT * time.Second)
+
+	ws.channelsResult.Store(query.RequestId, query.ResChan)
+
+	ws.mu.Lock()
+	defer ws.mu.Unlock()
+	err := ws.ws.WriteMessage(websocket.TextMessage, query.Query)
+	if err != nil {
+		return err
+	}
+
+	// Track requests made to allow Room.subscribeToSelf to work
+	ws.requestHistory[query.RequestId] = time.Now()
+	for i, request := range ws.requestHistory {
+		if request.Before(now) {
+			delete(ws.requestHistory, i)
+		}
+	}
+
+	return nil
+}
+
+func (ws *WebSocket) Close() error {
+	if ws.ws == nil {
+		return nil
+	}
+
+	ws.ws.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
+	ws.state = state.Disconnected
+
+	return ws.ws.Close()
+}
+
+func (ws *WebSocket) isValidState() bool {
+	switch ws.state {
+	case state.Initializing, state.Ready, state.Disconnected, state.Error, state.Offline:
+		return true
+	}
+	return false
+}
+
+func (ws *WebSocket) State() int {
+	return ws.state
+}
+
+func (ws *WebSocket) RequestHistory() map[string]time.Time {
+	return ws.requestHistory
+}
+
+func (ws *WebSocket) Host() string {
+	return ws.host
+}
+
+func (ws *WebSocket) Port() int {
+	return ws.port
+}
+
+func (ws *WebSocket) SslConnection() bool {
+	return ws.ssl
+}
diff --git a/connection/websocket/web_socket_test.go b/protocol/websocket/web_socket_test.go
similarity index 76%
rename from connection/websocket/web_socket_test.go
rename to protocol/websocket/web_socket_test.go
index 53bf4b8e..aff4e3ac 100644
--- a/connection/websocket/web_socket_test.go
+++ b/protocol/websocket/web_socket_test.go
@@ -15,6 +15,7 @@
 package websocket
 
 import (
+	"encoding/json"
 	"testing"
 
 	"github.com/kuzzleio/sdk-go/event"
@@ -22,7 +23,7 @@ import (
 )
 
 func TestAddListener(t *testing.T) {
-	c := webSocket{eventListeners: make(map[int]map[chan<- interface{}]bool)}
+	c := WebSocket{eventListeners: make(map[int]map[chan<- json.RawMessage]bool)}
 	c.Connect()
 	c.AddListener(event.LoginAttempt, nil)
 	c.AddListener(event.Disconnected, nil)
@@ -30,8 +31,8 @@ func TestAddListener(t *testing.T) {
 }
 
 func TestOnce(t *testing.T) {
-	c := webSocket{eventListenersOnce: make(map[int]map[chan<- interface{}]bool)}
-	listener := make(chan interface{})
+	c := WebSocket{eventListenersOnce: make(map[int]map[chan<- json.RawMessage]bool)}
+	listener := make(chan json.RawMessage)
 	go func() {
 		<-listener
 	}()
@@ -42,9 +43,9 @@ func TestOnce(t *testing.T) {
 }
 
 func TestRemoveAllListeners(t *testing.T) {
-	c := webSocket{
-		eventListeners:     make(map[int]map[chan<- interface{}]bool),
-		eventListenersOnce: make(map[int]map[chan<- interface{}]bool),
+	c := WebSocket{
+		eventListeners:     make(map[int]map[chan<- json.RawMessage]bool),
+		eventListenersOnce: make(map[int]map[chan<- json.RawMessage]bool),
 	}
 	c.Connect()
 
@@ -66,9 +67,9 @@ func TestRemoveAllListeners(t *testing.T) {
 }
 
 func TestRemoveListener(t *testing.T) {
-	c := webSocket{eventListeners: make(map[int]map[chan<- interface{}]bool)}
+	c := WebSocket{eventListeners: make(map[int]map[chan<- json.RawMessage]bool)}
 
-	listener := make(chan interface{})
+	listener := make(chan json.RawMessage)
 	c.AddListener(event.LoginAttempt, listener)
 	c.AddListener(event.Disconnected, listener)
 	assert.Equal(t, 1, len(c.eventListeners[event.LoginAttempt]))
@@ -83,13 +84,13 @@ func TestRemoveListener(t *testing.T) {
 }
 
 func TestListenerCount(t *testing.T) {
-	c := webSocket{
-		eventListeners:     make(map[int]map[chan<- interface{}]bool),
-		eventListenersOnce: make(map[int]map[chan<- interface{}]bool),
+	c := WebSocket{
+		eventListeners:     make(map[int]map[chan<- json.RawMessage]bool),
+		eventListenersOnce: make(map[int]map[chan<- json.RawMessage]bool),
 	}
 	c.Connect()
 
-	ch := make(chan<- interface{})
+	ch := make(chan<- json.RawMessage)
 	c.AddListener(event.LoginAttempt, nil)
 	c.AddListener(event.LoginAttempt, ch)
 
@@ -102,11 +103,11 @@ func TestListenerCount(t *testing.T) {
 }
 
 func TestEmitEvent(t *testing.T) {
-	c := webSocket{
-		eventListeners:     make(map[int]map[chan<- interface{}]bool),
-		eventListenersOnce: make(map[int]map[chan<- interface{}]bool),
+	c := WebSocket{
+		eventListeners:     make(map[int]map[chan<- json.RawMessage]bool),
+		eventListenersOnce: make(map[int]map[chan<- json.RawMessage]bool),
 	}
-	listener := make(chan interface{})
+	listener := make(chan json.RawMessage)
 	go func() {
 		for {
 			<-listener
diff --git a/realtime/count.go b/realtime/count.go
index 6f830ca6..fca5a1e5 100644
--- a/realtime/count.go
+++ b/realtime/count.go
@@ -21,18 +21,16 @@ import (
 )
 
 // Count returns the number of other subscriptions on that room.
-func (r *Realtime) Count(index, collection, roomID string, options types.QueryOptions) (int, error) {
-	if index == "" || collection == "" || roomID == "" {
-		return -1, types.NewError("Realtime.Count: index, collection and roomID required", 400)
+func (r *Realtime) Count(roomID string, options types.QueryOptions) (int, error) {
+	if roomID == "" {
+		return -1, types.NewError("Realtime.Count: roomID required", 400)
 	}
 
 	query := &types.KuzzleRequest{
 		Controller: "realtime",
 		Action:     "count",
-		Index:      index,
-		Collection: collection,
 		Body: struct {
-			RoomID string `json:"roomID"`
+			RoomID string `json:"roomId"`
 		}{roomID},
 	}
 
diff --git a/realtime/count_test.go b/realtime/count_test.go
index 0b14d5d4..998a9128 100644
--- a/realtime/count_test.go
+++ b/realtime/count_test.go
@@ -26,29 +26,11 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestCountIndexNull(t *testing.T) {
-	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
-	nr := realtime.NewRealtime(k)
-
-	_, err := nr.Count("", "collection", "roomID", nil)
-
-	assert.NotNil(t, err)
-}
-
-func TestCountCollectionNull(t *testing.T) {
-	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
-	nr := realtime.NewRealtime(k)
-
-	_, err := nr.Count("index", "", "roomID", nil)
-
-	assert.NotNil(t, err)
-}
-
 func TestCountRoomIDNull(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
 	nr := realtime.NewRealtime(k)
 
-	_, err := nr.Count("index", "collection", "", nil)
+	_, err := nr.Count("", nil)
 
 	assert.NotNil(t, err)
 }
@@ -62,7 +44,7 @@ func TestCountError(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(c, nil)
 	realTime := realtime.NewRealtime(k)
 
-	_, err := realTime.Count("index", "collection", "42", nil)
+	_, err := realTime.Count("42", nil)
 	assert.NotNil(t, err)
 }
 
@@ -81,6 +63,6 @@ func TestCount(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(c, nil)
 	realTime := realtime.NewRealtime(k)
 
-	res, _ := realTime.Count("index", "collection", "42", nil)
+	res, _ := realTime.Count("42", nil)
 	assert.Equal(t, 10, res)
 }
diff --git a/realtime/list.go b/realtime/list.go
deleted file mode 100644
index 5b20f135..00000000
--- a/realtime/list.go
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package realtime
-
-import (
-	"encoding/json"
-
-	"github.com/kuzzleio/sdk-go/types"
-)
-
-// List lists all subscriptions on all indexes and all collections.
-func (r *Realtime) List(index string, collection string, options types.QueryOptions) (json.RawMessage, error) {
-	if index == "" || collection == "" {
-		return nil, types.NewError("Realtime.List: index and collection required", 400)
-	}
-
-	query := &types.KuzzleRequest{
-		Controller: "realtime",
-		Action:     "list",
-		Index:      index,
-		Collection: collection,
-	}
-
-	result := make(chan *types.KuzzleResponse)
-
-	go r.k.Query(query, options, result)
-
-	res := <-result
-
-	if res.Error.Error() != "" {
-		return nil, res.Error
-	}
-
-	return res.Result, nil
-}
diff --git a/realtime/list_test.go b/realtime/list_test.go
deleted file mode 100644
index 9e8de884..00000000
--- a/realtime/list_test.go
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package realtime_test
-
-import (
-	"encoding/json"
-	"testing"
-
-	"github.com/kuzzleio/sdk-go/internal"
-	"github.com/kuzzleio/sdk-go/kuzzle"
-	"github.com/kuzzleio/sdk-go/realtime"
-	"github.com/kuzzleio/sdk-go/types"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestListIndexNull(t *testing.T) {
-	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
-	nr := realtime.NewRealtime(k)
-
-	_, err := nr.List("", "collection", nil)
-
-	assert.NotNil(t, err)
-}
-
-func TestListCollectionNull(t *testing.T) {
-	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
-	nr := realtime.NewRealtime(k)
-
-	_, err := nr.List("index", "", nil)
-
-	assert.NotNil(t, err)
-}
-
-func TestListError(t *testing.T) {
-	c := &internal.MockedConnection{
-		MockSend: func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
-			return &types.KuzzleResponse{Error: types.NewError("Unit test error")}
-		},
-	}
-	k, _ := kuzzle.NewKuzzle(c, nil)
-	nr := realtime.NewRealtime(k)
-
-	_, err := nr.List("index", "collection", nil)
-	assert.NotNil(t, err)
-	assert.Equal(t, "Unit test error", err.(types.KuzzleError).Message)
-}
-
-func TestList(t *testing.T) {
-	c := &internal.MockedConnection{
-		MockSend: func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
-			parsedQuery := &types.KuzzleRequest{}
-			json.Unmarshal(query, parsedQuery)
-
-			assert.Equal(t, "realtime", parsedQuery.Controller)
-			assert.Equal(t, "list", parsedQuery.Action)
-			assert.Equal(t, "index", parsedQuery.Index)
-			assert.Equal(t, "collection", parsedQuery.Collection)
-
-			res := types.KuzzleResponse{Result: []byte(`
-				{
-          "index": {
-            "collection": {
-              "afcd909773f197ab859447594bfbd154": 12,
-              "4adbc1948ac4dc84ac89d14b488bcad1": 4
-            }
-          }
-			  }`),
-			}
-
-			r, _ := json.Marshal(res.Result)
-			return &types.KuzzleResponse{Result: r}
-		},
-	}
-	k, _ := kuzzle.NewKuzzle(c, nil)
-
-	nr := realtime.NewRealtime(k)
-
-	res, err := nr.List("index", "collection", nil)
-	assert.Nil(t, err)
-	assert.NotNil(t, res)
-}
diff --git a/realtime/subscribe.go b/realtime/subscribe.go
index 0a09b986..697086e9 100644
--- a/realtime/subscribe.go
+++ b/realtime/subscribe.go
@@ -17,12 +17,11 @@ package realtime
 import (
 	"encoding/json"
 
-	"github.com/kuzzleio/sdk-go/event"
 	"github.com/kuzzleio/sdk-go/types"
 )
 
 // Subscribe permits to join a previously created subscription
-func (r *Realtime) Subscribe(index, collection string, filters json.RawMessage, cb chan<- types.KuzzleNotification, options types.RoomOptions) (*types.SubscribeResult, error) {
+func (r *Realtime) Subscribe(index, collection string, filters json.RawMessage, cb chan<- types.NotificationResult, options types.RoomOptions) (*types.SubscribeResult, error) {
 	if (index == "" || collection == "") || (filters == nil || cb == nil) {
 		return nil, types.NewError("Realtime.Subscribe: index, collection, filters and notificationChannel required", 400)
 	}
@@ -76,7 +75,5 @@ func (r *Realtime) Subscribe(index, collection string, filters json.RawMessage,
 		}
 	}()
 
-	r.k.AddListener(event.Reconnected, onReconnect)
-
 	return &resSub, nil
 }
diff --git a/realtime/subscribe_test.go b/realtime/subscribe_test.go
index f304f066..47ec1c35 100644
--- a/realtime/subscribe_test.go
+++ b/realtime/subscribe_test.go
@@ -30,7 +30,7 @@ func TestSubscribeIndexNull(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
 	nr := realtime.NewRealtime(k)
 
-	notifChan := make(chan<- types.KuzzleNotification)
+	notifChan := make(chan<- types.NotificationResult)
 	_, err := nr.Subscribe("", "collection", json.RawMessage(`{"filter": "filter"}`), notifChan, nil)
 
 	assert.NotNil(t, err)
@@ -40,7 +40,7 @@ func TestSubscribeCollectionNull(t *testing.T) {
 	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
 	nr := realtime.NewRealtime(k)
 
-	notifChan := make(chan<- types.KuzzleNotification)
+	notifChan := make(chan<- types.NotificationResult)
 	_, err := nr.Subscribe("index", "", json.RawMessage(`{"filter": "filter"}`), notifChan, nil)
 
 	assert.NotNil(t, err)
@@ -83,7 +83,7 @@ func TestSubscribeQueryError(t *testing.T) {
 	nr := realtime.NewRealtime(k)
 	c.SetState(state.Connected)
 
-	notifChan := make(chan<- types.KuzzleNotification)
+	notifChan := make(chan<- types.NotificationResult)
 	_, err := nr.Subscribe("index", "collection", json.RawMessage(`{"filter": "filter"}`), notifChan, nil)
 	assert.Equal(t, "ah!", err.Error())
 }
@@ -101,7 +101,7 @@ func TestRenewWithSubscribeToSelf(t *testing.T) {
 	nr := realtime.NewRealtime(k)
 	c.SetState(state.Connected)
 
-	notifChan := make(chan<- types.KuzzleNotification)
+	notifChan := make(chan<- types.NotificationResult)
 	res, err := nr.Subscribe("index", "collection", json.RawMessage(`{"filter": "filter"}`), notifChan, nil)
 	assert.Nil(t, err)
 	assert.NotNil(t, res)
@@ -121,7 +121,7 @@ func TestRoomSubscribe(t *testing.T) {
 	nr := realtime.NewRealtime(k)
 	c.SetState(state.Connected)
 
-	notifChan := make(chan<- types.KuzzleNotification)
+	notifChan := make(chan<- types.NotificationResult)
 	res, err := nr.Subscribe("index", "collection", json.RawMessage(`{"filter": "filter"}`), notifChan, nil)
 	assert.Nil(t, err)
 	assert.NotNil(t, res)
@@ -142,7 +142,7 @@ func TestRoomSubscribeNotConnected(t *testing.T) {
 	nr := realtime.NewRealtime(k)
 	c.SetState(state.Connected)
 
-	notifChan := make(chan<- types.KuzzleNotification)
+	notifChan := make(chan<- types.NotificationResult)
 	_, err := nr.Subscribe("collection", "index", json.RawMessage("{}"), notifChan, nil)
 	assert.NotNil(t, err)
 	assert.Equal(t, "Not Connected", err.Error())
@@ -159,6 +159,6 @@ func ExampleRealtime_Subscribe() {
 	nr := realtime.NewRealtime(k)
 	c.SetState(state.Connected)
 
-	notifChan := make(chan<- types.KuzzleNotification)
+	notifChan := make(chan<- types.NotificationResult)
 	nr.Subscribe("collection", "index", json.RawMessage(""), notifChan, nil)
 }
diff --git a/realtime/validate.go b/realtime/validate.go
deleted file mode 100644
index e4e6c05a..00000000
--- a/realtime/validate.go
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package realtime
-
-import (
-	"encoding/json"
-
-	"github.com/kuzzleio/sdk-go/types"
-)
-
-// Validate validates data against existing validation rules
-func (r *Realtime) Validate(index string, collection string, body string, options types.QueryOptions) (bool, error) {
-	if (index == "" || collection == "") || body == "" {
-		return false, types.NewError("Realtime.Validate: index, collection and body required", 400)
-	}
-
-	query := &types.KuzzleRequest{
-		Controller: "realtime",
-		Action:     "validate",
-		Index:      index,
-		Collection: collection,
-		Body:       body,
-	}
-
-	result := make(chan *types.KuzzleResponse)
-
-	go r.k.Query(query, options, result)
-
-	res := <-result
-
-	if res.Error.Error() != "" {
-		return false, res.Error
-	}
-
-	var isValid struct {
-		Value bool `json:"valid"`
-	}
-
-	json.Unmarshal(res.Result, &isValid)
-
-	return isValid.Value, nil
-}
diff --git a/realtime/validate_test.go b/realtime/validate_test.go
deleted file mode 100644
index 0c37c55a..00000000
--- a/realtime/validate_test.go
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright 2015-2018 Kuzzle
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 		http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package realtime_test
-
-import (
-	"encoding/json"
-	"testing"
-
-	"github.com/kuzzleio/sdk-go/internal"
-	"github.com/kuzzleio/sdk-go/kuzzle"
-	"github.com/kuzzleio/sdk-go/realtime"
-	"github.com/kuzzleio/sdk-go/types"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestValidateIndexNull(t *testing.T) {
-	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
-	nr := realtime.NewRealtime(k)
-
-	_, err := nr.Validate("", "collection", "body", nil)
-
-	assert.NotNil(t, err)
-}
-
-func TestValidateCollectionNull(t *testing.T) {
-	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
-	nr := realtime.NewRealtime(k)
-
-	_, err := nr.Validate("index", "", "body", nil)
-
-	assert.NotNil(t, err)
-}
-
-func TestValidateBodyNull(t *testing.T) {
-	k, _ := kuzzle.NewKuzzle(&internal.MockedConnection{}, nil)
-	nr := realtime.NewRealtime(k)
-
-	_, err := nr.Validate("index", "collection", "", nil)
-
-	assert.NotNil(t, err)
-}
-
-func TestValidateError(t *testing.T) {
-	c := &internal.MockedConnection{
-		MockSend: func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
-			return &types.KuzzleResponse{Error: types.NewError("Unit test error")}
-		},
-	}
-	k, _ := kuzzle.NewKuzzle(c, nil)
-	nr := realtime.NewRealtime(k)
-
-	_, err := nr.Validate("index", "collection", "body", nil)
-	assert.NotNil(t, err)
-}
-
-func TestValidate(t *testing.T) {
-	c := &internal.MockedConnection{
-		MockSend: func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
-			parsedQuery := &types.KuzzleRequest{}
-			json.Unmarshal(query, parsedQuery)
-
-			assert.Equal(t, "realtime", parsedQuery.Controller)
-			assert.Equal(t, "validate", parsedQuery.Action)
-			assert.Equal(t, "index", parsedQuery.Index)
-			assert.Equal(t, "collection", parsedQuery.Collection)
-			assert.NotNil(t, parsedQuery.Body)
-
-			res := types.KuzzleResponse{Result: []byte(`{"valid": true}`)}
-
-			r, _ := json.Marshal(res.Result)
-			return &types.KuzzleResponse{Result: r}
-		},
-	}
-	k, _ := kuzzle.NewKuzzle(c, nil)
-
-	nr := realtime.NewRealtime(k)
-
-	res, err := nr.Validate("index", "collection", "body", nil)
-	assert.Nil(t, err)
-	assert.Equal(t, true, res)
-}
diff --git a/security/getAllCredentialFields_test.go b/security/getAllCredentialFields_test.go
index a7e8b52d..c43cae46 100644
--- a/security/getAllCredentialFields_test.go
+++ b/security/getAllCredentialFields_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/security/getCredentialFields_test.go b/security/getCredentialFields_test.go
index 8344cca5..5731a556 100644
--- a/security/getCredentialFields_test.go
+++ b/security/getCredentialFields_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/security/getProfile_test.go b/security/getProfile_test.go
index f4d8e89f..e34bc43d 100644
--- a/security/getProfile_test.go
+++ b/security/getProfile_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/security/getRole_test.go b/security/getRole_test.go
index cb8b901b..1d8789d7 100644
--- a/security/getRole_test.go
+++ b/security/getRole_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/security"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
diff --git a/security/getUser_test.go b/security/getUser_test.go
index 7a0f2218..93e0781b 100644
--- a/security/getUser_test.go
+++ b/security/getUser_test.go
@@ -20,9 +20,9 @@ import (
 
 	"encoding/json"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/security/mGetProfiles_test.go b/security/mGetProfiles_test.go
index 973e8918..2f2e6111 100644
--- a/security/mGetProfiles_test.go
+++ b/security/mGetProfiles_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/security/mGetRoles_test.go b/security/mGetRoles_test.go
index 67748928..e00bf815 100644
--- a/security/mGetRoles_test.go
+++ b/security/mGetRoles_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/security/profile.go b/security/profile.go
index a6fbc99a..9c816ab3 100644
--- a/security/profile.go
+++ b/security/profile.go
@@ -23,12 +23,6 @@ type Profile struct {
 	Policies []*types.Policy
 }
 
-type ProfileSearchResult struct {
-	Hits     []*Profile
-	Total    int    `json:"total"`
-	ScrollId string `json:"scrollId"`
-}
-
 func NewProfile(id string, policies []*types.Policy) *Profile {
 	return &Profile{
 		Id:       id,
diff --git a/security/profileSearchResult.go b/security/profileSearchResult.go
new file mode 100644
index 00000000..9710018b
--- /dev/null
+++ b/security/profileSearchResult.go
@@ -0,0 +1,82 @@
+// Copyright 2015-2018 Kuzzle
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 		http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package security
+
+import (
+	"encoding/json"
+
+	"github.com/kuzzleio/sdk-go/types"
+)
+
+type ProfileSearchResult struct {
+	Aggregations json.RawMessage `json:"aggregations"`
+	Hits         []*Profile
+	Total        int `json:"total"`
+	Fetched      int
+	ScrollId     string `json:"scrollId"`
+	kuzzle       types.IKuzzle
+	request      *types.KuzzleRequest
+	response     *types.KuzzleResponse
+	options      types.QueryOptions
+}
+
+func (sr *ProfileSearchResult) Request() *types.KuzzleRequest {
+	return sr.request
+}
+
+func (sr *ProfileSearchResult) Response() *types.KuzzleResponse {
+	return sr.response
+}
+
+func (sr *ProfileSearchResult) Options() types.QueryOptions {
+	return sr.options
+}
+
+// Next returns the next page of profiles
+func (psr *ProfileSearchResult) Next() (*ProfileSearchResult, error) {
+	sr, err := types.NewSearchResult(psr.kuzzle, "scrollProfiles", psr.request, psr.options, psr.response)
+	if err != nil {
+		return nil, err
+	}
+
+	nsr, err := sr.Next()
+
+	if err != nil {
+		return nil, err
+	}
+
+	npsr := &ProfileSearchResult{
+		Aggregations: nsr.Aggregations,
+		Total:        nsr.Total,
+		Fetched:      nsr.Fetched,
+		ScrollId:     nsr.ScrollId,
+		kuzzle:       psr.kuzzle,
+		request:      psr.request,
+		response:     psr.response,
+		options:      psr.options,
+	}
+	var jprofiles []jsonProfile
+	err = json.Unmarshal(nsr.Hits, &jprofiles)
+
+	if err != nil {
+		return nil, err
+	}
+
+	for _, jprofile := range jprofiles {
+		npsr.Hits = append(npsr.Hits, jprofile.jsonProfileToProfile())
+	}
+
+	return npsr, nil
+}
diff --git a/security/role.go b/security/role.go
index 1c9ac973..07ce4b1e 100644
--- a/security/role.go
+++ b/security/role.go
@@ -23,11 +23,6 @@ type Role struct {
 	Controllers map[string]*types.Controller
 }
 
-type RoleSearchResult struct {
-	Hits  []*Role
-	Total int
-}
-
 func NewRole(id string, controllers *types.Controllers) *Role {
 	r := &Role{
 		Id: id,
diff --git a/security/roleSearchResult.go b/security/roleSearchResult.go
new file mode 100644
index 00000000..bcd9f8e5
--- /dev/null
+++ b/security/roleSearchResult.go
@@ -0,0 +1,82 @@
+// Copyright 2015-2018 Kuzzle
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 		http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package security
+
+import (
+	"encoding/json"
+
+	"github.com/kuzzleio/sdk-go/types"
+)
+
+type RoleSearchResult struct {
+	Aggregations json.RawMessage `json:"aggregations"`
+	Hits         []*Role
+	Total        int `json:"total"`
+	Fetched      int
+	ScrollId     string `json:"scrollId"`
+	kuzzle       types.IKuzzle
+	request      *types.KuzzleRequest
+	response     *types.KuzzleResponse
+	options      types.QueryOptions
+}
+
+func (sr *RoleSearchResult) Request() *types.KuzzleRequest {
+	return sr.request
+}
+
+func (sr *RoleSearchResult) Response() *types.KuzzleResponse {
+	return sr.response
+}
+
+func (sr *RoleSearchResult) Options() types.QueryOptions {
+	return sr.options
+}
+
+// Next returns the next page of roles
+func (rsr *RoleSearchResult) Next() (*RoleSearchResult, error) {
+	sr, err := types.NewSearchResult(rsr.kuzzle, "scrollRoles", rsr.request, rsr.options, rsr.response)
+	if err != nil {
+		return nil, err
+	}
+
+	nsr, err := sr.Next()
+
+	if err != nil {
+		return nil, err
+	}
+
+	nrsr := &RoleSearchResult{
+		Aggregations: nsr.Aggregations,
+		Total:        nsr.Total,
+		Fetched:      nsr.Fetched,
+		ScrollId:     nsr.ScrollId,
+		kuzzle:       rsr.kuzzle,
+		request:      rsr.request,
+		response:     rsr.response,
+		options:      rsr.options,
+	}
+	var jroles []jsonRole
+	err = json.Unmarshal(nsr.Hits, &jroles)
+
+	if err != nil {
+		return nil, err
+	}
+
+	for _, jrole := range jroles {
+		nrsr.Hits = append(nrsr.Hits, jrole.jsonRoleToRole())
+	}
+
+	return nrsr, nil
+}
diff --git a/security/searchProfiles.go b/security/searchProfiles.go
index cfb95b06..2b9b950d 100644
--- a/security/searchProfiles.go
+++ b/security/searchProfiles.go
@@ -50,9 +50,21 @@ func (s *Security) SearchProfiles(body json.RawMessage, options types.QueryOptio
 	jsonSearchResult := &jsonProfileSearchResult{}
 	json.Unmarshal(res.Result, jsonSearchResult)
 
+	sr, err := types.NewSearchResult(s.Kuzzle, "scrollProfiles", query, options, res)
+
+	if err != nil {
+		return nil, err
+	}
+
 	searchResult := &ProfileSearchResult{
-		ScrollId: jsonSearchResult.ScrollId,
-		Total:    jsonSearchResult.Total,
+		Aggregations: sr.Aggregations,
+		Total:        sr.Total,
+		Fetched:      sr.Fetched,
+		ScrollId:     sr.ScrollId,
+		kuzzle:       s.Kuzzle,
+		request:      query,
+		response:     res,
+		options:      options,
 	}
 	for _, j := range jsonSearchResult.Hits {
 		p := j.jsonProfileToProfile()
diff --git a/security/searchProfiles_test.go b/security/searchProfiles_test.go
index a9f2504d..e7c70e0b 100644
--- a/security/searchProfiles_test.go
+++ b/security/searchProfiles_test.go
@@ -19,9 +19,11 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
+	"github.com/kuzzleio/sdk-go/security"
+
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
@@ -93,7 +95,7 @@ func TestSearchProfileWithScroll(t *testing.T) {
 				"hits": [
 					{"_id": "profile42", "_source": {"policies": [{"roleId": "admin"}]}}
 				],
-				"scrollId": "f00b4r"
+				"_scroll_id": "f00b4r"
 			}`)}
 		},
 	}
@@ -110,6 +112,45 @@ func TestSearchProfileWithScroll(t *testing.T) {
 	assert.Equal(t, []*types.Policy{
 		{RoleId: "admin"},
 	}, res.Hits[0].Policies)
-	assert.Equal(t, "f00b4r", res.ScrollId)
 	assert.Equal(t, "profile42", res.Hits[0].Id)
+	assert.Equal(t, "f00b4r", res.ScrollId)
+
+	c.MockSend = func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
+		parsedQuery := &types.KuzzleRequest{}
+		json.Unmarshal(query, parsedQuery)
+
+		assert.Equal(t, "1m", options.Scroll())
+		assert.Equal(t, "f00b4r", options.ScrollId())
+
+		return &types.KuzzleResponse{Result: json.RawMessage(`{
+			"hits": [
+				{
+					"_id": "id3", 
+					"_source": {
+						"policies": [
+							{"roleId": "admin"}
+						]
+					}
+				},
+				{
+					"_id": "id4", 
+					"_source": {
+						"policies": [
+							{"roleId": "demo"}
+						]
+					}
+				}
+			],
+			"_scroll_id": "new_scroll"
+		}`)}
+	}
+
+	nsr, err := res.Next()
+	assert.Nil(t, err)
+	assert.NotNil(t, nsr)
+	assert.Equal(t, 3, nsr.Fetched)
+
+	p := security.NewProfile("id", nil)
+	assert.IsType(t, p, nsr.Hits[0])
+	assert.Equal(t, 2, len(nsr.Hits))
 }
diff --git a/security/searchRoles.go b/security/searchRoles.go
index fa66f4f0..448e351e 100644
--- a/security/searchRoles.go
+++ b/security/searchRoles.go
@@ -20,6 +20,7 @@ import (
 	"github.com/kuzzleio/sdk-go/types"
 )
 
+// SearchRoles returns the roles matching the given query
 func (s *Security) SearchRoles(body json.RawMessage, options types.QueryOptions) (*RoleSearchResult, error) {
 	ch := make(chan *types.KuzzleResponse)
 
@@ -49,8 +50,21 @@ func (s *Security) SearchRoles(body json.RawMessage, options types.QueryOptions)
 	jsonSearchResult := &jsonRoleSearchResult{}
 	json.Unmarshal(res.Result, jsonSearchResult)
 
+	sr, err := types.NewSearchResult(s.Kuzzle, "scrollRoles", query, options, res)
+
+	if err != nil {
+		return nil, err
+	}
+
 	searchResult := &RoleSearchResult{
-		Total: jsonSearchResult.Total,
+		Aggregations: sr.Aggregations,
+		Total:        sr.Total,
+		Fetched:      sr.Fetched,
+		ScrollId:     sr.ScrollId,
+		kuzzle:       s.Kuzzle,
+		request:      query,
+		response:     res,
+		options:      options,
 	}
 	for _, j := range jsonSearchResult.Hits {
 		r := j.jsonRoleToRole()
diff --git a/security/searchRoles_test.go b/security/searchRoles_test.go
index 257411cd..730828cb 100644
--- a/security/searchRoles_test.go
+++ b/security/searchRoles_test.go
@@ -19,9 +19,11 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
+	"github.com/kuzzleio/sdk-go/security"
+
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
@@ -116,3 +118,81 @@ func TestSearchWithOptions(t *testing.T) {
 	assert.Equal(t, 1, len(res.Hits))
 	assert.Equal(t, res.Hits[0].Controllers["*"].Actions["*"], true)
 }
+
+func TestSearchRolesNext(t *testing.T) {
+	c := &internal.MockedConnection{
+		MockSend: func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
+			return &types.KuzzleResponse{Result: json.RawMessage(`{
+				"hits": [
+					{
+						"_id": "admin",
+						"_source": {
+							"controllers": {
+								"*": {
+									"actions": {
+										"*": true
+									}
+								}
+							}
+						}
+					},
+					{
+						"_id": "administrator",
+						"_source": {
+							"controllers": {
+								"*": {
+									"actions": {
+										"*": true
+									}
+								}
+							}
+						}
+					}
+
+				],
+				"total": 42
+			}`)}
+		},
+	}
+	k, _ := kuzzle.NewKuzzle(c, nil)
+
+	options := types.NewQueryOptions()
+	options.SetFrom(0)
+	options.SetSize(2)
+
+	sr, err := k.Security.SearchRoles(json.RawMessage(`{}`), options)
+	assert.Nil(t, err)
+	assert.NotNil(t, sr)
+	assert.Equal(t, 2, len(sr.Hits))
+
+	c.MockSend = func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
+		assert.Equal(t, 2, options.From())
+		assert.Equal(t, 2, options.Size())
+
+		return &types.KuzzleResponse{Result: json.RawMessage(`{
+			"hits": [
+				{
+					"_id": "none",
+					"_source": {
+						"controllers": {
+							"*": {
+								"actions": {
+									"*": false
+								}
+							}
+						}
+					}
+				}
+			],
+			"total": 42
+		}`)}
+	}
+
+	nsr, err := sr.Next()
+	assert.Nil(t, err)
+	assert.NotNil(t, nsr)
+
+	assert.Equal(t, 1, len(nsr.Hits))
+	r := security.NewRole("id", nil)
+	assert.IsType(t, r, nsr.Hits[0])
+}
diff --git a/security/searchUsers.go b/security/searchUsers.go
index 326aa1f2..58c14501 100644
--- a/security/searchUsers.go
+++ b/security/searchUsers.go
@@ -20,6 +20,7 @@ import (
 	"github.com/kuzzleio/sdk-go/types"
 )
 
+// SearchUsers retrieves the users matching the given query
 func (s *Security) SearchUsers(body json.RawMessage, options types.QueryOptions) (*UserSearchResult, error) {
 	ch := make(chan *types.KuzzleResponse)
 
@@ -50,9 +51,21 @@ func (s *Security) SearchUsers(body json.RawMessage, options types.QueryOptions)
 	jsonSearchResult := &jsonUserSearchResult{}
 	json.Unmarshal(res.Result, jsonSearchResult)
 
+	sr, err := types.NewSearchResult(s.Kuzzle, "scrollUsers", query, options, res)
+
+	if err != nil {
+		return nil, err
+	}
+
 	searchResult := &UserSearchResult{
-		Total:    jsonSearchResult.Total,
-		ScrollId: jsonSearchResult.ScrollId,
+		Aggregations: sr.Aggregations,
+		Total:        sr.Total,
+		Fetched:      sr.Fetched,
+		ScrollId:     sr.ScrollId,
+		kuzzle:       s.Kuzzle,
+		request:      query,
+		response:     res,
+		options:      options,
 	}
 
 	for _, j := range jsonSearchResult.Hits {
diff --git a/security/searchUsers_test.go b/security/searchUsers_test.go
index d52118f4..2d010bfb 100644
--- a/security/searchUsers_test.go
+++ b/security/searchUsers_test.go
@@ -19,9 +19,11 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
+	"github.com/kuzzleio/sdk-go/security"
+
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
@@ -64,6 +66,78 @@ func TestSearchUsers(t *testing.T) {
 	assert.Equal(t, map[string]interface{}{"foo": "bar"}, res.Hits[0].Content)
 }
 
+func TestSearchUsersNext(t *testing.T) {
+	c := &internal.MockedConnection{
+		MockSend: func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
+			return &types.KuzzleResponse{Result: json.RawMessage(`{
+				"hits": [
+					{
+						"_id": "id1",
+						"_source": {
+							"profileIds": [ "admin", "other" ],
+							"foo": "bar"
+						}
+					},
+					{
+						"_id": "id2",
+						"_source": {
+							"profileIds": [ "default" ],
+							"foo": "baz"
+						}
+					}
+				],
+				"total": 42,
+				"_scroll_id": "scroll_id"
+			}`)}
+		},
+	}
+	k, _ := kuzzle.NewKuzzle(c, nil)
+
+	options := types.NewQueryOptions()
+	options.SetScroll("1m")
+
+	sr, err := k.Security.SearchUsers(json.RawMessage(`{}`), options)
+	assert.Nil(t, err)
+	assert.NotNil(t, sr)
+
+	c.MockSend = func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
+		parsedQuery := &types.KuzzleRequest{}
+		json.Unmarshal(query, parsedQuery)
+
+		assert.Equal(t, "1m", options.Scroll())
+		assert.Equal(t, "scroll_id", options.ScrollId())
+
+		return &types.KuzzleResponse{Result: json.RawMessage(`{
+			"hits": [
+				{
+					"_id": "id3",
+					"_source": {
+						"profileIds": [ "admin", "other" ],
+						"foo": "bar"
+					}
+				},
+				{
+					"_id": "id4",
+					"_source": {
+						"profileIds": [ "default" ],
+						"foo": "baz"
+					}
+				}
+			],
+			"total": 42,
+			"_scroll_id": "new_scroll"
+		}`)}
+	}
+
+	nsr, err := sr.Next()
+	assert.Nil(t, err)
+	assert.NotNil(t, nsr)
+	assert.Equal(t, 4, nsr.Fetched)
+
+	u := security.NewUser("id", nil)
+	assert.IsType(t, u, nsr.Hits[1])
+}
+
 func ExampleSearchUsers() {
 	c := websocket.NewWebSocket("localhost:7512", nil)
 	k, _ := kuzzle.NewKuzzle(c, nil)
@@ -76,32 +150,3 @@ func ExampleSearchUsers() {
 
 	fmt.Println(res.Hits[0].Id, res.Hits[0].Content)
 }
-
-func TestSearchUsersWithScroll(t *testing.T) {
-	c := &internal.MockedConnection{
-		MockSend: func(query []byte, options types.QueryOptions) *types.KuzzleResponse {
-			parsedQuery := &types.KuzzleRequest{}
-			json.Unmarshal(query, parsedQuery)
-
-			assert.Equal(t, "security", parsedQuery.Controller)
-			assert.Equal(t, "searchUsers", parsedQuery.Action)
-			assert.Equal(t, "1m", parsedQuery.Scroll)
-
-			return &types.KuzzleResponse{Result: []byte(`{
-				"total": 42,
-				"hits": [
-					{"_id": "user42", "_source": {"profileIds": ["admin", "other"}, "foo": "bar"}
-				],
-				"scrollId": "f00b4r"
-			}`)}
-		},
-	}
-	k, _ := kuzzle.NewKuzzle(c, nil)
-
-	opts := types.NewQueryOptions()
-	opts.SetFrom(2)
-	opts.SetSize(4)
-	opts.SetScroll("1m")
-
-	k.Security.SearchUsers(nil, opts)
-}
diff --git a/security/updateCredentials_test.go b/security/updateCredentials_test.go
index 463e1f09..738c40d7 100644
--- a/security/updateCredentials_test.go
+++ b/security/updateCredentials_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/security/user.go b/security/user.go
index 062135f1..9f079fd6 100644
--- a/security/user.go
+++ b/security/user.go
@@ -24,12 +24,6 @@ type User struct {
 	ProfileIds []string
 }
 
-type UserSearchResult struct {
-	Hits     []*User
-	Total    int
-	ScrollId string
-}
-
 func NewUser(id string, content *types.UserData) *User {
 	u := &User{
 		Id: id,
diff --git a/security/userSearchResult.go b/security/userSearchResult.go
new file mode 100644
index 00000000..0544b86b
--- /dev/null
+++ b/security/userSearchResult.go
@@ -0,0 +1,82 @@
+// Copyright 2015-2018 Kuzzle
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 		http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package security
+
+import (
+	"encoding/json"
+
+	"github.com/kuzzleio/sdk-go/types"
+)
+
+type UserSearchResult struct {
+	Aggregations json.RawMessage `json:"aggregations"`
+	Hits         []*User
+	Total        int `json:"total"`
+	Fetched      int
+	ScrollId     string `json:"scrollId"`
+	kuzzle       types.IKuzzle
+	request      *types.KuzzleRequest
+	response     *types.KuzzleResponse
+	options      types.QueryOptions
+}
+
+func (sr *UserSearchResult) Request() *types.KuzzleRequest {
+	return sr.request
+}
+
+func (sr *UserSearchResult) Response() *types.KuzzleResponse {
+	return sr.response
+}
+
+func (sr *UserSearchResult) Options() types.QueryOptions {
+	return sr.options
+}
+
+// Next returns the next page of roles
+func (usr *UserSearchResult) Next() (*UserSearchResult, error) {
+	sr, err := types.NewSearchResult(usr.kuzzle, "scrollUsers", usr.request, usr.options, usr.response)
+	if err != nil {
+		return nil, err
+	}
+
+	nsr, err := sr.Next()
+
+	if err != nil {
+		return nil, err
+	}
+
+	nusr := &UserSearchResult{
+		Aggregations: nsr.Aggregations,
+		Total:        nsr.Total,
+		Fetched:      nsr.Fetched,
+		ScrollId:     nsr.ScrollId,
+		kuzzle:       usr.kuzzle,
+		request:      usr.request,
+		response:     usr.response,
+		options:      usr.options,
+	}
+	var jusers []jsonUser
+	err = json.Unmarshal(nsr.Hits, &jusers)
+
+	if err != nil {
+		return nil, err
+	}
+
+	for _, juser := range jusers {
+		nusr.Hits = append(nusr.Hits, juser.jsonUserToUser())
+	}
+
+	return nusr, nil
+}
diff --git a/security/validateCredentials_test.go b/security/validateCredentials_test.go
index b651c0d0..a179fa98 100644
--- a/security/validateCredentials_test.go
+++ b/security/validateCredentials_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/server/adminExists_test.go b/server/adminExists_test.go
index 64133d5e..90162820 100644
--- a/server/adminExists_test.go
+++ b/server/adminExists_test.go
@@ -18,9 +18,9 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/server/getAllStats_test.go b/server/getAllStats_test.go
index 90e7176e..744f9822 100644
--- a/server/getAllStats_test.go
+++ b/server/getAllStats_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/server/getConfig_test.go b/server/getConfig_test.go
index 1ba73257..12199f11 100644
--- a/server/getConfig_test.go
+++ b/server/getConfig_test.go
@@ -18,9 +18,9 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/server/getLastStats_test.go b/server/getLastStats_test.go
index eea03013..aeaa6fa0 100644
--- a/server/getLastStats_test.go
+++ b/server/getLastStats_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/server/getStats.go b/server/getStats.go
index 7b30a2d5..7e3fc41e 100644
--- a/server/getStats.go
+++ b/server/getStats.go
@@ -40,7 +40,7 @@ func (s *Server) GetStats(startTime *time.Time, stopTime *time.Time, options typ
 
 	query := &types.KuzzleRequest{
 		Controller: "server",
-		Action:     "getLastStats",
+		Action:     "getStats",
 		Body:       d,
 	}
 
diff --git a/server/getStats_test.go b/server/getStats_test.go
index fb298c37..533fcb5f 100644
--- a/server/getStats_test.go
+++ b/server/getStats_test.go
@@ -20,9 +20,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
@@ -33,7 +33,7 @@ func TestGetStatsQueryError(t *testing.T) {
 			request := types.KuzzleRequest{}
 			json.Unmarshal(query, &request)
 			assert.Equal(t, "server", request.Controller)
-			assert.Equal(t, "getLastStats", request.Action)
+			assert.Equal(t, "getStats", request.Action)
 			return &types.KuzzleResponse{Error: types.KuzzleError{Message: "error"}}
 		},
 	}
@@ -48,7 +48,7 @@ func TestGetStats(t *testing.T) {
 			request := types.KuzzleRequest{}
 			json.Unmarshal(query, &request)
 			assert.Equal(t, "server", request.Controller)
-			assert.Equal(t, "getLastStats", request.Action)
+			assert.Equal(t, "getStats", request.Action)
 
 			return &types.KuzzleResponse{Result: json.RawMessage(`{"foo": "bar"}`)}
 		},
diff --git a/server/info_test.go b/server/info_test.go
index 773a6fc9..f5ebf712 100644
--- a/server/info_test.go
+++ b/server/info_test.go
@@ -18,9 +18,9 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/server/now_test.go b/server/now_test.go
index 0589d5c3..20725b05 100644
--- a/server/now_test.go
+++ b/server/now_test.go
@@ -19,9 +19,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/kuzzleio/sdk-go/connection/websocket"
 	"github.com/kuzzleio/sdk-go/internal"
 	"github.com/kuzzleio/sdk-go/kuzzle"
+	"github.com/kuzzleio/sdk-go/protocol/websocket"
 	"github.com/kuzzleio/sdk-go/types"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/test.sh b/test.sh
deleted file mode 100755
index 4a297305..00000000
--- a/test.sh
+++ /dev/null
@@ -1,51 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-workdir=$dir/.cover
-profile="$workdir/cover.out"
-mode=count
-dirs=(kuzzle connection/websocket collection security ms realtime index server auth document)
-timeout=${TIMEOUT:=1m}
-
-generate_cover_data() {
-    rm -rf "$workdir"
-    mkdir "$workdir"
-
-    for pkg in ${dirs[@]}; do
-        go test -timeout "$timeout" -covermode="$mode" -coverprofile="$workdir/$(basename $pkg).cover" "./$pkg"
-    done
-
-    echo "mode: $mode" >"$profile"
-    grep -h -v "^mode:" "$workdir"/*.cover >>"$profile"
-}
-
-show_cover_report() {
-    go tool cover -${1}="$profile"
-}
-
-linter_check() {
-    invalid_files=$(gofmt -l "$1")
-
-    if [ -n "${invalid_files}" ]; then
-        echo "Lint errors on the following files:"
-        echo ${invalid_files}
-        exit 1
-    fi
-}
-
-cd "$dir"
-
-linter_check .
-linter_check ./internal/wrappers
-generate_cover_data
-show_cover_report func
-
-case "$1" in
-"")
-    ;;
---html)
-    show_cover_report html ;;
-*)
-    echo >&2 "error: invalid option: $1"; exit 1 ;;
-esac
diff --git a/types/ikuzzle.go b/types/ikuzzle.go
index beb44d9e..2f308f5c 100644
--- a/types/ikuzzle.go
+++ b/types/ikuzzle.go
@@ -22,8 +22,8 @@ type IKuzzle interface {
 	Query(query *KuzzleRequest, options QueryOptions, responseChannel chan<- *KuzzleResponse)
 	EmitEvent(int, interface{})
 	SetJwt(string)
-	RegisterSub(string, string, json.RawMessage, bool, chan<- KuzzleNotification, chan<- interface{})
+	RegisterSub(string, string, json.RawMessage, bool, chan<- NotificationResult, chan<- interface{})
 	UnregisterSub(string)
-	AddListener(event int, notifChan chan<- interface{})
+	AddListener(event int, notifChan chan<- json.RawMessage)
 	AutoResubscribe() bool
 }
diff --git a/types/kuzzle_request.go b/types/kuzzle_request.go
index 784e7886..b062ebfe 100644
--- a/types/kuzzle_request.go
+++ b/types/kuzzle_request.go
@@ -17,50 +17,51 @@ package types
 import "encoding/json"
 
 type KuzzleRequest struct {
-	RequestId  string        `json:"requestId,omitempty"`
-	Controller string        `json:"controller,omitempty"`
-	Action     string        `json:"action,omitempty"`
-	Index      string        `json:"index,omitempty"`
-	Collection string        `json:"collection,omitempty"`
-	Body       interface{}   `json:"body"`
-	Id         string        `json:"_id,omitempty"`
-	From       int           `json:"from"`
-	Size       int           `json:"size"`
-	Scroll     string        `json:"scroll,omitempty"`
-	ScrollId   string        `json:"scrollId,omitempty"`
-	Strategy   string        `json:"strategy,omitempty"`
-	ExpiresIn  int           `json:"expiresIn,omitempty"`
-	Volatile   VolatileData  `json:"volatile"`
-	Scope      string        `json:"scope"`
-	State      string        `json:"state"`
-	Users      string        `json:"users"`
-	Start      int           `json:"start,omitempty"`
-	Stop       int           `json:"stop,omitempty"`
-	End        int           `json:"end,omitempty"`
-	Bit        int           `json:"bit,omitempty"`
-	Member     string        `json:"member,omitempty"`
-	Member1    string        `json:"member1,omitempty"`
-	Member2    string        `json:"member2,omitempty"`
-	Members    []string      `json:"members,omitempty"`
-	Lon        float64       `json:"lon,omitempty"`
-	Lat        float64       `json:"lat,omitempty"`
-	Distance   float64       `json:"distance,omitempty"`
-	Unit       string        `json:"unit,omitempty"`
-	Options    []interface{} `json:"options,omitempty"`
-	Keys       []string      `json:"keys,omitempty"`
-	Cursor     int           `json:"cursor,omitempty"`
-	Offset     int           `json:"offset,omitempty"`
-	Field      string        `json:"field,omitempty"`
-	Fields     []string      `json:"fields,omitempty"`
-	Subcommand string        `json:"subcommand,omitempty"`
-	Pattern    string        `json:"pattern,omitempty"`
-	Idx        int           `json:"idx, omitempty"`
-	Min        string        `json:"min,omitempty"`
-	Max        string        `json:"max,omitempty"`
-	Limit      string        `json:"limit,omitempty"`
-	Count      int           `json:"count,omitempty"`
-	Match      string        `json:"match,omitempty"`
-	Reset      bool          `json:"reset,omitempty"`
+	RequestId    string        `json:"requestId,omitempty"`
+	Controller   string        `json:"controller,omitempty"`
+	Action       string        `json:"action,omitempty"`
+	Index        string        `json:"index,omitempty"`
+	Collection   string        `json:"collection,omitempty"`
+	Body         interface{}   `json:"body"`
+	Id           string        `json:"_id,omitempty"`
+	From         int           `json:"from"`
+	Size         int           `json:"size"`
+	Scroll       string        `json:"scroll,omitempty"`
+	ScrollId     string        `json:"scrollId,omitempty"`
+	Strategy     string        `json:"strategy,omitempty"`
+	ExpiresIn    int           `json:"expiresIn,omitempty"`
+	Volatile     VolatileData  `json:"volatile"`
+	Scope        string        `json:"scope"`
+	State        string        `json:"state"`
+	Users        string        `json:"users"`
+	Start        int           `json:"start,omitempty"`
+	Stop         int           `json:"stop,omitempty"`
+	End          int           `json:"end,omitempty"`
+	Bit          int           `json:"bit,omitempty"`
+	Member       string        `json:"member,omitempty"`
+	Member1      string        `json:"member1,omitempty"`
+	Member2      string        `json:"member2,omitempty"`
+	Members      []string      `json:"members,omitempty"`
+	Lon          float64       `json:"lon,omitempty"`
+	Lat          float64       `json:"lat,omitempty"`
+	Distance     float64       `json:"distance,omitempty"`
+	Unit         string        `json:"unit,omitempty"`
+	Options      []interface{} `json:"options,omitempty"`
+	Keys         []string      `json:"keys,omitempty"`
+	Cursor       int           `json:"cursor,omitempty"`
+	Offset       int           `json:"offset,omitempty"`
+	Field        string        `json:"field,omitempty"`
+	Fields       []string      `json:"fields,omitempty"`
+	Subcommand   string        `json:"subcommand,omitempty"`
+	Pattern      string        `json:"pattern,omitempty"`
+	Idx          int           `json:"idx, omitempty"`
+	Min          string        `json:"min,omitempty"`
+	Max          string        `json:"max,omitempty"`
+	Limit        string        `json:"limit,omitempty"`
+	Count        int           `json:"count,omitempty"`
+	Match        string        `json:"match,omitempty"`
+	Reset        bool          `json:"reset,omitempty"`
+	IncludeTrash bool          `json:"includeTrash,omitempty"`
 }
 
 type SubscribeQuery struct {
diff --git a/types/kuzzle_response.go b/types/kuzzle_response.go
index 820051cd..b00de28f 100644
--- a/types/kuzzle_response.go
+++ b/types/kuzzle_response.go
@@ -42,33 +42,33 @@ type (
 		Channel string `json:"channel"`
 	}
 
-	// NotificationResult contains
-	NotificationResult struct {
+	// NotificationContent contains
+	NotificationContent struct {
 		Id      string          `json:"_id"`
 		Meta    *Meta           `json:"_meta"`
 		Content json.RawMessage `json:"_source"`
 		Count   int             `json:"count"`
 	}
 
-	// KuzzleNotification is a notification from Kuzzle
-	KuzzleNotification struct {
-		RequestId  string              `json:"requestId"`
-		Result     *NotificationResult `json:"result"`
-		Volatile   json.RawMessage     `json:"volatile"`
-		Index      string              `json:"index"`
-		Collection string              `json:"collection"`
-		Controller string              `json:"controller"`
-		Action     string              `json:"action"`
-		Protocol   string              `json:"protocol"`
-		Scope      string              `json:"scope"`
-		State      string              `json:"state"`
-		User       string              `json:"user"`
-		Type       string              `json:"type"`
-		RoomId     string              `json:"room"`
-		Channel    string              `json:"channel"`
-		Timestamp  int                 `json:"timestamp"`
-		Status     int                 `json:"status"`
-		Error      KuzzleError         `json:"error"`
+	// NotificationResult is a notification from Kuzzle
+	NotificationResult struct {
+		RequestId  string               `json:"requestId"`
+		Result     *NotificationContent `json:"result"`
+		Volatile   json.RawMessage      `json:"volatile"`
+		Index      string               `json:"index"`
+		Collection string               `json:"collection"`
+		Controller string               `json:"controller"`
+		Action     string               `json:"action"`
+		Protocol   string               `json:"protocol"`
+		Scope      string               `json:"scope"`
+		State      string               `json:"state"`
+		User       string               `json:"user"`
+		Type       string               `json:"type"`
+		RoomId     string               `json:"room"`
+		Channel    string               `json:"channel"`
+		Timestamp  int                  `json:"timestamp"`
+		Status     int                  `json:"status"`
+		Error      KuzzleError          `json:"error"`
 	}
 
 	// KuzzleResponse is a response to a KuzzleRequest
diff --git a/types/options.go b/types/options.go
index ba9a6a3f..8c042778 100644
--- a/types/options.go
+++ b/types/options.go
@@ -15,6 +15,7 @@
 package types
 
 import (
+	"net/http"
 	"time"
 )
 
@@ -43,12 +44,12 @@ type Options interface {
 	SetReconnectionDelay(time.Duration) *options
 	ReplayInterval() time.Duration
 	SetReplayInterval(time.Duration) *options
-	Refresh() string
-	SetRefresh(string) *options
 	Port() int
 	SetPort(int) *options
 	SslConnection() bool
 	SetSslConnection(bool) *options
+	Headers() *http.Header
+	SetHeaders(*http.Header) *options
 }
 
 type options struct {
@@ -62,9 +63,9 @@ type options struct {
 	reconnectionDelay time.Duration
 	replayInterval    time.Duration
 	connect           int
-	refresh           string
 	port              int
 	sslConnection     bool
+	headers           *http.Header
 }
 
 func (o options) QueueTTL() time.Duration {
@@ -148,15 +149,6 @@ func (o *options) SetReplayInterval(replayInterval time.Duration) *options {
 	return o
 }
 
-func (o options) Refresh() string {
-	return o.refresh
-}
-
-func (o *options) SetRefresh(refresh string) *options {
-	o.refresh = refresh
-	return o
-}
-
 func (o *options) Port() int {
 	return o.port
 }
@@ -175,6 +167,15 @@ func (o *options) SetSslConnection(v bool) *options {
 	return o
 }
 
+func (o *options) Headers() *http.Header {
+	return o.headers
+}
+
+func (o *options) SetHeaders(h *http.Header) *options {
+	o.headers = h
+	return o
+}
+
 // NewOptions instanciates new Options with default values
 func NewOptions() *options {
 	return &options{
@@ -189,5 +190,6 @@ func NewOptions() *options {
 		replayInterval:    10,
 		port:              7512,
 		sslConnection:     false,
+		headers:           nil,
 	}
 }
diff --git a/types/query_object.go b/types/query_object.go
index 5e86b1c0..66af769b 100644
--- a/types/query_object.go
+++ b/types/query_object.go
@@ -23,7 +23,7 @@ type QueryObject struct {
 	Query     []byte
 	Options   QueryOptions
 	ResChan   chan<- *KuzzleResponse
-	NotifChan chan<- *KuzzleNotification
+	NotifChan chan<- *NotificationResult
 	Timestamp time.Time
 	RequestId string
 }
diff --git a/types/query_options.go b/types/query_options.go
index b1866400..51e5d817 100644
--- a/types/query_options.go
+++ b/types/query_options.go
@@ -32,6 +32,8 @@ type QueryOptions interface {
 	SetRefresh(string) *queryOptions
 	IfExist() string
 	SetIfExist(string) *queryOptions
+	IncludeTrash() bool
+	SetIncludeTrash(bool) *queryOptions
 	RetryOnConflict() int
 	SetRetryOnConflict(int) *queryOptions
 	Start() int
@@ -91,6 +93,7 @@ type queryOptions struct {
 	volatile        VolatileData
 	refresh         string
 	ifExist         string
+	includeTrash    bool
 	retryOnConflict int
 	start           int
 	end             int
@@ -190,6 +193,15 @@ func (qo *queryOptions) SetIfExist(ifExist string) *queryOptions {
 	return qo
 }
 
+func (qo *queryOptions) IncludeTrash() bool {
+	return qo.includeTrash
+}
+
+func (qo *queryOptions) SetIncludeTrash(includeTrash bool) *queryOptions {
+	qo.includeTrash = includeTrash
+	return qo
+}
+
 func (qo queryOptions) RetryOnConflict() int {
 	return qo.retryOnConflict
 }
diff --git a/types/room.go b/types/room.go
index 8543f894..d56bc128 100644
--- a/types/room.go
+++ b/types/room.go
@@ -24,9 +24,9 @@ type SubscribeResponse struct {
 
 // IRoom provides functions to manage Room
 type IRoom interface {
-	Subscribe(realtimeNotificationChannel chan<- KuzzleNotification)
+	Subscribe(realtimeNotificationChannel chan<- NotificationResult)
 	Unsubscribe() error
-	RealtimeChannel() chan<- KuzzleNotification
+	RealtimeChannel() chan<- NotificationResult
 	ResponseChannel() chan SubscribeResponse
 	RoomId() string
 	Filters() interface{}
diff --git a/types/search_result.go b/types/search_result.go
index ed29c5ac..952c2adb 100644
--- a/types/search_result.go
+++ b/types/search_result.go
@@ -16,45 +16,233 @@ package types
 
 import (
 	"encoding/json"
+	"fmt"
+	"strings"
 )
 
 // SearchResult is a search result representation
 type SearchResult struct {
-	Collection   string
-	Documents    json.RawMessage
+	Aggregations json.RawMessage
+	Hits         json.RawMessage
 	Total        int
 	Fetched      int
-	Aggregations json.RawMessage
-	Options      QueryOptions
-	Filters      json.RawMessage
+	ScrollId     string
+	kuzzle       IKuzzle
+	request      *KuzzleRequest
+	response     *KuzzleResponse
+	options      QueryOptions
+	scrollAction string
 }
 
 // NewSearchResult Search Result constructor
-func NewSearchResult(collection string, filters json.RawMessage, options QueryOptions, raw *KuzzleResponse) *SearchResult {
+func NewSearchResult(kuzzle IKuzzle, scrollAction string, request *KuzzleRequest, options QueryOptions, raw *KuzzleResponse) (*SearchResult, error) {
 	type ParseSearchResult struct {
-		Documents    json.RawMessage `json:"hits"`
+		Hits         json.RawMessage `json:"hits"`
 		Total        int             `json:"total"`
-		ScrollID     string          `json:"_scroll_id"`
+		ScrollId     string          `json:"_scroll_id"`
 		Aggregations json.RawMessage `json:"aggregations"`
 	}
 
 	var parsed ParseSearchResult
-	json.Unmarshal(raw.Result, &parsed)
+	err := json.Unmarshal(raw.Result, &parsed)
+
+	if err != nil {
+		return nil, NewError(fmt.Sprintf("Unable to parse response: %s\n%s", err.Error(), raw.Result), 500)
+	}
+
+	var docs []interface{}
+	json.Unmarshal(parsed.Hits, &docs)
 
 	sr := &SearchResult{
-		Collection:   collection,
-		Filters:      filters,
-		Documents:    parsed.Documents,
-		Total:        parsed.Total,
-		Fetched:      len(parsed.Documents),
 		Aggregations: parsed.Aggregations,
-		Options:      NewQueryOptions(),
+		Hits:         parsed.Hits,
+		Fetched:      len(docs),
+		Total:        parsed.Total,
+		ScrollId:     parsed.ScrollId,
+		kuzzle:       kuzzle,
+		request:      request,
+		response:     raw,
+		options:      NewQueryOptions(),
+		scrollAction: scrollAction,
+	}
+
+	sr.options = options
+
+	return sr, nil
+}
+
+func (sr *SearchResult) Kuzzle() IKuzzle {
+	return sr.kuzzle
+}
+
+func (sr *SearchResult) Request() *KuzzleRequest {
+	return sr.request
+}
+
+func (sr *SearchResult) Response() *KuzzleResponse {
+	return sr.response
+}
+
+func (sr *SearchResult) Options() QueryOptions {
+	return sr.options
+}
+
+func (sr *SearchResult) ScrollAction() string {
+	return sr.scrollAction
+}
+
+// Next page result
+func (sr *SearchResult) Next() (*SearchResult, error) {
+	if sr.Fetched >= sr.Total {
+		return nil, nil
+	}
+
+	var pb struct {
+		Sort []map[string]string `json:"sort"`
+	}
+	j, _ := json.Marshal(sr.request.Body)
+	json.Unmarshal(j, &pb)
+
+	if sr.ScrollId != "" {
+		// scroll
+
+		query := &KuzzleRequest{
+			Controller: sr.request.Controller,
+			Action:     sr.scrollAction,
+		}
+
+		options := sr.options
+		options.SetScrollId(sr.ScrollId)
+
+		ch := make(chan *KuzzleResponse)
+		go sr.kuzzle.Query(query, sr.options, ch)
+		res := <-ch
+
+		nsr, err := NewSearchResult(sr.kuzzle, sr.scrollAction, query, options, res)
+
+		if err != nil {
+			return nil, err
+		}
+
+		nsr.Fetched += sr.Fetched
+
+		return nsr, nil
+	} else if pb.Sort != nil && sr.request.Size > 0 {
+		// search_after
+
+		query := sr.request
+		query.RequestId = ""
+
+		type Parsed struct {
+			Hits []map[string]interface{} `json:"hits"`
+		}
+		var parsed Parsed
+		json.Unmarshal(sr.response.Result, &parsed)
+
+		last := make(map[string]interface{})
+		if len(parsed.Hits) > 0 {
+			last = parsed.Hits[len(parsed.Hits)-1]
+		}
+
+		searchAfter := make([]interface{}, 0)
+		for _, v := range pb.Sort {
+			for key := range v {
+				searchAfter = append(searchAfter, getDeepField(key, last, 0))
+			}
+		}
+
+		var body map[string]interface{}
+		jbody, ok := sr.request.Body.(json.RawMessage)
+		if ok {
+			json.Unmarshal(jbody, &body)
+			body["search_after"] = searchAfter
+			query.Body = body
+		}
+		mbody, ok := sr.request.Body.(map[string]interface{})
+		if ok {
+			mbody["search_after"] = searchAfter
+			query.Body = mbody
+		}
+		fmt.Println(searchAfter)
+
+		options := sr.options
+
+		ch := make(chan *KuzzleResponse)
+		go sr.kuzzle.Query(query, sr.options, ch)
+		res := <-ch
+
+		nsr, err := NewSearchResult(sr.kuzzle, sr.scrollAction, query, options, res)
+
+		if err != nil {
+			return nil, err
+		}
+
+		nsr.Fetched += sr.Fetched
+
+		return nsr, nil
+	} else if sr.request.Size > 0 {
+		// from/size
+
+		if sr.request.From >= sr.Total {
+			return nil, nil
+		}
+
+		query := sr.request
+		query.RequestId = ""
+		query.From = sr.Fetched
+		options := sr.options
+		options.SetFrom(sr.Fetched)
+
+		ch := make(chan *KuzzleResponse)
+		go sr.kuzzle.Query(query, options, ch)
+		res := <-ch
+
+		nsr, err := NewSearchResult(sr.kuzzle, sr.scrollAction, query, options, res)
+
+		if err != nil {
+			return nil, err
+		}
+
+		nsr.Fetched += sr.Fetched
+
+		return nsr, nil
+	}
+
+	return nil, NewError("Unable to retrieve next results from search: missing scrollId, from/sort, or from/size parameters")
+}
+
+func getDeepField(key string, s map[string]interface{}, depth int) interface{} {
+	if depth == 0 && key == "_uid" {
+		key = "_id"
+	}
+	if depth == 0 && key != "_id" && key != "_score" {
+		key = "_source." + key
+	}
+
+	if s[key] != nil {
+		str, ok := s[key].(string)
+		if ok {
+			return str
+		}
+		i, ok := s[key].(int)
+		if ok {
+			return i
+		}
+		f, ok := s[key].(float64)
+		if ok {
+			return f
+		}
+	}
+
+	keys := strings.Split(key, ".")
+	if len(keys) == 1 {
+		return nil
 	}
 
-	if options != nil {
-		sr.Options.SetFrom(options.From())
-		sr.Options.SetSize(options.Size())
+	m, ok := s[keys[0]].(map[string]interface{})
+	if ok {
+		return getDeepField(strings.Join(keys[1:], "."), m, depth+1)
 	}
 
-	return sr
+	return nil
 }
diff --git a/internal/wrappers/headers/core.hpp b/types/validation_response.go
similarity index 50%
rename from internal/wrappers/headers/core.hpp
rename to types/validation_response.go
index 8492db9c..0bd085be 100644
--- a/internal/wrappers/headers/core.hpp
+++ b/types/validation_response.go
@@ -12,15 +12,28 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef _CORE_HPP_
-#define _CORE_HPP_
+package types
 
-extern "C" {
-  #define _Complex
-  #include <stdio.h>
+import (
+	"encoding/json"
+	"fmt"
+)
 
-  #include "kuzzle.h"
-  #include "kuzzlesdk.h"
+// ValidationResponse contains a validation response
+type ValidationResponse struct {
+	Valid       bool     `json:"valid"`
+	Details     []string `json:"details"`
+	Description string   `json:"description"`
 }
 
-#endif
+func NewValidationResponse(validationResponse json.RawMessage) (*ValidationResponse, error) {
+	vr := &ValidationResponse{}
+
+	err := json.Unmarshal(validationResponse, vr)
+
+	if err != nil {
+		return nil, NewError(fmt.Sprintf("Unable to parse response: %s\n%s", err.Error(), validationResponse), 500)
+	}
+
+	return vr, nil
+}