diff --git a/zeus/AbstractFunction.cpp b/zeus/AbstractFunction.cpp
index ecbb5d3..0532238 100644
--- a/zeus/AbstractFunction.cpp
+++ b/zeus/AbstractFunction.cpp
@@ -86,62 +86,14 @@ zeus::AbstractFunction::AbstractFunction(const std::string& _name,
 }
 
 
-bool zeus::AbstractFunction::checkCompatibility(const ParamType& _type, const std::string& _params) {
-	if (createType<bool>() == _type) {
-		return _params == "bool";
+bool zeus::AbstractFunction::checkCompatibility(const ParamType& _type, const ParamType& _params) {
+	if (_params == _type) {
+		return true;
 	}
-	if (    createType<int64_t>() == _type
-	     || createType<int32_t>() == _type
-	     || createType<int16_t>() == _type
-	     || createType<int8_t>() == _type
-	     || createType<uint64_t>() == _type
-	     || createType<uint32_t>() == _type
-	     || createType<uint16_t>() == _type
-	     || createType<uint8_t>() == _type
-	     || createType<float>() == _type
-	     || createType<double>() == _type) {
-		return    _params == "int8"
-		       || _params == "int16"
-		       || _params == "int32"
-		       || _params == "int64"
-		       || _params == "uint8"
-		       || _params == "uint16"
-		       || _params == "uint32"
-		       || _params == "uint64"
-		       || _params == "float"
-		       || _params == "double";
-	}
-	if (createType<std::vector<std::string>>() == _type) {
-		return _params == "vector:string";
-	}
-	if (    createType<std::vector<bool>>() == _type
-	     || createType<std::vector<int64_t>>() == _type
-	     || createType<std::vector<int32_t>>() == _type
-	     || createType<std::vector<int16_t>>() == _type
-	     || createType<std::vector<int8_t>>() == _type
-	     || createType<std::vector<uint64_t>>() == _type
-	     || createType<std::vector<uint32_t>>() == _type
-	     || createType<std::vector<uint16_t>>() == _type
-	     || createType<std::vector<uint8_t>>() == _type
-	     || createType<std::vector<float>>() == _type
-	     || createType<std::vector<double>>() == _type) {
-		return    _params == "vector:int8"
-		       || _params == "vector:int16"
-		       || _params == "vector:int32"
-		       || _params == "vector:int64"
-		       || _params == "vector:uint8"
-		       || _params == "vector:uint16"
-		       || _params == "vector:uint32"
-		       || _params == "vector:uint64"
-		       || _params == "vector:float"
-		       || _params == "vector:double"
-		       || _params == "vector:empty";
-	}
-	if (createType<zeus::File>() == _type) {
-		return _params == "file";
-	}
-	if (createType<std::string>() == _type) {
-		return _params == "string";
+	// check cross compatibilité (All number are convertible (with min/max) and all number vector are convertible (min/max too)
+	if (    _type.isNumber() == true
+	     && _params.isNumber() == true) {
+		return _type.isVector() == _params.isVector();
 	}
 	return false;
 }
diff --git a/zeus/AbstractFunction.h b/zeus/AbstractFunction.h
index 95bcb31..53e67b7 100644
--- a/zeus/AbstractFunction.h
+++ b/zeus/AbstractFunction.h
@@ -58,7 +58,7 @@ namespace zeus {
 		public:
 			virtual ~AbstractFunction() {};
 		public:
-			bool checkCompatibility(const ParamType& _type, const std::string& _params);
+			bool checkCompatibility(const ParamType& _type, const ParamType& _params);
 		public:
 			std::string getPrototypeFull() const;
 			virtual std::string getPrototype() const = 0;
diff --git a/zeus/AbstractFunctionTypeClass.h b/zeus/AbstractFunctionTypeClass.h
index c55447c..d8a93c4 100644
--- a/zeus/AbstractFunctionTypeClass.h
+++ b/zeus/AbstractFunctionTypeClass.h
@@ -73,6 +73,7 @@ namespace zeus {
 				answer.setPartId(m_partId);
 				answer.setPartFinish(false);
 				if (m_partId == 0) {
+					answer.setType(zeus::Buffer::typeMessage::answer);
 					m_node.fileOpenRead();
 					std::string extention = std::string(m_data.getFileName().begin()+m_data.getFileName().size() -3, m_data.getFileName().end());
 					ZEUS_WARNING("send file: '" << m_data.getFileName() << "' with extention: '" << extention << "'");
@@ -83,6 +84,7 @@ namespace zeus {
 					m_partId++;
 					return false;
 				}
+				answer.setType(zeus::Buffer::typeMessage::data);
 				int32_t tmpSize = 1024;
 				if (m_size < 1024) {
 					tmpSize = m_size;
diff --git a/zeus/Buffer.cpp b/zeus/Buffer.cpp
index f4b55a2..1a95a3b 100644
--- a/zeus/Buffer.cpp
+++ b/zeus/Buffer.cpp
@@ -37,10 +37,10 @@ static enum zeus::Buffer::typeMessage getTypeType(uint16_t _value) {
 			return zeus::Buffer::typeMessage::call;
 		case 2:
 			return zeus::Buffer::typeMessage::answer;
+		case 3:
+			return zeus::Buffer::typeMessage::data;
 		case 4:
 			return zeus::Buffer::typeMessage::event;
-		case 8:
-			return zeus::Buffer::typeMessage::data;
 	}
 	return zeus::Buffer::typeMessage::call;
 }
@@ -51,19 +51,58 @@ zeus::Buffer::Buffer() {
 
 void zeus::Buffer::internalComposeWith(const uint8_t* _buffer, uint32_t _lenght) {
 	clear();
+	if (_lenght < sizeof(headerBin)) {
+		ZEUS_ERROR("wrong size of the buffer");
+		return;
+	}
 	uint32_t offset = 0;
 	memcpy(reinterpret_cast<char*>(&m_header), &_buffer[offset], sizeof(headerBin));
 	offset += sizeof(headerBin);
-	if (m_header.numberOfParameter != 0) {
-		m_paramOffset.resize(m_header.numberOfParameter);
-		memcpy(&m_paramOffset[0], &_buffer[offset], m_header.numberOfParameter * sizeof(uint16_t));
-		offset += m_header.numberOfParameter * sizeof(uint16_t);
-		m_data.resize(_lenght - offset);
-		memcpy(&m_data[0], &_buffer[offset], m_data.size());
-	} else {
-		// TODO : check size ...
+	m_parameter.clear();
+	m_parameter.resize(m_header.numberOfParameter, std::make_pair(-1, std::vector<uint8_t>()));
+	// Load all Parameters
+	int32_t nbParameters = 0;
+	while (    nbParameters < m_header.numberOfParameter
+	        && offset < _lenght) {
+		// parameters is contituated with size + data assiciated
+		uint16_t sizeParam;
+		memcpy(&sizeParam, &_buffer[offset], sizeof(uint16_t));
+		offset += sizeof(uint16_t);
+		if (offset+sizeParam > _lenght) {
+			ZEUS_ERROR("Wrong parameter size : " << sizeParam << " / availlable=" << _lenght-offset);
+			return;
+		}
+		std::vector<uint8_t> data;
+		data.resize(sizeParam);
+		memcpy(&data[0], &_buffer[offset], data.size() * sizeof(uint8_t));
+		offset += data.size() * sizeof(uint8_t);
+		m_parameter[nbParameters].second = data;
+		nbParameters++;
 	}
-	ZEUS_DEBUG("Get binary messages " << generateHumanString());
+}
+
+bool zeus::Buffer::writeOn(enet::WebSocket& _interface) {
+	m_header.numberOfParameter = m_parameter.size();
+	uint64_t size = sizeof(headerBin);
+	for (auto &it : m_parameter) {
+		size += sizeof(uint16_t); // parameter size
+		size += it.second.size();
+	}
+	ZEUS_DEBUG("Send BINARY " << size << " bytes '" << generateHumanString() << "'");
+	
+	if (_interface.writeHeader(size, false) == false) {
+		return false;
+	}
+	uint8_t* data = nullptr;
+	uint32_t dataSize = 0;
+	m_header.numberOfParameter = m_parameter.size();
+	size = _interface.writeData((uint8_t*)&m_header, sizeof(headerBin));
+	for (auto &it : m_parameter) {
+		uint16_t paramSize = it.second.size();
+		size = _interface.writeData((uint8_t*)&paramSize, sizeof(uint16_t));
+		size = _interface.writeData(&it.second[0], it.second.size() * sizeof(uint8_t));
+	}
+	return true;
 }
 
 void zeus::Buffer::composeWith(const std::vector<uint8_t>& _buffer) {
@@ -71,45 +110,52 @@ void zeus::Buffer::composeWith(const std::vector<uint8_t>& _buffer) {
 }
 
 void zeus::Buffer::clear() {
-	ZEUS_VERBOSE("clear buffer");
-	m_data.clear();
-	m_paramOffset.clear();
-	m_header.versionProtocol = 1;
+	m_parameter.clear();
 	m_header.transactionID = 1;
 	m_header.clientID = 0;
 	m_header.partID = 0x8000;
 	m_header.typeMessage = 1;
 	m_header.numberOfParameter = 1;
 }
+
 std::string zeus::Buffer::generateHumanString() {
-	std::string out = "zeus::Buffer Lenght=: ";
-	out += " v=" + etk::to_string(m_header.versionProtocol);
+	std::string out = "zeus::Buffer: ";
+	//out += " v=" + etk::to_string(m_header.versionProtocol); // se it in the websocket
 	out += " id=" + etk::to_string(m_header.transactionID);
 	out += " cId=" + etk::to_string(m_header.clientID);
-	out += " pId=" + etk::to_string(getPartId());
-	out += " finish=" + etk::to_string(getPartFinish());
+	if (    getPartId() != 0
+	     || getPartFinish() == false) {
+		out += " part=" + etk::to_string(getPartId());
+		if (getPartFinish() == true) {
+			out += "/finish";
+		}
+	}
 	enum zeus::Buffer::typeMessage type = getTypeType(m_header.typeMessage);
-	out += " type=" + etk::to_string(type);
 	switch (type) {
 		case zeus::Buffer::typeMessage::call:
 			out += " nbParam=" + etk::to_string(getNumberParameter());
-			out += " call='" + getCall() + "'";
+			out += " -CALL-:'" + getCall() + "'";
 			break;
 		case zeus::Buffer::typeMessage::answer:
-			if (m_paramOffset.size() == 1) {
-				out += " mode=Value";
-			} else if (m_paramOffset.size() == 2) {
-				out += " mode=Error";
-			} else if (m_paramOffset.size() == 3) {
-				out += " mode=Value+Error";
+			out += " -ANSWER-:";
+			if (m_parameter.size() == 1) {
+				out += "Value:" + simpleStringParam(0);
+			} else if (m_parameter.size() == 2) {
+				out += "Error";
+				out += "Error:" + simpleStringParam(0);
+			} else if (m_parameter.size() == 3) {
+				out += "Value:" + simpleStringParam(0);
+				out += "+Error:" + simpleStringParam(1);
 			} else {
-				out += " mode=???";
+				out += "???";
 			}
 			break;
 		case zeus::Buffer::typeMessage::event:
+			out += " -EVENT-";
 			
 			break;
 		case zeus::Buffer::typeMessage::data:
+			out += " -DATA-";
 			
 			break;
 	}
@@ -119,28 +165,18 @@ std::string zeus::Buffer::generateHumanString() {
 			if (iii != 0) {
 				out += ",";
 			}
-			out += internalGetParameterType(iii);
+			out += internalGetParameterType(iii).getName();
 		}
 		out += ")";
 	}
 	return out;
 }
 
-uint16_t zeus::Buffer::getProtocalVersion() const {
-	return m_header.versionProtocol;
-}
-
-void zeus::Buffer::setProtocolVersion(uint16_t _value) {
-	ZEUS_VERBOSE("setProtocolVersion :" << _value);
-	m_header.versionProtocol = _value;
-}
-
 uint32_t zeus::Buffer::getTransactionId() const {
 	return m_header.transactionID;
 }
 
 void zeus::Buffer::setTransactionId(uint32_t _value) {
-	ZEUS_VERBOSE("setTransactionId :" << _value);
 	m_header.transactionID = _value;
 }
 
@@ -149,7 +185,6 @@ uint32_t zeus::Buffer::getClientId() const {
 }
 
 void zeus::Buffer::setClientId(uint32_t _value) {
-	ZEUS_VERBOSE("setClientId :" << _value);
 	m_header.clientID = _value;
 }
 
@@ -159,7 +194,6 @@ uint16_t zeus::Buffer::getPartId() const {
 }
 
 void zeus::Buffer::setPartId(uint16_t _value) {
-	ZEUS_VERBOSE("setPartId :" << _value);
 	m_header.partID = (m_header.partID&0x8000) | (_value & 0x7FFF);
 }
 
@@ -168,7 +202,6 @@ bool zeus::Buffer::getPartFinish() const {
 }
 
 void zeus::Buffer::setPartFinish(bool _value) {
-	ZEUS_VERBOSE("setPartFinish :" << _value);
 	if (_value == true) {
 		m_header.partID = (m_header.partID & 0x7FFF) | 0x8000;
 	} else {
@@ -181,41 +214,72 @@ enum zeus::Buffer::typeMessage zeus::Buffer::getType() const {
 }
 
 void zeus::Buffer::setType(enum typeMessage _value) {
-	ZEUS_VERBOSE("setType :" << _value);
 	m_header.typeMessage = uint16_t(_value);
 }
 
 uint16_t zeus::Buffer::getNumberParameter() const {
-	return m_paramOffset.size()-1;
+	return m_parameter.size()-1;
 }
-std::string zeus::Buffer::internalGetParameterType(int32_t _id) const {
-	std::string out;
-	if (m_paramOffset.size() <= _id) {
-		ZEUS_ERROR("out of range Id for parameter ... " << _id << " have " << m_paramOffset.size());
-		return out;
+zeus::ParamType zeus::Buffer::internalGetParameterType(int32_t _id) const {
+	if (m_parameter.size() <= _id) {
+		ZEUS_ERROR("out of range Id for parameter ... " << _id << " have " << m_parameter.size());
+		return createType<void>();
 	}
-	out = reinterpret_cast<const char*>(&m_data[m_paramOffset[_id]]);
-	return out;
+	if (m_parameter[_id].second.size() < 2) {
+		ZEUS_ERROR("try to get type with no ID value Type (not enouth data)");
+		return createType<void>();
+	}
+	uint16_t typeId = (uint16_t(m_parameter[_id].second[0]) << 8) + uint16_t(m_parameter[_id].second[1]);
+	if (typeId == createType<void>().getId()) { m_parameter[_id].first = 2; return createType<void>(); }
+	if (typeId == createType<bool>().getId()) { m_parameter[_id].first = 2; return createType<bool>(); }
+	if (typeId == createType<float>().getId()) { m_parameter[_id].first = 2; return createType<float>(); }
+	if (typeId == createType<double>().getId()) { m_parameter[_id].first = 2; return createType<double>(); }
+	if (typeId == createType<int64_t>().getId()) { m_parameter[_id].first = 2; return createType<int64_t>(); }
+	if (typeId == createType<int32_t>().getId()) { m_parameter[_id].first = 2; return createType<int32_t>(); }
+	if (typeId == createType<int16_t>().getId()) { m_parameter[_id].first = 2; return createType<int16_t>(); }
+	if (typeId == createType<int8_t>().getId()) { m_parameter[_id].first = 2; return createType<int8_t>(); }
+	if (typeId == createType<uint64_t>().getId()) { m_parameter[_id].first = 2; return createType<uint64_t>(); }
+	if (typeId == createType<uint32_t>().getId()) { m_parameter[_id].first = 2; return createType<uint32_t>(); }
+	if (typeId == createType<uint16_t>().getId()) { m_parameter[_id].first = 2; return createType<uint16_t>(); }
+	if (typeId == createType<uint8_t>().getId()) { m_parameter[_id].first = 2; return createType<uint8_t>(); }
+	if (typeId == createType<std::string>().getId()) { m_parameter[_id].first = 2; return createType<std::string>(); }
+	if (typeId == createType<std::vector<void>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<void>>(); }
+	if (typeId == createType<std::vector<bool>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<bool>>(); }
+	if (typeId == createType<std::vector<float>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<float>>(); }
+	if (typeId == createType<std::vector<double>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<double>>(); }
+	if (typeId == createType<std::vector<int64_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<int64_t>>(); }
+	if (typeId == createType<std::vector<int32_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<int32_t>>(); }
+	if (typeId == createType<std::vector<int16_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<int16_t>>(); }
+	if (typeId == createType<std::vector<int8_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<int8_t>>(); }
+	if (typeId == createType<std::vector<uint64_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<uint64_t>>(); }
+	if (typeId == createType<std::vector<uint32_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<uint32_t>>(); }
+	if (typeId == createType<std::vector<uint16_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<uint16_t>>(); }
+	if (typeId == createType<std::vector<uint8_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<uint8_t>>(); }
+	if (typeId == createType<std::vector<std::string>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<std::string>>(); }
+	if (typeId == createType<zeus::File>().getId()) { m_parameter[_id].first = 2; return createType<zeus::File>(); }
+	if (typeId == paramTypeObject) {
+		std::string type = reinterpret_cast<const char*>(&m_parameter[_id].second[2]);
+		m_parameter[_id].first = type.size() + sizeof(uint16_t);
+		// TODO : Check error of \0 ==> limit at 256 char ...
+		return zeus::ParamType(type, paramTypeObject);
+	}
+	ZEUS_ERROR("Can not get type of parameter ... ");
+	return createType<void>();
 }
-std::string zeus::Buffer::getParameterType(int32_t _id) const {
+zeus::ParamType zeus::Buffer::getParameterType(int32_t _id) const {
 	return internalGetParameterType(_id + 1);
 }
 
 const uint8_t* zeus::Buffer::internalGetParameterPointer(int32_t _id) const {
 	const uint8_t* out = nullptr;
-	if (m_paramOffset.size() <= _id) {
-		ZEUS_ERROR("out of range Id for parameter ... " << _id << " have " << m_paramOffset.size());
+	if (m_parameter.size() <= _id) {
+		ZEUS_ERROR("out of range Id for parameter ... " << _id << " have " << m_parameter.size());
 		return out;
 	}
-	out = reinterpret_cast<const uint8_t*>(&m_data[m_paramOffset[_id]]);
-	if (out == nullptr) {
-		return out;
+	if (m_parameter[_id].first <= -1) {
+		internalGetParameterType(_id); // this function initialize this parameter if needed ...
 	}
-	// TODO : unlock if > 1024
-	while (*out != 0) {
-		out++;
-	}
-	out++;
+	out = reinterpret_cast<const uint8_t*>(&m_parameter[_id].second[m_parameter[_id].first]);
 	return out;
 }
 
@@ -225,547 +289,316 @@ const uint8_t* zeus::Buffer::getParameterPointer(int32_t _id) const {
 
 uint32_t zeus::Buffer::internalGetParameterSize(int32_t _id) const {
 	int32_t out = 0;
-	if (m_paramOffset.size() <= _id) {
-		ZEUS_ERROR("out of range Id for parameter ... " << _id << " have " << m_paramOffset.size());
-		return out;
+	if (m_parameter.size() <= _id) {
+		ZEUS_ERROR("out of range Id for parameter ... " << _id << " have " << m_parameter.size());
+		return 0;
 	}
-	int32_t startPos = m_paramOffset[_id];
-	int32_t endPos = m_data.size();
-	if (m_paramOffset.size() > _id+1) {
-		endPos = m_paramOffset[_id+1];
+	if (m_parameter[_id].first <= -1) {
+		internalGetParameterType(_id); // this function initialize this parameter if needed ...
 	}
-	// First get type:
-	const char* type = reinterpret_cast<const char*>(&m_data[startPos]); // Will be stop with \0 ...
-	// move in the buffer pos
-	startPos += strlen(type) + 1;
-	// get real data size
-	out = endPos - startPos;
-	out --;
-	if (out < 0) {
-		ZEUS_ERROR("Get size < 0 : " << out);
-		out = 0;
-	}
-	return out;
+	return m_parameter[_id].second.size() - m_parameter[_id].first;
 }
 
-
-
 void zeus::Buffer::addData(void* _data, uint32_t _size) {
-	m_paramOffset.clear();
+	m_parameter.clear();
 	setType(zeus::Buffer::typeMessage::data);
-	m_data.resize(_size);
-	memcpy(&m_data[0], _data, _size);
+	//m_data.resize(_size);
+	//memcpy(&m_data[0], _data, _size);
+	ZEUS_TODO("Must implement the add data ...");
 }
 
-
 uint32_t zeus::Buffer::getParameterSize(int32_t _id) const {
 	return internalGetParameterSize(_id + 1);
 }
 
+static void addType(std::vector<uint8_t>& _data, zeus::ParamType _type) {
+	_data.push_back(uint8_t(_type.getId()>>8));
+	_data.push_back(uint8_t(_type.getId()));
+}
+
+static void addTypeObject(std::vector<uint8_t>& _data, const std::string _type) {
+	_data.push_back(uint8_t(zeus::paramTypeObject>>8));
+	_data.push_back(uint8_t(zeus::paramTypeObject));
+	for (auto &it : _type) {
+		_data.push_back(uint8_t(it));
+	}
+	_data.push_back(0);
+}
+
 void zeus::Buffer::addParameter() {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('v');
-	m_data.push_back('o');
-	m_data.push_back('i');
-	m_data.push_back('d');
-	m_data.push_back('\0');
+	std::vector<uint8_t> data;
+	addType(data, createType<void>());
+	m_parameter.push_back(std::make_pair(2,data));
 }
 void zeus::Buffer::addParameterEmptyVector() {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('v');
-	m_data.push_back('e');
-	m_data.push_back('c');
-	m_data.push_back('t');
-	m_data.push_back('o');
-	m_data.push_back('r');
-	m_data.push_back(':');
-	m_data.push_back('e');
-	m_data.push_back('m');
-	m_data.push_back('p');
-	m_data.push_back('t');
-	m_data.push_back('y');
-	m_data.push_back('\0');
+	// special case of json change mode
+	std::vector<uint8_t> data;
+	addType(data, createType<std::vector<void>>());
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<std::string>(const std::string& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('s');
-	m_data.push_back('t');
-	m_data.push_back('r');
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('g');
-	m_data.push_back('\0');
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+_value.size()+1);
-	memcpy(&m_data[currentOffset], &_value[0], _value.size());
+	std::vector<uint8_t> data;
+	addType(data, createType<std::string>());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+_value.size());
+	memcpy(&data[currentOffset], &_value[0], _value.size());
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<std::vector<std::string>>(const std::vector<std::string>& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('v');
-	m_data.push_back('e');
-	m_data.push_back('c');
-	m_data.push_back('t');
-	m_data.push_back('o');
-	m_data.push_back('r');
-	m_data.push_back(':');
-	m_data.push_back('s');
-	m_data.push_back('t');
-	m_data.push_back('r');
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('g');
-	m_data.push_back('\0');
+	std::vector<uint8_t> data;
+	addType(data, createType<std::vector<std::string>>());
 	// count all datas:
 	uint32_t size = 0;
 	for (auto &it : _value) {
 		size+=it.size()+1;
 	}
 	uint16_t nb = _value.size();
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+size+2);
-	memcpy(&m_data[currentOffset], &nb, sizeof(uint16_t));
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+size+2);
+	memcpy(&data[currentOffset], &nb, sizeof(uint16_t));
 	currentOffset += sizeof(uint16_t);
 	for (auto &it : _value) {
-		memcpy(&m_data[currentOffset], &it[0], it.size());
+		memcpy(&data[currentOffset], &it[0], it.size());
 		currentOffset += it.size();
-		m_data[currentOffset] = '\0';
+		data[currentOffset] = '\0';
 		currentOffset++;
 	}
+	m_parameter.push_back(std::make_pair(2,data));
 }
 
 template<>
 void zeus::Buffer::addParameter<std::vector<bool>>(const std::vector<bool>& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('v');
-	m_data.push_back('e');
-	m_data.push_back('c');
-	m_data.push_back('t');
-	m_data.push_back('o');
-	m_data.push_back('r');
-	m_data.push_back(':');
-	m_data.push_back('b');
-	m_data.push_back('o');
-	m_data.push_back('o');
-	m_data.push_back('l');
-	m_data.push_back('\0');
+	std::vector<uint8_t> data;
+	addType(data, createType<std::vector<bool>>());
 	// add size:
 	uint16_t nb = _value.size();
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+_value.size());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+_value.size());
 	for (const auto &it : _value) {
 		if (it == true) {
-			m_data[currentOffset] = 'T';
+			data[currentOffset] = 'T';
 		} else {
-			m_data[currentOffset] = 'F';
+			data[currentOffset] = 'F';
 		}
 		currentOffset++;
 	}
+	m_parameter.push_back(std::make_pair(2,data));
 }
 
 template<>
 void zeus::Buffer::addParameter<std::vector<int8_t>>(const std::vector<int8_t>& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('v');
-	m_data.push_back('e');
-	m_data.push_back('c');
-	m_data.push_back('t');
-	m_data.push_back('o');
-	m_data.push_back('r');
-	m_data.push_back(':');
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('8');
-	m_data.push_back('\0');
+	std::vector<uint8_t> data;
+	addType(data, createType<std::vector<int8_t>>());
 	// add size:
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+_value.size());
-	memcpy(&m_data[currentOffset], &_value[0], sizeof(int8_t)*_value.size());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+_value.size());
+	memcpy(&data[currentOffset], &_value[0], sizeof(int8_t)*_value.size());
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<std::vector<int16_t>>(const std::vector<int16_t>& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('v');
-	m_data.push_back('e');
-	m_data.push_back('c');
-	m_data.push_back('t');
-	m_data.push_back('o');
-	m_data.push_back('r');
-	m_data.push_back(':');
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('1');
-	m_data.push_back('6');
-	m_data.push_back('\0');
+	std::vector<uint8_t> data;
+	addType(data, createType<std::vector<int16_t>>());
 	// add size:
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+_value.size());
-	memcpy(&m_data[currentOffset], &_value[0], sizeof(int16_t)*_value.size());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+_value.size());
+	memcpy(&data[currentOffset], &_value[0], sizeof(int16_t)*_value.size());
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<std::vector<int32_t>>(const std::vector<int32_t>& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('v');
-	m_data.push_back('e');
-	m_data.push_back('c');
-	m_data.push_back('t');
-	m_data.push_back('o');
-	m_data.push_back('r');
-	m_data.push_back(':');
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('3');
-	m_data.push_back('2');
-	m_data.push_back('\0');
+	std::vector<uint8_t> data;
+	addType(data, createType<std::vector<int32_t>>());
 	// add size:
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+_value.size());
-	memcpy(&m_data[currentOffset], &_value[0], sizeof(int32_t)*_value.size());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+_value.size());
+	memcpy(&data[currentOffset], &_value[0], sizeof(int32_t)*_value.size());
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<std::vector<int64_t>>(const std::vector<int64_t>& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('v');
-	m_data.push_back('e');
-	m_data.push_back('c');
-	m_data.push_back('t');
-	m_data.push_back('o');
-	m_data.push_back('r');
-	m_data.push_back(':');
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('6');
-	m_data.push_back('4');
-	m_data.push_back('\0');
+	std::vector<uint8_t> data;
+	addType(data, createType<std::vector<int64_t>>());
 	// add size:
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+_value.size());
-	memcpy(&m_data[currentOffset], &_value[0], sizeof(int64_t)*_value.size());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+_value.size());
+	memcpy(&data[currentOffset], &_value[0], sizeof(int64_t)*_value.size());
+	m_parameter.push_back(std::make_pair(2,data));
 }
-
 template<>
 void zeus::Buffer::addParameter<std::vector<uint8_t>>(const std::vector<uint8_t>& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('v');
-	m_data.push_back('e');
-	m_data.push_back('c');
-	m_data.push_back('t');
-	m_data.push_back('o');
-	m_data.push_back('r');
-	m_data.push_back(':');
-	m_data.push_back('u');
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('8');
-	m_data.push_back('\0');
+	std::vector<uint8_t> data;
+	addType(data, createType<std::vector<uint8_t>>());
 	// add size:
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+_value.size());
-	memcpy(&m_data[currentOffset], &_value[0], sizeof(uint8_t)*_value.size());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+_value.size());
+	memcpy(&data[currentOffset], &_value[0], sizeof(uint8_t)*_value.size());
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<std::vector<uint16_t>>(const std::vector<uint16_t>& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('v');
-	m_data.push_back('e');
-	m_data.push_back('c');
-	m_data.push_back('t');
-	m_data.push_back('o');
-	m_data.push_back('r');
-	m_data.push_back(':');
-	m_data.push_back('u');
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('1');
-	m_data.push_back('6');
-	m_data.push_back('\0');
+	std::vector<uint8_t> data;
+	addType(data, createType<std::vector<uint16_t>>());
 	// add size:
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+_value.size());
-	memcpy(&m_data[currentOffset], &_value[0], sizeof(uint16_t)*_value.size());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+_value.size());
+	memcpy(&data[currentOffset], &_value[0], sizeof(uint16_t)*_value.size());
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<std::vector<uint32_t>>(const std::vector<uint32_t>& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('v');
-	m_data.push_back('e');
-	m_data.push_back('c');
-	m_data.push_back('t');
-	m_data.push_back('o');
-	m_data.push_back('r');
-	m_data.push_back(':');
-	m_data.push_back('u');
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('3');
-	m_data.push_back('2');
-	m_data.push_back('\0');
+	std::vector<uint8_t> data;
+	addType(data, createType<std::vector<uint32_t>>());
 	// add size:
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+_value.size());
-	memcpy(&m_data[currentOffset], &_value[0], sizeof(uint32_t)*_value.size());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+_value.size());
+	memcpy(&data[currentOffset], &_value[0], sizeof(uint32_t)*_value.size());
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<std::vector<uint64_t>>(const std::vector<uint64_t>& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('v');
-	m_data.push_back('e');
-	m_data.push_back('c');
-	m_data.push_back('t');
-	m_data.push_back('o');
-	m_data.push_back('r');
-	m_data.push_back(':');
-	m_data.push_back('u');
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('6');
-	m_data.push_back('4');
-	m_data.push_back('\0');
+	std::vector<uint8_t> data;
+	addType(data, createType<std::vector<uint64_t>>());
 	// add size:
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+_value.size());
-	memcpy(&m_data[currentOffset], &_value[0], sizeof(uint64_t)*_value.size());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+_value.size());
+	memcpy(&data[currentOffset], &_value[0], sizeof(uint64_t)*_value.size());
+	m_parameter.push_back(std::make_pair(2,data));
 }
 
 template<>
 void zeus::Buffer::addParameter<std::vector<float>>(const std::vector<float>& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('v');
-	m_data.push_back('e');
-	m_data.push_back('c');
-	m_data.push_back('t');
-	m_data.push_back('o');
-	m_data.push_back('r');
-	m_data.push_back(':');
-	m_data.push_back('f');
-	m_data.push_back('l');
-	m_data.push_back('o');
-	m_data.push_back('a');
-	m_data.push_back('t');
-	m_data.push_back('\0');
+	std::vector<uint8_t> data;
+	addType(data, createType<std::vector<float>>());
 	// add size:
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+_value.size());
-	memcpy(&m_data[currentOffset], &_value[0], sizeof(float)*_value.size());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+_value.size());
+	memcpy(&data[currentOffset], &_value[0], sizeof(float)*_value.size());
+	m_parameter.push_back(std::make_pair(2,data));
 }
 
 template<>
 void zeus::Buffer::addParameter<std::vector<double>>(const std::vector<double>& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('v');
-	m_data.push_back('e');
-	m_data.push_back('c');
-	m_data.push_back('t');
-	m_data.push_back('o');
-	m_data.push_back('r');
-	m_data.push_back(':');
-	m_data.push_back('d');
-	m_data.push_back('o');
-	m_data.push_back('u');
-	m_data.push_back('b');
-	m_data.push_back('l');
-	m_data.push_back('e');
-	m_data.push_back('\0');
+	std::vector<uint8_t> data;
+	addType(data, createType<std::vector<double>>());
 	// add size:
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+_value.size());
-	memcpy(&m_data[currentOffset], &_value[0], sizeof(double)*_value.size());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+_value.size());
+	memcpy(&data[currentOffset], &_value[0], sizeof(double)*_value.size());
+	m_parameter.push_back(std::make_pair(2,data));
 }
 
 template<>
 void zeus::Buffer::addParameter<int8_t>(const int8_t& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('8');
-	m_data.push_back('\0');
-	m_data.push_back(uint8_t(_value));
+	std::vector<uint8_t> data;
+	addType(data, createType<int8_t>());
+	data.push_back(uint8_t(_value));
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<uint8_t>(const uint8_t& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('u');
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('8');
-	m_data.push_back('\0');
-	m_data.push_back(_value);
+	std::vector<uint8_t> data;
+	addType(data, createType<uint8_t>());
+	data.push_back(_value);
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<int16_t>(const int16_t& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('1');
-	m_data.push_back('6');
-	m_data.push_back('\0');
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+2);
-	memcpy(&m_data[currentOffset], &_value, 2);
+	std::vector<uint8_t> data;
+	addType(data, createType<int16_t>());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+2);
+	memcpy(&data[currentOffset], &_value, 2);
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<uint16_t>(const uint16_t& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('u');
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('1');
-	m_data.push_back('6');
-	m_data.push_back('\0');
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+2);
-	memcpy(&m_data[currentOffset], &_value, 2);
+	std::vector<uint8_t> data;
+	addType(data, createType<uint16_t>());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+2);
+	memcpy(&data[currentOffset], &_value, 2);
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<int32_t>(const int32_t& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('3');
-	m_data.push_back('2');
-	m_data.push_back('\0');
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+4);
-	memcpy(&m_data[currentOffset], &_value, 4);
+	std::vector<uint8_t> data;
+	addType(data, createType<int32_t>());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+4);
+	memcpy(&data[currentOffset], &_value, 4);
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<uint32_t>(const uint32_t& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('u');
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('3');
-	m_data.push_back('2');
-	m_data.push_back('\0');
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+4);
-	memcpy(&m_data[currentOffset], &_value, 4);
+	std::vector<uint8_t> data;
+	addType(data, createType<uint32_t>());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+4);
+	memcpy(&data[currentOffset], &_value, 4);
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<int64_t>(const int64_t& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('3');
-	m_data.push_back('2');
-	m_data.push_back('\0');
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+8);
-	memcpy(&m_data[currentOffset], &_value, 8);
+	std::vector<uint8_t> data;
+	addType(data, createType<int64_t>());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+8);
+	memcpy(&data[currentOffset], &_value, 8);
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<uint64_t>(const uint64_t& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('u');
-	m_data.push_back('i');
-	m_data.push_back('n');
-	m_data.push_back('t');
-	m_data.push_back('6');
-	m_data.push_back('4');
-	m_data.push_back('\0');
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+8);
-	memcpy(&m_data[currentOffset], &_value, 8);
+	std::vector<uint8_t> data;
+	addType(data, createType<uint64_t>());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+8);
+	memcpy(&data[currentOffset], &_value, 8);
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<float>(const float& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('f');
-	m_data.push_back('l');
-	m_data.push_back('o');
-	m_data.push_back('a');
-	m_data.push_back('t');
-	m_data.push_back('\0');
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+4);
-	memcpy(&m_data[currentOffset], &_value, 4);
+	std::vector<uint8_t> data;
+	addType(data, createType<float>());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+4);
+	memcpy(&data[currentOffset], &_value, 4);
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<double>(const double& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('d');
-	m_data.push_back('o');
-	m_data.push_back('u');
-	m_data.push_back('b');
-	m_data.push_back('l');
-	m_data.push_back('e');
-	m_data.push_back('\0');
-	currentOffset = m_data.size();
-	m_data.resize(m_data.size()+8);
-	memcpy(&m_data[currentOffset], &_value, 8);
+	std::vector<uint8_t> data;
+	addType(data, createType<double>());
+	int32_t currentOffset = data.size();
+	data.resize(data.size()+8);
+	memcpy(&data[currentOffset], &_value, 8);
+	m_parameter.push_back(std::make_pair(2,data));
 }
 template<>
 void zeus::Buffer::addParameter<bool>(const bool& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('b');
-	m_data.push_back('o');
-	m_data.push_back('o');
-	m_data.push_back('l');
-	m_data.push_back('\0');
+	std::vector<uint8_t> data;
+	addType(data, createType<bool>());
 	if (_value == true) {
-		m_data.push_back('T');
+		data.push_back('T');
 	} else {
-		m_data.push_back('F');
+		data.push_back('F');
 	}
+	m_parameter.push_back(std::make_pair(2,data));
 }
 
 template<>
 void zeus::Buffer::addParameter<zeus::File>(const zeus::File& _value) {
-	int32_t currentOffset = m_data.size();
-	m_paramOffset.push_back(currentOffset);
-	m_data.push_back('f');
-	m_data.push_back('i');
-	m_data.push_back('l');
-	m_data.push_back('e');
-	m_data.push_back('\0');
+	std::vector<uint8_t> data;
+	addType(data, createType<zeus::File>());
 	ZEUS_TODO("Send file in output ...");
+	m_parameter.push_back(std::make_pair(2,data));
 }
 
 template<>
 bool zeus::Buffer::internalGetParameter<bool>(int32_t _id) const {
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	if (createType<bool>() != type) {
@@ -783,7 +616,7 @@ bool zeus::Buffer::internalGetParameter<bool>(int32_t _id) const {
 template<>
 std::string zeus::Buffer::internalGetParameter<std::string>(int32_t _id) const {
 	std::string out;
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	out.resize(dataSize, 0);
@@ -794,7 +627,7 @@ std::string zeus::Buffer::internalGetParameter<std::string>(int32_t _id) const {
 
 template<>
 uint8_t zeus::Buffer::internalGetParameter<uint8_t>(int32_t _id) const {
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
@@ -834,7 +667,7 @@ uint8_t zeus::Buffer::internalGetParameter<uint8_t>(int32_t _id) const {
 }
 template<>
 uint16_t zeus::Buffer::internalGetParameter<uint16_t>(int32_t _id) const {
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
@@ -875,7 +708,7 @@ uint16_t zeus::Buffer::internalGetParameter<uint16_t>(int32_t _id) const {
 
 template<>
 uint32_t zeus::Buffer::internalGetParameter<uint32_t>(int32_t _id) const {
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
@@ -916,7 +749,7 @@ uint32_t zeus::Buffer::internalGetParameter<uint32_t>(int32_t _id) const {
 
 template<>
 uint64_t zeus::Buffer::internalGetParameter<uint64_t>(int32_t _id) const {
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
@@ -957,7 +790,7 @@ uint64_t zeus::Buffer::internalGetParameter<uint64_t>(int32_t _id) const {
 
 template<>
 int8_t zeus::Buffer::internalGetParameter<int8_t>(int32_t _id) const {
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
@@ -998,7 +831,7 @@ int8_t zeus::Buffer::internalGetParameter<int8_t>(int32_t _id) const {
 
 template<>
 int16_t zeus::Buffer::internalGetParameter<int16_t>(int32_t _id) const {
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
@@ -1039,7 +872,7 @@ int16_t zeus::Buffer::internalGetParameter<int16_t>(int32_t _id) const {
 
 template<>
 int32_t zeus::Buffer::internalGetParameter<int32_t>(int32_t _id) const {
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
@@ -1080,7 +913,7 @@ int32_t zeus::Buffer::internalGetParameter<int32_t>(int32_t _id) const {
 
 template<>
 int64_t zeus::Buffer::internalGetParameter<int64_t>(int32_t _id) const {
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
@@ -1121,7 +954,7 @@ int64_t zeus::Buffer::internalGetParameter<int64_t>(int32_t _id) const {
 
 template<>
 float zeus::Buffer::internalGetParameter<float>(int32_t _id) const {
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
@@ -1161,7 +994,7 @@ float zeus::Buffer::internalGetParameter<float>(int32_t _id) const {
 }
 template<>
 double zeus::Buffer::internalGetParameter<double>(int32_t _id) const {
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
@@ -1226,11 +1059,11 @@ double zeus::Buffer::internalGetParameter<double>(int32_t _id) const {
 template<>
 std::vector<uint8_t> zeus::Buffer::internalGetParameter<std::vector<uint8_t>>(int32_t _id) const {
 	std::vector<uint8_t> out;
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
-	if (type == "vector:empty") {
+	if (type == createType<std::vector<void>>()) {
 		return out;
 	} else if (createType<std::vector<uint8_t>>() == type) {
 		int32_t nbElement = dataSize / sizeof(uint8_t);
@@ -1316,11 +1149,11 @@ std::vector<uint8_t> zeus::Buffer::internalGetParameter<std::vector<uint8_t>>(in
 template<>
 std::vector<uint16_t> zeus::Buffer::internalGetParameter<std::vector<uint16_t>>(int32_t _id) const {
 	std::vector<uint16_t> out;
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
-	if (type == "vector:empty") {
+	if (type == createType<std::vector<void>>()) {
 		return out;
 	} else if (createType<std::vector<uint8_t>>() == type) {
 		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
@@ -1407,11 +1240,11 @@ std::vector<uint16_t> zeus::Buffer::internalGetParameter<std::vector<uint16_t>>(
 template<>
 std::vector<uint32_t> zeus::Buffer::internalGetParameter<std::vector<uint32_t>>(int32_t _id) const {
 	std::vector<uint32_t> out;
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
-	if (type == "vector:empty") {
+	if (type == createType<std::vector<void>>()) {
 		return out;
 	} else if (createType<std::vector<uint8_t>>() == type) {
 		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
@@ -1498,11 +1331,11 @@ std::vector<uint32_t> zeus::Buffer::internalGetParameter<std::vector<uint32_t>>(
 template<>
 std::vector<uint64_t> zeus::Buffer::internalGetParameter<std::vector<uint64_t>>(int32_t _id) const {
 	std::vector<uint64_t> out;
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
-	if (type == "vector:empty") {
+	if (type == createType<std::vector<void>>()) {
 		return out;
 	} else if (createType<std::vector<uint8_t>>() == type) {
 		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
@@ -1589,11 +1422,11 @@ std::vector<uint64_t> zeus::Buffer::internalGetParameter<std::vector<uint64_t>>(
 template<>
 std::vector<int8_t> zeus::Buffer::internalGetParameter<std::vector<int8_t>>(int32_t _id) const {
 	std::vector<int8_t> out;
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
-	if (type == "vector:empty") {
+	if (type == createType<std::vector<void>>()) {
 		return out;
 	} else if (createType<std::vector<uint8_t>>() == type) {
 		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
@@ -1680,11 +1513,11 @@ std::vector<int8_t> zeus::Buffer::internalGetParameter<std::vector<int8_t>>(int3
 template<>
 std::vector<int16_t> zeus::Buffer::internalGetParameter<std::vector<int16_t>>(int32_t _id) const {
 	std::vector<int16_t> out;
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
-	if (type == "vector:empty") {
+	if (type == createType<std::vector<void>>()) {
 		return out;
 	} else if (createType<std::vector<uint8_t>>() == type) {
 		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
@@ -1771,11 +1604,11 @@ std::vector<int16_t> zeus::Buffer::internalGetParameter<std::vector<int16_t>>(in
 template<>
 std::vector<int32_t> zeus::Buffer::internalGetParameter<std::vector<int32_t>>(int32_t _id) const {
 	std::vector<int32_t> out;
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
-	if (type == "vector:empty") {
+	if (type == createType<std::vector<void>>()) {
 		return out;
 	} else if (createType<std::vector<uint8_t>>() == type) {
 		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
@@ -1862,11 +1695,11 @@ std::vector<int32_t> zeus::Buffer::internalGetParameter<std::vector<int32_t>>(in
 template<>
 std::vector<int64_t> zeus::Buffer::internalGetParameter<std::vector<int64_t>>(int32_t _id) const {
 	std::vector<int64_t> out;
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
-	if (type == "vector:empty") {
+	if (type == createType<std::vector<void>>()) {
 		return out;
 	} else if (createType<std::vector<uint8_t>>() == type) {
 		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
@@ -1953,11 +1786,11 @@ std::vector<int64_t> zeus::Buffer::internalGetParameter<std::vector<int64_t>>(in
 template<>
 std::vector<float> zeus::Buffer::internalGetParameter<std::vector<float>>(int32_t _id) const {
 	std::vector<float> out;
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
-	if (type == "vector:empty") {
+	if (type == createType<std::vector<void>>()) {
 		return out;
 	} else if (createType<std::vector<uint8_t>>() == type) {
 		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
@@ -2044,11 +1877,11 @@ std::vector<float> zeus::Buffer::internalGetParameter<std::vector<float>>(int32_
 template<>
 std::vector<double> zeus::Buffer::internalGetParameter<std::vector<double>>(int32_t _id) const {
 	std::vector<double> out;
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
-	if (type == "vector:empty") {
+	if (type == createType<std::vector<void>>()) {
 		return out;
 	} else if (createType<std::vector<uint8_t>>() == type) {
 		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
@@ -2135,11 +1968,11 @@ std::vector<double> zeus::Buffer::internalGetParameter<std::vector<double>>(int3
 template<>
 std::vector<bool> zeus::Buffer::internalGetParameter<std::vector<bool>>(int32_t _id) const {
 	std::vector<bool> out;
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
-	if (type == "vector:empty") {
+	if (type == createType<std::vector<void>>()) {
 		return out;
 	} else if (createType<std::vector<bool>>() == type) {
 		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
@@ -2157,10 +1990,10 @@ std::vector<bool> zeus::Buffer::internalGetParameter<std::vector<bool>>(int32_t
 template<>
 std::vector<std::string> zeus::Buffer::internalGetParameter<std::vector<std::string>>(int32_t _id) const {
 	std::vector<std::string> out;
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
-	if (type == "vector:empty") {
+	if (type == createType<std::vector<void>>()) {
 		return out;
 	} else if (createType<std::vector<std::string>>() == type) {
 		// first element is the number of elements:
@@ -2184,7 +2017,7 @@ std::vector<std::string> zeus::Buffer::internalGetParameter<std::vector<std::str
 template<>
 zeus::File zeus::Buffer::internalGetParameter<zeus::File>(int32_t _id) const {
 	zeus::File out;
-	std::string type = internalGetParameterType(_id);
+	zeus::ParamType type = internalGetParameterType(_id);
 	const uint8_t* pointer = internalGetParameterPointer(_id);
 	uint32_t dataSize = internalGetParameterSize(_id);
 	// TODO : Check size ...
@@ -2230,29 +2063,21 @@ std::string zeus::Buffer::getCall() const {
 }
 
 void zeus::Buffer::setCall(std::string _value) {
-	if (m_paramOffset.size() != 0) {
+	if (m_parameter.size() != 0) {
 		ZEUS_ERROR("Clear Buffer of parameter ==> set the call type in first ...");
-		m_paramOffset.clear();
-		m_data.clear();
+		m_parameter.clear();
 	}
 	addParameter(_value);
 }
 
-uint64_t zeus::Buffer::prepare() {
-	m_header.numberOfParameter = m_paramOffset.size();
-	uint64_t size = sizeof(headerBin);
-	size += m_paramOffset.size() * sizeof(uint16_t); // param list
-	size += m_data.size();
-	return size;
-}
 
 bool zeus::Buffer::hasError() {
 	if (getType() != zeus::Buffer::typeMessage::answer) {
 		return false;
 	}
-	if (m_paramOffset.size() == 2) {
+	if (m_parameter.size() == 2) {
 		return true;
-	} else if (m_paramOffset.size() == 3) {
+	} else if (m_parameter.size() == 3) {
 		return true;
 	}
 	return false;
@@ -2262,9 +2087,9 @@ std::string zeus::Buffer::getError() {
 	if (getType() != zeus::Buffer::typeMessage::answer) {
 		return "";
 	}
-	if (m_paramOffset.size() == 2) {
+	if (m_parameter.size() == 2) {
 		return getParameter<std::string>(0);
-	} else if (m_paramOffset.size() == 3) {
+	} else if (m_parameter.size() == 3) {
 		return getParameter<std::string>(1);
 	}
 	return "";
@@ -2274,11 +2099,28 @@ std::string zeus::Buffer::getErrorHelp() {
 	if (getType() != zeus::Buffer::typeMessage::answer) {
 		return "";
 	}
-	if (m_paramOffset.size() == 2) {
+	if (m_parameter.size() == 2) {
 		return getParameter<std::string>(1);
-	} else if (m_paramOffset.size() == 3) {
+	} else if (m_parameter.size() == 3) {
 		return getParameter<std::string>(2);
 	}
 	return "";
 }
 
+
+std::string zeus::Buffer::simpleStringParam(uint32_t _id) const {
+	zeus::ParamType paramType = internalGetParameterType(_id);
+	if (paramType.isVector() == false) {
+		if (paramType.isNumber() == true) {
+			return etk::to_string(internalGetParameter<int64_t>(_id));
+		}
+	}
+	if (paramType == createType<bool>()) {
+		return etk::to_string(internalGetParameter<bool>(_id));
+	}
+	if (paramType == createType<std::string>()) {
+		return internalGetParameter<std::string>(_id);
+	}
+	return paramType.getName();
+}
+
diff --git a/zeus/Buffer.h b/zeus/Buffer.h
index 03160a0..342edab 100644
--- a/zeus/Buffer.h
+++ b/zeus/Buffer.h
@@ -5,17 +5,19 @@
  */
 #pragma once
 #include <etk/types.h>
+#include <enet/WebSocket.h>
+#include <zeus/ParamType.h>
 
 namespace zeus {
 	//U32 message lenght
 	#pragma pack(push,1)
 	struct headerBin {
-		uint16_t versionProtocol; // protocol Version (might be 1)
+		//uint16_t versionProtocol; // protocol Version (might be 1)
 		uint32_t transactionID;
 		uint32_t clientID; // same as sevice ID
 		int16_t partID; // if < 0 the partId ifs the last (start at 0 if multiple or 0x8000 if single message)
 		uint16_t typeMessage; //TypeMessgae (1:call, 2:Answer, 4:event)
-		uint16_t numberOfParameter; //TypeMessgae (1:call, 2:Answer, 4:event)
+		uint16_t numberOfParameter;
 	};
 	#pragma pack(pop)
 	/*
@@ -82,27 +84,7 @@ namespace zeus {
 	class Buffer {
 		private:
 			headerBin m_header;
-			std::vector<uint16_t> m_paramOffset;
-			std::vector<uint8_t> m_data;
-		public:
-			const uint8_t* getHeader() const {
-				return reinterpret_cast<const uint8_t*>(&m_header);
-			}
-			uint32_t getHeaderSize() const {
-				return sizeof(headerBin);
-			}
-			const uint8_t* getParam() const {
-				return reinterpret_cast<const uint8_t*>(&m_paramOffset[0]);
-			}
-			uint32_t getParamSize() const {
-				return m_paramOffset.size() * 2;
-			}
-			const uint8_t* getData() const {
-				return &m_data[0];
-			}
-			uint32_t getDataSize() const {
-				return m_data.size();
-			}
+			mutable std::vector<std::pair<int32_t,std::vector<uint8_t>>> m_parameter;
 		private:
 			void internalComposeWith(const uint8_t* _buffer, uint32_t _lenght);
 		public:
@@ -111,8 +93,6 @@ namespace zeus {
 			void composeWith(const std::string& _buffer);
 			std::string generateHumanString();
 			void clear();
-			uint16_t getProtocalVersion() const;
-			void setProtocolVersion(uint16_t _value);
 			uint32_t getTransactionId() const;
 			void setTransactionId(uint32_t _value);
 			uint32_t getClientId() const;// this is the same as serviceId
@@ -129,10 +109,10 @@ namespace zeus {
 			bool getPartFinish() const;
 			void setPartFinish(bool _value);
 			enum class typeMessage {
-				call = 0x0001,
-				answer = 0x0002,
-				event = 0x0004,
-				data = 0x0008,
+				call = 0x0001, // Remote call on a service ID
+				answer = 0x0002, // Answer from a previous call
+				data = 0x0003, // data message happend when partId > 0 it compleate the data of a parameter or an answer or an event
+				event = 0x0004, // event message
 			};
 			enum typeMessage getType() const;
 			void setType(enum typeMessage _value);
@@ -143,14 +123,15 @@ namespace zeus {
 		private:
 			template<class ZEUS_TYPE_DATA>
 			ZEUS_TYPE_DATA internalGetParameter(int32_t _id) const;
-			std::string internalGetParameterType(int32_t _id) const;
+			zeus::ParamType internalGetParameterType(int32_t _id) const;
 			const uint8_t* internalGetParameterPointer(int32_t _id) const;
 			uint32_t internalGetParameterSize(int32_t _id) const;
+			std::string simpleStringParam(uint32_t _id) const;
 		public:
 			std::string getCall() const;
 			void setCall(std::string _value);
 			uint16_t getNumberParameter() const;
-			std::string getParameterType(int32_t _id) const;
+			zeus::ParamType getParameterType(int32_t _id) const;
 			const uint8_t* getParameterPointer(int32_t _id) const;
 			uint32_t getParameterSize(int32_t _id) const;
 			
@@ -188,7 +169,7 @@ namespace zeus {
 			//multiple section of data (part ...)
 			void addData(void* _data, uint32_t _size);
 		
-			uint64_t prepare();
+			bool writeOn(enet::WebSocket& _interface);
 	};
 	std::ostream& operator <<(std::ostream& _os, enum zeus::Buffer::typeMessage _value);
 }
diff --git a/zeus/GateWayService.cpp b/zeus/GateWayService.cpp
index cc9a570..96dc4f7 100644
--- a/zeus/GateWayService.cpp
+++ b/zeus/GateWayService.cpp
@@ -45,12 +45,10 @@ void zeus::GateWayService::stop() {
 
 void zeus::GateWayService::SendData(uint64_t _userSessionId, zeus::Buffer& _data) {
 	_data.setClientId(_userSessionId);
-	_data.prepare();
 	m_interfaceClient.writeBinary(_data);
 }
 
 void zeus::GateWayService::onServiceData(zeus::Buffer& _value) {
-	ZEUS_DEBUG("On service data: " << _value.generateHumanString());
 	uint32_t transactionId = _value.getTransactionId();
 	//data.add("from-service", ejson::String(m_name));
 	if (_value.getType() == zeus::Buffer::typeMessage::event) {
diff --git a/zeus/ParamType.cpp b/zeus/ParamType.cpp
index 8ab4c71..721092e 100644
--- a/zeus/ParamType.cpp
+++ b/zeus/ParamType.cpp
@@ -8,18 +8,58 @@
 #include <zeus/debug.h>
 #include <zeus/File.h>
 
+std::ostream& zeus::operator <<(std::ostream& _os, const zeus::ParamType& _obj) {
+	_os << "{" << _obj.getId() << ":" << _obj.getName() << "}";
+	return _os;
+}
 
-zeus::ParamType::ParamType(const char* _name):
-  m_typeName(_name) {
+zeus::ParamType::ParamType(const char* _name, uint16_t _id, bool _isNumber, bool _isVector):
+  m_typeName(_name),
+  m_id(_id),
+  m_isNumber(_isNumber),
+  m_isVector(_isVector) {
+	
+}
+zeus::ParamType::ParamType(const std::string& _name, uint16_t _id, bool _isNumber, bool _isVector):
+  m_typeName(_name),
+  m_id(_id),
+  m_isNumber(_isNumber),
+  m_isVector(_isVector) {
 	
 }
 
-const char* zeus::ParamType::getName() const {
+bool zeus::ParamType::isNumber() const {
+	return m_isNumber;
+}
+
+bool zeus::ParamType::isVector() const {
+	return m_isVector;
+}
+const std::string& zeus::ParamType::getName() const {
 	return m_typeName;
 }
 
+uint16_t zeus::ParamType::getId() const {
+	return m_id;
+}
+
 bool zeus::ParamType::operator == (const ParamType& _obj) const {
-	return m_typeName == _obj.m_typeName;
+	if (m_id != _obj.m_id) {
+		return false;
+	}
+	if (m_id == paramTypeObject) {
+		return m_typeName == _obj.m_typeName;
+	}
+	return true;
+}
+bool zeus::ParamType::operator != (const ParamType& _obj) const {
+	if (m_id != _obj.m_id) {
+		return true;
+	}
+	if (m_id == paramTypeObject) {
+		return m_typeName != _obj.m_typeName;
+	}
+	return false;
 }
 
 bool zeus::ParamType::operator == (const std::string& _value) const {
@@ -29,43 +69,52 @@ bool zeus::ParamType::operator != (const std::string& _value) const {
 	return _value != m_typeName;
 }
 
-#define generate_basic_type(_type, _name) \
+bool zeus::ParamType::operator == (const uint16_t& _value) const {
+	return _value == m_id;
+}
+
+bool zeus::ParamType::operator != (const uint16_t& _value) const {
+	return _value != m_id;
+}
+
+#define generate_basic_type(_type, _name, _id, _num, _vect) \
 namespace zeus { \
 	template<> zeus::ParamType createType<_type>() {\
-		return zeus::ParamType(_name); \
+		return zeus::ParamType(_name, _id, _num, _vect); \
 	} \
 }
 
-generate_basic_type(void, "void");
-generate_basic_type(bool, "bool");
-generate_basic_type(float, "float");
-generate_basic_type(double, "double");
-generate_basic_type(int64_t, "int64");
-generate_basic_type(int32_t, "int32");
-generate_basic_type(int16_t, "int16");
-generate_basic_type(int8_t, "int8");
-generate_basic_type(uint64_t, "uint64");
-generate_basic_type(uint32_t, "uint32");
-generate_basic_type(uint16_t, "uint16");
-generate_basic_type(uint8_t, "uint8");
-generate_basic_type(std::string, "string");
+generate_basic_type(void, "void", 0x1, false, false);
+generate_basic_type(bool, "bool", 0x2, false, false);
+generate_basic_type(float, "float", 0x3, true, false);
+generate_basic_type(double, "double", 0x4, true, false);
+generate_basic_type(int64_t, "int64", 0x5, true, false);
+generate_basic_type(int32_t, "int32", 0x6, true, false);
+generate_basic_type(int16_t, "int16", 0x7, true, false);
+generate_basic_type(int8_t, "int8", 0x8, true, false);
+generate_basic_type(uint64_t, "uint64", 0x9, true, false);
+generate_basic_type(uint32_t, "uint32", 0xA, true, false);
+generate_basic_type(uint16_t, "uint16", 0xB, true, false);
+generate_basic_type(uint8_t, "uint8", 0xC, true, false);
+generate_basic_type(std::string, "string", 0xD, false, false);
 
 
-generate_basic_type(std::vector<bool>, "vector:bool");
-generate_basic_type(std::vector<float>, "vector:float");
-generate_basic_type(std::vector<double>, "vector:double");
-generate_basic_type(std::vector<int64_t>, "vector:int64");
-generate_basic_type(std::vector<int32_t>, "vector:int32");
-generate_basic_type(std::vector<int16_t>, "vector:int16");
-generate_basic_type(std::vector<int8_t>, "vector:int8");
-generate_basic_type(std::vector<uint64_t>, "vector:uint64");
-generate_basic_type(std::vector<uint32_t>, "vector:uint32");
-generate_basic_type(std::vector<uint16_t>, "vector:uint16");
-generate_basic_type(std::vector<uint8_t>, "vector:uint8");
-generate_basic_type(std::vector<std::string>, "vector:string");
+generate_basic_type(std::vector<void>, "vector:empty", 0x0102, true, true);
+generate_basic_type(std::vector<bool>, "vector:bool", 0x0102, false, true);
+generate_basic_type(std::vector<float>, "vector:float", 0x0103, true, true);
+generate_basic_type(std::vector<double>, "vector:double", 0x0104, true, true);
+generate_basic_type(std::vector<int64_t>, "vector:int64", 0x0105, true, true);
+generate_basic_type(std::vector<int32_t>, "vector:int32", 0x0106, true, true);
+generate_basic_type(std::vector<int16_t>, "vector:int16", 0x0107, true, true);
+generate_basic_type(std::vector<int8_t>, "vector:int8", 0x0108, true, true);
+generate_basic_type(std::vector<uint64_t>, "vector:uint64", 0x0109, true, true);
+generate_basic_type(std::vector<uint32_t>, "vector:uint32", 0x010A, true, true);
+generate_basic_type(std::vector<uint16_t>, "vector:uint16", 0x010B, true, true);
+generate_basic_type(std::vector<uint8_t>, "vector:uint8", 0x010C, true, true);
+generate_basic_type(std::vector<std::string>, "vector:string", 0x010D, false, true);
 
+generate_basic_type(zeus::File, "file", 0x000E, false, false);
+generate_basic_type(zeus::FileServer, "file", 0x000E, false, false);
 
-generate_basic_type(zeus::File, "file");
-generate_basic_type(zeus::FileServer, "file");
-
+const uint16_t zeus::paramTypeObject = 0xFFFF;
 
diff --git a/zeus/ParamType.h b/zeus/ParamType.h
index 6f0543f..114625b 100644
--- a/zeus/ParamType.h
+++ b/zeus/ParamType.h
@@ -10,15 +10,26 @@
 namespace zeus {
 	class ParamType {
 		protected:
-			const char* m_typeName;
+			const std::string m_typeName;
+			const uint16_t m_id;
+			const bool m_isNumber;
+			const bool m_isVector;
 		public:
-			ParamType(const char* _name = "");
-			const char* getName() const;
+			ParamType(const char* _name = "", uint16_t _id=0, bool _isNumber=false, bool _isVector=false);
+			ParamType(const std::string& _name, uint16_t _id, bool _isNumber=false, bool _isVector=false);
+			const std::string& getName() const;
+			uint16_t getId() const;
 			bool operator == (const ParamType& _obj) const;
+			bool operator != (const ParamType& _obj) const;
 			bool operator == (const std::string& _value) const;
 			bool operator != (const std::string& _value) const;
+			bool operator == (const uint16_t& _value) const;
+			bool operator != (const uint16_t& _value) const;
+			bool isNumber() const;
+			bool isVector() const;
 	};
-	
+	extern const uint16_t paramTypeObject;
+	std::ostream& operator <<(std::ostream& _os, const zeus::ParamType& _obj);
 	
 	template<class ZEUS_TYPE>
 	ParamType createType();
diff --git a/zeus/TcpString.cpp b/zeus/TcpString.cpp
index 65f8980..2f8d74d 100644
--- a/zeus/TcpString.cpp
+++ b/zeus/TcpString.cpp
@@ -32,7 +32,10 @@ void zeus::TcpString::setInterface(enet::Tcp _connection, bool _isServer) {
 		m_connection.connectUri(this, &zeus::TcpString::onReceiveUri);
 		m_connection.start();
 	} else {
-		m_connection.start("/stupidName");
+		std::vector<std::string> protocols;
+		protocols.push_back("zeus/0.8");
+		protocols.push_back("zeus/1.0");
+		m_connection.start("/stupidName", protocols);
 	}
 }
 
@@ -88,30 +91,23 @@ void zeus::TcpString::disconnect(bool _inThreadStop){
 }
 
 int32_t zeus::TcpString::writeBinary(zeus::Buffer& _data) {
-	uint64_t size = _data.prepare();
-	ZEUS_DEBUG("Send BINARY " << size << " bytes '" << _data.generateHumanString() << "'");
 	if (m_connection.isAlive() == false) {
 		return -2;
 	}
-	if (m_connection.writeHeader(size, false) == false) {
-		return -1;
+	if (_data.writeOn(m_connection) == true) {
+		return 1;
 	}
-	uint8_t* data = nullptr;
-	uint32_t dataSize = 0;
-	data = (uint8_t*)_data.getHeader();
-	dataSize = _data.getHeaderSize();
-	size = m_connection.writeData(data, dataSize);
-	data = (uint8_t*)_data.getParam();
-	dataSize = _data.getParamSize();
-	size += m_connection.writeData(data, dataSize);
-	data = (uint8_t*)_data.getData();
-	dataSize = _data.getDataSize();
-	size += m_connection.writeData(data, dataSize);
-	return size;
+	return -1;
 }
 
-bool zeus::TcpString::onReceiveUri(const std::string& _uri) {
+bool zeus::TcpString::onReceiveUri(const std::string& _uri, const std::vector<std::string>& _protocols) {
 	ZEUS_INFO("Receive Header uri: " << _uri);
+	for (auto &it : _protocols) {
+		if (it == "zeus/1.0") {
+			m_connection.setProtocol(it);
+			break;
+		}
+	}
 	if (_uri == "/stupidName") {
 		return true;
 	}
@@ -264,10 +260,10 @@ class SendAsyncBinary {
 };
 
 zeus::FutureBase zeus::TcpString::callBinary(uint64_t _transactionId,
-                                           zeus::Buffer& _obj,
-                                           const std::vector<ActionAsyncClient>& _async,
-                                           zeus::FutureData::ObserverFinish _callback,
-                                           const uint32_t& _serviceId) {
+                                             zeus::Buffer& _obj,
+                                             const std::vector<ActionAsyncClient>& _async,
+                                             zeus::FutureData::ObserverFinish _callback,
+                                             const uint32_t& _serviceId) {
 	ZEUS_VERBOSE("Send Binary [START] ");
 	if (isActive() == false) {
 		zeus::Buffer obj;
diff --git a/zeus/TcpString.h b/zeus/TcpString.h
index e8b0602..814b08c 100644
--- a/zeus/TcpString.h
+++ b/zeus/TcpString.h
@@ -49,8 +49,7 @@ namespace zeus {
 			void setInterfaceName(const std::string& _name);
 			int32_t writeBinary(zeus::Buffer& _data);
 			void ping();
-		private:
-			bool onReceiveUri(const std::string& _uri);
+			bool onReceiveUri(const std::string& _uri, const std::vector<std::string>& _protocols);
 			void onReceiveData(std::vector<uint8_t>& _frame, bool _isBinary);
 			void newBuffer(zeus::Buffer& _buffer);
 		public: