diff --git a/doc/features/datatypes/README.md b/doc/features/datatypes/README.md
index da554ac0..fec28e5d 100644
--- a/doc/features/datatypes/README.md
+++ b/doc/features/datatypes/README.md
@@ -29,7 +29,7 @@ tuple|[Tuple](tuples)
 uuid|[Uuid](uuids)
 varchar|String
 varint|[Integer](numerical)
-vector|[Float32Array](collections)
+vector|[Vector](collections)
 
 ## Encoding data 
 
diff --git a/doc/features/datatypes/collections/README.md b/doc/features/datatypes/collections/README.md
index 879d7dc2..a7a18134 100644
--- a/doc/features/datatypes/collections/README.md
+++ b/doc/features/datatypes/collections/README.md
@@ -73,8 +73,7 @@ client.execute('SELECT map_val FROM tbl')
 
 ### Vector
 
-As of version 4.7.0 the driver also includes support for the vector type available in Cassandra 5.0.  Vectors are represented as instances of
-the [Float32Array] class.  For example, to create and write to a vector with three dimensions you can do the following:
+The driver supports vectors of arbitrary subtypes available in Apache Cassandra 5.0. Vectors are represented as instances of `cassandra.types.Vector` class. For example, to create and write to a vector with three dimensions you can do the following:
 
 ```javascript
 await c.connect()
@@ -84,8 +83,10 @@ await c.connect()
   .then(() => c.execute("create custom index ann_index on test.foo(j) using 'StorageAttachedIndex'"))
 
   // Base inserts using simple and prepared statements
-  .then(() => c.execute(`insert into test.foo (i, j) values (?, ?)`, [cassandra.types.Integer.fromInt(1), new Float32Array([8, 2.3, 58])]))
-  .then(() => c.execute(`insert into test.foo (i, j) values (?, ?)`, [cassandra.types.Integer.fromInt(5), new Float32Array([23, 18, 3.9])], {prepare: true}));
+  .then(() => c.execute(`insert into test.foo (i, j) values (?, ?)`, [cassandra.types.Integer.fromInt(1), new cassandra.types.Vector([8, 2.3, 58], 'float')]))
+  .then(() => c.execute(`insert into test.foo (i, j) values (?, ?)`, [cassandra.types.Integer.fromInt(5), new cassandra.types.Vector([23, 18, 3.9])], {prepare: true}));
 ```
 
+In driver versions 4.7.0 - 4.7.2, the vector of floats was represented as a [Float32Array]. This is still supported for backward compatibility, but it is deprecated, and it is recommended to use the `cassandra.types.Vector` class instead.
+
 [Float32Array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float32Array
diff --git a/index.d.ts b/index.d.ts
index cf44d76e..90f2b6c3 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -349,6 +349,10 @@ export namespace errors {
     constructor(address: string, maxRequestsPerConnection: number, connectionLength: number);
   }
 
+  class VIntOutOfRangeException extends DriverError {
+    constructor(long: Long);
+  }
+
   abstract class DriverError extends Error {
     info: string;
 
diff --git a/lib/encoder.js b/lib/encoder.js
index 74219f77..7a78754d 100644
--- a/lib/encoder.js
+++ b/lib/encoder.js
@@ -26,6 +26,7 @@ const utils = require('./utils');
 const token = require('./token');
 const { DateRange } = require('./datastax/search');
 const geo = require('./geometry');
+const Vector = require('./types/vector');
 const Geometry = geo.Geometry;
 const LineString = geo.LineString;
 const Point = geo.Point;
@@ -94,6 +95,8 @@ const singleTypeNames = Object.freeze({
   'org.apache.cassandra.db.marshal.IntegerType':        dataTypes.varint,
   'org.apache.cassandra.db.marshal.CounterColumnType':  dataTypes.counter
 });
+
+// eslint-disable-next-line no-unused-vars
 const singleTypeNamesByDataType = invertObject(singleTypeNames);
 const singleFqTypeNamesLength = Object.keys(singleTypeNames).reduce(function (previous, current) {
   return current.length > previous ? current.length : previous;
@@ -125,10 +128,26 @@ const zeroLengthTypesSupported = new Set([
   dataTypes.blob
 ]);
 
+/**
+ * @typedef {(singleTypeNames[keyof singleTypeNames] | types.dataTypes.duration | types.dataTypes.text)} SingleTypeCodes
+ * @typedef {('point' | 'polygon' | 'duration' | 'lineString' | 'dateRange')} CustomSimpleTypeCodes
+ * @typedef {(customTypeNames[CustomSimpleTypeCodes]) | CustomSimpleTypeCodes | 'empty'} CustomSimpleTypeNames
+ * @typedef {{code : SingleTypeCodes, info?: null, options? : {frozen?:boolean, reversed?:boolean} }} SingleColumnInfo
+ * @typedef {{code : (types.dataTypes.custom), info : CustomSimpleTypeNames, options? : {frozen?:boolean, reversed?:boolean}}} CustomSimpleColumnInfo
+ * @typedef {{code : (types.dataTypes.map), info : [ColumnInfo, ColumnInfo], options?: {frozen?: Boolean, reversed?: Boolean}}} MapColumnInfo
+ * @typedef {{code : (types.dataTypes.tuple), info : Array<ColumnInfo>, options?: {frozen?: Boolean, reversed?: Boolean}}} TupleColumnInfo 
+ * @typedef {{code : (types.dataTypes.tuple | types.dataTypes.list)}} TupleListColumnInfoWithoutSubtype TODO: guessDataType can return null on tuple/list info, why?
+ * @typedef {{code : (types.dataTypes.list | types.dataTypes.set), info : ColumnInfo, options?: {frozen?: Boolean, reversed?: Boolean}}} ListSetColumnInfo
+ * @typedef {{code : (types.dataTypes.udt), info : {name : string, fields : Array<{name : string, type : ColumnInfo}>}, options? : {frozen?: Boolean, reversed?: Boolean}}} UdtColumnInfo
+ * @typedef {{code : (types.dataTypes.custom), customTypeName : ('vector'), info : [ColumnInfo, number], options? : {frozen?:boolean, reversed?:boolean}}} VectorColumnInfo
+ * @typedef {{code : (types.dataTypes.custom), info : string, options? : {frozen?:boolean, reversed?:boolean}}} OtherCustomColumnInfo
+ * @typedef {SingleColumnInfo | CustomSimpleColumnInfo | MapColumnInfo | TupleColumnInfo | ListSetColumnInfo | VectorColumnInfo | OtherCustomColumnInfo | UdtColumnInfo | TupleListColumnInfoWithoutSubtype} ColumnInfo If this is a simple type, info is null; if this is a collection type with a simple subtype, info is a string, if this is a nested collection type, info is a ColumnInfo object
+ */
+
 /**
  * Serializes and deserializes to and from a CQL type and a Javascript Type.
  * @param {Number} protocolVersion
- * @param {ClientOptions} options
+ * @param {import('./client.js').ClientOptions} options
  * @constructor
  */
 function Encoder(protocolVersion, options) {
@@ -188,23 +207,37 @@ function defineInstanceMembers() {
   this.decodeBlob = function (bytes) {
     return this.handleBuffer(bytes);
   };
-  this.decodeCustom = function (bytes, typeName) {
+
+  /**
+   * 
+   * @param {Buffer} bytes 
+   * @param {OtherCustomColumnInfo | VectorColumnInfo} columnInfo
+   * @returns 
+   */
+  this.decodeCustom = function (bytes, columnInfo) {
 
     // Make sure we actually have something to process in typeName before we go any further
-    if (!typeName || typeName.length === 0) {
+    if (!columnInfo) {
       return this.handleBuffer(bytes);
     }
 
     // Special handling for vector custom types (since they have args)
-    if (typeName.startsWith(customTypeNames.vector)) {
-      return this.decodeVector(bytes, this.parseVectorTypeArgs(typeName, customTypeNames.vector, this.parseFqTypeName));
+    if ('customTypeName' in columnInfo && columnInfo.customTypeName === 'vector') {
+      return this.decodeVector(bytes, columnInfo);
+    }
+
+    if(typeof columnInfo.info === 'string' && columnInfo.info.startsWith(customTypeNames.vector)) {
+      const vectorColumnInfo = /** @type {VectorColumnInfo} */ (this.parseFqTypeName(columnInfo.info));
+      return this.decodeVector(bytes, vectorColumnInfo);
     }
-    const handler = customDecoders[typeName];
+
+    const handler = customDecoders[columnInfo.info];
     if (handler) {
       return handler.call(this, bytes);
     }
     return this.handleBuffer(bytes);
   };
+
   this.decodeUtf8String = function (bytes) {
     return bytes.toString('utf8');
   };
@@ -283,7 +316,8 @@ function defineInstanceMembers() {
   /*
    * Reads a list from bytes
    */
-  this.decodeList = function (bytes, subtype) {
+  this.decodeList = function (bytes, columnInfo) {
+    const subtype = columnInfo.info;
     const totalItems = this.decodeCollectionLength(bytes, 0);
     let offset = this.collectionLengthSize;
     const list = new Array(totalItems);
@@ -300,8 +334,8 @@ function defineInstanceMembers() {
   /*
    * Reads a Set from bytes
    */
-  this.decodeSet = function (bytes, subtype) {
-    const arr = this.decodeList(bytes, subtype);
+  this.decodeSet = function (bytes, columnInfo) {
+    const arr = this.decodeList(bytes, columnInfo);
     if (this.encodingOptions.set) {
       const setConstructor = this.encodingOptions.set;
       return new setConstructor(arr);
@@ -311,7 +345,8 @@ function defineInstanceMembers() {
   /*
    * Reads a map (key / value) from bytes
    */
-  this.decodeMap = function (bytes, subtypes) {
+  this.decodeMap = function (bytes, columnInfo) {
+    const subtypes = columnInfo.info;
     let map;
     const totalItems = this.decodeCollectionLength(bytes, 0);
     let offset = this.collectionLengthSize;
@@ -358,10 +393,11 @@ function defineInstanceMembers() {
   /**
    * Decodes a user defined type into an object
    * @param {Buffer} bytes
-   * @param {{fields: Array}} udtInfo
+   * @param {UdtColumnInfo} columnInfo
    * @private
    */
-  this.decodeUdt = function (bytes, udtInfo) {
+  this.decodeUdt = function (bytes, columnInfo) {
+    const udtInfo = columnInfo.info;
     const result = {};
     let offset = 0;
     for (let i = 0; i < udtInfo.fields.length && offset < bytes.length; i++) {
@@ -380,7 +416,8 @@ function defineInstanceMembers() {
     return result;
   };
 
-  this.decodeTuple = function (bytes, tupleInfo) {
+  this.decodeTuple = function (bytes, columnInfo) {
+    const tupleInfo = columnInfo.info;
     const elements = new Array(tupleInfo.length);
     let offset = 0;
 
@@ -708,17 +745,29 @@ function defineInstanceMembers() {
     }
     return value;
   };
-  this.encodeCustom = function (value, customTypeName) {
 
-    // Special handling for vector custom types (since they have args)
-    if (customTypeName.startsWith(customTypeNames.vector)) {
-      return this.encodeVector(value, this.parseVectorTypeArgs(customTypeName, customTypeNames.vector, this.parseFqTypeName));
+  /**
+   * 
+   * @param {any} value 
+   * @param {OtherCustomColumnInfo | VectorColumnInfo} columnInfo
+   * @returns 
+   */
+  this.encodeCustom = function (value, columnInfo) {
+
+    if ('customTypeName' in columnInfo && columnInfo.customTypeName === 'vector') {
+      return this.encodeVector(value, columnInfo);
+    }
+
+    if(typeof columnInfo.info === 'string' && columnInfo.info.startsWith(customTypeNames.vector)) {
+      const vectorColumnInfo = /** @type {VectorColumnInfo} */ (this.parseFqTypeName(columnInfo.info));
+      return this.encodeVector(value, vectorColumnInfo);
     }
-    const handler = customEncoders[customTypeName];
+
+    const handler = customEncoders[columnInfo.info];
     if (handler) {
       return handler.call(this, value);
     }
-    throw new TypeError('No encoding handler found for type ' + customTypeName);
+    throw new TypeError('No encoding handler found for type ' + columnInfo);
   };
   /**
    * @param {Boolean} value
@@ -753,7 +802,7 @@ function defineInstanceMembers() {
     return buf;
   };
   /**
-   * @param {Number|String} value
+   * @param {Number} value
    * @private
    */
   this.encodeTinyint = function (value) {
@@ -764,7 +813,8 @@ function defineInstanceMembers() {
     buf.writeInt8(value, 0);
     return buf;
   };
-  this.encodeList = function (value, subtype) {
+  this.encodeList = function (value, columnInfo) {
+    const subtype = columnInfo.info;
     if (!Array.isArray(value)) {
       throw new TypeError('Not a valid list value, expected Array obtained ' + util.inspect(value));
     }
@@ -786,24 +836,25 @@ function defineInstanceMembers() {
     }
     return Buffer.concat(parts);
   };
-  this.encodeSet = function (value, subtype) {
+  this.encodeSet = function (value, columnInfo) {
     if (this.encodingOptions.set && value instanceof this.encodingOptions.set) {
       const arr = [];
       value.forEach(function (x) {
         arr.push(x);
       });
-      return this.encodeList(arr, subtype);
+      return this.encodeList(arr, columnInfo);
     }
-    return this.encodeList(value, subtype);
+    return this.encodeList(value, columnInfo);
   };
   /**
    * Serializes a map into a Buffer
    * @param value
-   * @param {Array} [subtypes]
+   * @param {MapColumnInfo} columnInfo
    * @returns {Buffer}
    * @private
    */
-  this.encodeMap = function (value, subtypes) {
+  this.encodeMap = function (value, columnInfo) {
+    const subtypes = columnInfo.info;
     const parts = [];
     let propCounter = 0;
     let keySubtype = null;
@@ -853,7 +904,14 @@ function defineInstanceMembers() {
     parts.unshift(this.getLengthBuffer(propCounter));
     return Buffer.concat(parts);
   };
-  this.encodeUdt = function (value, udtInfo) {
+  /**
+   * 
+   * @param {any} value 
+   * @param {UdtColumnInfo} columnInfo 
+   * @returns 
+   */
+  this.encodeUdt = function (value, columnInfo) {
+    const udtInfo = columnInfo.info;
     const parts = [];
     let totalLength = 0;
     for (let i = 0; i < udtInfo.fields.length; i++) {
@@ -877,7 +935,14 @@ function defineInstanceMembers() {
     }
     return Buffer.concat(parts, totalLength);
   };
-  this.encodeTuple = function (value, tupleInfo) {
+  /**
+   * 
+   * @param {any} value 
+   * @param {TupleColumnInfo} columnInfo
+   * @returns 
+   */
+  this.encodeTuple = function (value, columnInfo) {
+    const tupleInfo = columnInfo.info;
     const parts = [];
     let totalLength = 0;
     const length = Math.min(tupleInfo.length, value.length);
@@ -908,70 +973,110 @@ function defineInstanceMembers() {
     return Buffer.concat(parts, totalLength);
   };
 
+  /**
+   * 
+   * @param {Buffer} buffer 
+   * @param {VectorColumnInfo} params 
+   * @returns {Vector}
+   */
   this.decodeVector = function(buffer, params) {
-    const subtype = params["subtype"];
-    const dimensions = params["dimensions"];
-    const elemLength = 4; // TODO: figure this out based on the subtype
-    const expectedLength = buffer.length / elemLength;
-    if ((elemLength * dimensions) !== buffer.length) {
-      throw new TypeError(`Expected buffer of subtype ${subtype} with dimensions ${dimensions} to be of size ${expectedLength}, observed size ${buffer.length}`);
-    }
+    const subtype = params.info[0];
+    const dimension = params.info[1];
+    const elemLength = this.serializationSizeIfFixed(subtype);
+
     const rv = [];
     let offset = 0;
-    for (let i = 0; i < dimensions; i++) {
-      offset = i * elemLength;
-      rv[i] = this.decode(buffer.slice(offset, offset + elemLength), subtype);
+    for (let i = 0; i < dimension; i++) {
+      if (elemLength === -1) {
+        // var sized
+        const [size, bytesRead] = utils.VIntCoding.uvintUnpack(buffer.subarray(offset));
+        offset += bytesRead;
+        if (offset + size > buffer.length) {
+          throw new TypeError('Not enough bytes to decode the vector');
+        }
+        rv[i] = this.decode(buffer.subarray(offset, offset + size), subtype);
+        offset += size;
+      }else{
+        if (offset + elemLength > buffer.length) {
+          throw new TypeError('Not enough bytes to decode the vector');
+        }
+        rv[i] = this.decode(buffer.subarray(offset, offset + elemLength), subtype);
+        offset += elemLength;
+      }
+    }
+    if (offset !== buffer.length) {
+      throw new TypeError('Extra bytes found after decoding the vector');
     }
-    return new Float32Array(rv);
+    const typeInfo = (types.getDataTypeNameByCode(subtype));
+    return new Vector(rv, typeInfo);
   };
 
   /**
-   * @param {CqlVector} value
-   * @param {Object} params
+   * @param {ColumnInfo} cqlType
+   * @returns {Number}
    */
-  this.encodeVector = function(value, params) {
-
-    // Evaluate params to encodeVector(), returning the computed subtype
-    function evalParams() {
-
-      if (!(value instanceof Float32Array)) {
-        throw new TypeError("Driver only supports vectors of 4 byte floating point values");
-      }
-
-      // Perform client-side validation iff we were actually supplied with meaningful type info.  In practice
-      // this will only occur when using prepared statements.
-      if (params.hasOwnProperty("subtype") && params.hasOwnProperty("dimensions")) {
-
-        const subtype = params["subtype"];
-        const dimensions = params["dimensions"];
-        if (value.length !== dimensions) {
-          throw new TypeError(`Expected vector with ${dimensions} dimensions, observed size of ${value.length}`);
-        }
-        if (subtype.code !== dataTypes.float) {
-          throw new TypeError("Driver only supports vectors of 4 byte floating point values");
+  this.serializationSizeIfFixed = function (cqlType) {
+    switch (cqlType.code) {
+      case dataTypes.bigint:
+        return 8;
+      case dataTypes.boolean:
+        return 1;
+      case dataTypes.timestamp:
+        return 8;
+      case dataTypes.double:
+        return 8;
+      case dataTypes.float:
+        return 4;
+      case dataTypes.int:
+        return 4;
+      case dataTypes.timeuuid:
+        return 16;
+      case dataTypes.uuid:
+        return 16;
+      case dataTypes.custom:
+        if ('customTypeName' in cqlType && cqlType.customTypeName === 'vector'){ 
+          const subtypeSerialSize = this.serializationSizeIfFixed(cqlType.info[0]);
+          if (subtypeSerialSize === -1){
+            return -1;
+          }
+          return subtypeSerialSize * cqlType.info[1];
+          
         }
-        return subtype;
-      }
+        return -1;
+      default:
+        return -1;
+    }
+  };
+  /**
+   * @param {Vector} value
+   * @param {VectorColumnInfo} params
+   * @returns {Buffer}
+   */
+  this.encodeVector = function(value, params) {
 
-      return { code: dataTypes.float };
+    if (!(value instanceof Vector)) {
+      throw new TypeError("Driver only supports Vector type when encoding a vector");
     }
 
-    if (!Encoder.isTypedArray(value)) {
-      throw new TypeError('Expected TypedArray subclass, obtained ' + util.inspect(value));
+    const dimension = params.info[1];
+    if (value.length !== dimension) {
+      throw new TypeError(`Expected vector with ${dimension} dimensions, observed size of ${value.length}`);
     }
+
     if (value.length === 0) {
       throw new TypeError("Cannot encode empty array as vector");
     }
 
-    const subtype = evalParams();
-
-    // TypedArrays are _not_ JS arrays so explicitly convert them here before trying to write them
-    // into a buffer
-    const elems = [];
+    const serializationSize = this.serializationSizeIfFixed(params.info[0]);
+    const encoded = [];
     for (const elem of value) {
-      elems.push(this.encode(elem, subtype));
+      const elemBuffer = this.encode(elem, params.info[0]);
+      if (serializationSize === -1) {
+        encoded.push(utils.VIntCoding.uvintPack(elemBuffer.length));
+      }
+      encoded.push(elemBuffer);
     }
-    return Buffer.concat(elems);
+    return Buffer.concat(encoded);
   };
 
   /**
@@ -980,7 +1085,7 @@ function defineInstanceMembers() {
    * @param {String} typeName
    * @param {String} stringToExclude Leading string indicating this is a vector type (to be excluded when eval'ing args)
    * @param {Function} subtypeResolveFn Function used to resolve subtype type; varies depending on type naming convention
-   * @returns {Object}
+   * @returns {VectorColumnInfo}
    * @internal
    */
   this.parseVectorTypeArgs = function(typeName, stringToExclude, subtypeResolveFn) {
@@ -989,15 +1094,18 @@ function defineInstanceMembers() {
     const argsLength = typeName.length - (stringToExclude.length + 2);
     const params = parseParams(typeName, argsStartIndex, argsLength);
     if (params.length === 2) {
-      return {subtype: subtypeResolveFn(params[0]), dimensions: parseInt(params[1], 10)};
+      /** @type {VectorColumnInfo} */
+      const columnInfo = { code: dataTypes.custom, info: [subtypeResolveFn.bind(this)(params[0].trim()), parseInt(params[1].trim(), 10 )], customTypeName : 'vector'};
+      return columnInfo;
     }
+
     throw new TypeError('Not a valid type ' + typeName);
   };
 
   /**
    * If not provided, it uses the array of buffers or the parameters and hints to build the routingKey
    * @param {Array} params
-   * @param {ExecutionOptions} execOptions
+   * @param {import('..').ExecutionOptions} execOptions
    * @param [keys] parameter keys and positions in the params array
    * @throws TypeError
    * @internal
@@ -1145,8 +1253,10 @@ function defineInstanceMembers() {
    * @param {Number} startIndex
    * @param {Number|null} length
    * @param {Function} udtResolver
-   * @returns {Promise<{err, info, options}>} callback Callback invoked with err and  {{code: number, info: Object|Array|null, options: {frozen: Boolean}}}
+   * @async
+   * @returns {Promise.<ColumnInfo>} callback Callback invoked with err and  {{code: number, info: Object|Array|null, options: {frozen: Boolean}}}
    * @internal
+   * @throws {Error}
    * @ignore
    */
   this.parseTypeName = async function (keyspace, typeName, startIndex, length, udtResolver) {
@@ -1155,20 +1265,16 @@ function defineInstanceMembers() {
       length = typeName.length;
     }
 
-    const dataType = {
-      code: 0,
-      info: null,
-      options: {
-        frozen: false
-      }
-    };
-
     let innerTypes;
+    let frozen = false;
 
     if (typeName.indexOf("'", startIndex) === startIndex) {
       //If quoted, this is a custom type.
-      dataType.info = typeName.substr(startIndex+1, length-2);
-      return dataType;
+      const info = typeName.substr(startIndex+1, length-2);
+      return {
+        code: dataTypes.custom,
+        info: info,
+      };
     }
 
     if (!length) {
@@ -1179,7 +1285,7 @@ function defineInstanceMembers() {
       //Remove the frozen token
       startIndex += cqlNames.frozen.length + 1;
       length -= cqlNames.frozen.length + 2;
-      dataType.options.frozen = true;
+      frozen = true;
     }
 
     if (typeName.indexOf(cqlNames.list, startIndex) === startIndex) {
@@ -1192,9 +1298,14 @@ function defineInstanceMembers() {
         throw new TypeError('Not a valid type ' + typeName);
       }
 
-      dataType.code = dataTypes.list;
-      dataType.info = await this.parseTypeName(keyspace, innerTypes[0], 0, null, udtResolver);
-      return dataType;
+      const info = await this.parseTypeName(keyspace, innerTypes[0], 0, null, udtResolver);
+      return {
+        code: dataTypes.list,
+        info: info,
+        options: {
+          frozen: frozen
+        }
+      };
     }
 
     if (typeName.indexOf(cqlNames.set, startIndex) === startIndex) {
@@ -1207,9 +1318,14 @@ function defineInstanceMembers() {
         throw new TypeError('Not a valid type ' + typeName);
       }
 
-      dataType.code = dataTypes.set;
-      dataType.info = await this.parseTypeName(keyspace, innerTypes[0], 0, null, udtResolver);
-      return dataType;
+      const info = await this.parseTypeName(keyspace, innerTypes[0], 0, null, udtResolver);
+      return {
+        code: dataTypes.set,
+        info: info,
+        options: {
+          frozen: frozen
+        }
+      };
     }
 
     if (typeName.indexOf(cqlNames.map, startIndex) === startIndex) {
@@ -1223,9 +1339,14 @@ function defineInstanceMembers() {
         throw new TypeError('Not a valid type ' + typeName);
       }
 
-      dataType.code = dataTypes.map;
-      dataType.info = await this._parseChildTypes(keyspace, innerTypes, udtResolver);
-      return dataType;
+      const info = await this._parseChildTypes(keyspace, innerTypes, udtResolver);
+      return {
+        code: dataTypes.map,
+        info: info,
+        options: {
+          frozen: frozen
+        }
+      };
     }
 
     if (typeName.indexOf(cqlNames.tuple, startIndex) === startIndex) {
@@ -1238,22 +1359,23 @@ function defineInstanceMembers() {
         throw new TypeError('Not a valid type ' + typeName);
       }
 
-      dataType.code = dataTypes.tuple;
-      dataType.info = await this._parseChildTypes(keyspace, innerTypes, udtResolver);
-      return dataType;
+      const info = await this._parseChildTypes(keyspace, innerTypes, udtResolver);
+      return {
+        code: dataTypes.tuple,
+        info: info,
+        options: {frozen: frozen}
+      };
     }
 
     if (typeName.indexOf(cqlNames.vector, startIndex) === startIndex) {
       // It's a vector, so record the subtype and dimension.
-      dataType.code = dataTypes.custom;
 
       // parseVectorTypeArgs is not an async function but we are.  To keep things simple let's ask the
       // function to just return whatever it finds for an arg and we'll eval it after the fact
-      const params = this.parseVectorTypeArgs(typeName, cqlNames.vector, (arg) => arg );
-      params["subtype"] = await this.parseTypeName(keyspace, params["subtype"]);
-      dataType.info = params;
+      const params = this.parseVectorTypeArgs.bind(this)(typeName, cqlNames.vector, (arg) => arg );
+      params["info"][0] = await this.parseTypeName(keyspace, params["info"][0]);
 
-      return dataType;
+      return params;
     }
 
     const quoted = typeName.indexOf('"', startIndex) === startIndex;
@@ -1275,26 +1397,27 @@ function defineInstanceMembers() {
 
     const typeCode = dataTypes[typeName];
     if (typeof typeCode === 'number') {
-      dataType.code = typeCode;
-      return dataType;
+      return {code : typeCode, info: null};
     }
 
     if (typeName === cqlNames.duration) {
-      dataType.info = customTypeNames.duration;
-      return dataType;
+      return {code : dataTypes.custom, info : customTypeNames.duration};
     }
 
     if (typeName === cqlNames.empty) {
       // Set as custom
-      dataType.info = 'empty';
-      return dataType;
+      return {code : dataTypes.custom, info : 'empty'};
     }
 
     const udtInfo = await udtResolver(keyspace, typeName);
     if (udtInfo) {
-      dataType.code = dataTypes.udt;
-      dataType.info = udtInfo;
-      return dataType;
+      return {
+        code: dataTypes.udt,
+        info: udtInfo,
+        options: {
+          frozen: frozen
+        }
+      };
     }
 
     throw new TypeError('Not a valid type "' + typeName + '"');
@@ -1316,20 +1439,14 @@ function defineInstanceMembers() {
    * @param {String} typeName
    * @param {Number} [startIndex]
    * @param {Number} [length]
-   * @throws TypeError
-   * @returns {{code: number, info: Object|Array|null, options: {frozen: Boolean, reversed: Boolean}}}
+   * @throws {TypeError}
+   * @returns {ColumnInfo}
    * @internal
    * @ignore
    */
   this.parseFqTypeName = function (typeName, startIndex, length) {
-    const dataType = {
-      code: 0,
-      info: null,
-      options: {
-        reversed: false,
-        frozen: false
-      }
-    };
+    let frozen = false;
+    let reversed = false;
     startIndex = startIndex || 0;
     let params;
     if (!length) {
@@ -1339,19 +1456,26 @@ function defineInstanceMembers() {
       //Remove the reversed token
       startIndex += complexTypeNames.reversed.length + 1;
       length -= complexTypeNames.reversed.length + 2;
-      dataType.options.reversed = true;
+      reversed = true;
     }
     if (length > complexTypeNames.frozen.length &&
         typeName.indexOf(complexTypeNames.frozen, startIndex) === startIndex) {
       //Remove the frozen token
       startIndex += complexTypeNames.frozen.length + 1;
       length -= complexTypeNames.frozen.length + 2;
-      dataType.options.frozen = true;
+      frozen = true;
     }
+    const options = {
+      frozen: frozen,
+      reversed: reversed
+    };
     if (typeName === complexTypeNames.empty) {
       //set as custom
-      dataType.info = 'empty';
-      return dataType;
+      return {
+        code: dataTypes.custom,
+        info: 'empty',
+        options: options
+      };
     }
     //Quick check if its a single type
     if (length <= singleFqTypeNamesLength) {
@@ -1360,8 +1484,11 @@ function defineInstanceMembers() {
       }
       const typeCode = singleTypeNames[typeName];
       if (typeof typeCode === 'number') {
-        dataType.code = typeCode;
-        return dataType;
+        return {code : typeCode, info: null, options : options};
+      }
+      // special handling for duration
+      if (typeName === customTypeNames.duration) {
+        return {code: dataTypes.duration, options: options};
       }
       throw new TypeError('Not a valid type "' + typeName + '"');
     }
@@ -1375,9 +1502,12 @@ function defineInstanceMembers() {
       if (params.length !== 1) {
         throw new TypeError('Not a valid type ' + typeName);
       }
-      dataType.code = dataTypes.list;
-      dataType.info = this.parseFqTypeName(params[0]);
-      return dataType;
+      const info = this.parseFqTypeName(params[0]);
+      return {
+        code: dataTypes.list,
+        info: info,
+        options: options
+      };
     }
     if (typeName.indexOf(complexTypeNames.set, startIndex) === startIndex) {
       //Its a set
@@ -1390,9 +1520,12 @@ function defineInstanceMembers() {
       {
         throw new TypeError('Not a valid type ' + typeName);
       }
-      dataType.code = dataTypes.set;
-      dataType.info = this.parseFqTypeName(params[0]);
-      return dataType;
+      const info = this.parseFqTypeName(params[0]);
+      return {
+        code : dataTypes.set,
+        info : info,
+        options: options
+      };
     }
     if (typeName.indexOf(complexTypeNames.map, startIndex) === startIndex) {
       //org.apache.cassandra.db.marshal.MapType(keyType,valueType)
@@ -1404,15 +1537,21 @@ function defineInstanceMembers() {
       if (params.length !== 2) {
         throw new TypeError('Not a valid type ' + typeName);
       }
-      dataType.code = dataTypes.map;
-      dataType.info = [this.parseFqTypeName(params[0]), this.parseFqTypeName(params[1])];
-      return dataType;
+      const info1 = this.parseFqTypeName(params[0]);
+      const info2 = this.parseFqTypeName(params[1]);
+      return {
+        code : dataTypes.map,
+        info : [info1, info2],
+        options: options
+      };
     }
     if (typeName.indexOf(complexTypeNames.udt, startIndex) === startIndex) {
       //move cursor across the name and bypass the parenthesis
       startIndex += complexTypeNames.udt.length + 1;
       length -= complexTypeNames.udt.length + 2;
-      return this._parseUdtName(typeName, startIndex, length);
+      const udtType = this._parseUdtName(typeName, startIndex, length);
+      udtType.options = options;
+      return udtType;
     }
     if (typeName.indexOf(complexTypeNames.tuple, startIndex) === startIndex) {
       //move cursor across the name and bypass the parenthesis
@@ -1422,21 +1561,28 @@ function defineInstanceMembers() {
       if (params.length < 1) {
         throw new TypeError('Not a valid type ' + typeName);
       }
-      dataType.code = dataTypes.tuple;
-      dataType.info = params.map(x => this.parseFqTypeName(x));
-      return dataType;
+      const info = params.map(x => this.parseFqTypeName(x));
+      return {
+        code : dataTypes.tuple,
+        info : info,
+        options: options
+      };
     }
 
     if (typeName.indexOf(customTypeNames.vector, startIndex) === startIndex) {
       // It's a vector, so record the subtype and dimension.
-      dataType.code = dataTypes.custom;
-      dataType.info = this.parseVectorTypeArgs(typeName, customTypeNames.vector, this.parseFqTypeName);
-      return dataType;
+      const params = this.parseVectorTypeArgs.bind(this)(typeName, customTypeNames.vector, this.parseFqTypeName);
+      params.options = options;
+      return params;
     }
 
     // Assume custom type if cannot be parsed up to this point.
-    dataType.info = typeName.substr(startIndex, length);
-    return dataType;
+    const info = typeName.substr(startIndex, length);
+    return {
+      code: dataTypes.custom,
+      info: info,
+      options: options
+    };
   };
   /**
    * Parses type names with composites
@@ -1502,16 +1648,22 @@ function defineInstanceMembers() {
       isComposite: isComposite
     };
   };
+  /**
+   * 
+   * @param {string} typeName 
+   * @param {number} startIndex 
+   * @param {number} length 
+   * @returns {UdtColumnInfo} 
+   */
   this._parseUdtName = function (typeName, startIndex, length) {
     const udtParams = parseParams(typeName, startIndex, length);
     if (udtParams.length < 2) {
       //It should contain at least the keyspace, name of the udt and a type
       throw new TypeError('Not a valid type ' + typeName);
     }
-    const dataType = {
-      code: dataTypes.udt,
-      info: null
-    };
+    /**
+     * @type {{keyspace: String, name: String, fields: Array}}
+     */
     const udtInfo = {
       keyspace: udtParams[0],
       name: utils.allocBufferFromString(udtParams[1], 'hex').toString(),
@@ -1526,8 +1678,10 @@ function defineInstanceMembers() {
         type: fieldType
       });
     }
-    dataType.info = udtInfo;
-    return dataType;
+    return {
+      code : dataTypes.udt,
+      info : udtInfo
+    };
   };
 }
 
@@ -1603,9 +1757,7 @@ function setEncoders() {
  * This is part of an <b>experimental</b> API, this can be changed future releases.
  * </p>
  * @param {Buffer} buffer Raw buffer to be decoded.
- * @param {Object} type An object containing the data type <code>code</code> and <code>info</code>.
- * @param {Number} type.code Type code.
- * @param {Object} [type.info] Additional information on the type for complex / nested types.
+ * @param {ColumnInfo} type 
  */
 Encoder.prototype.decode = function (buffer, type) {
   if (buffer === null || (buffer.length === 0 && !zeroLengthTypesSupported.has(type.code))) {
@@ -1618,7 +1770,7 @@ Encoder.prototype.decode = function (buffer, type) {
     throw new Error('Unknown data type: ' + type.code);
   }
 
-  return decoder.call(this, buffer, type.info);
+  return decoder.call(this, buffer, type);
 };
 
 /**
@@ -1627,7 +1779,7 @@ Encoder.prototype.decode = function (buffer, type) {
  * This is part of an <b>experimental</b> API, this can be changed future releases.
  * </p>
  * @param {*} value The value to be converted.
- * @param {{code: number, info: *|Object}|String|Number} [typeInfo] The type information.
+ * @param {ColumnInfo | Number | String} typeInfo The type information.
  * <p>It can be either a:</p>
  * <ul>
  *   <li>A <code>String</code> representing the data type.</li>
@@ -1657,24 +1809,22 @@ Encoder.prototype.encode = function (value, typeInfo) {
     return value;
   }
 
-  /** @type {{code: Number, info: object}} */
-  let type = {
-    code: null,
-    info: null
-  };
+  /** @type {ColumnInfo | null} */
+  let type = null;
 
   if (typeInfo) {
     if (typeof typeInfo === 'number') {
-      type.code = typeInfo;
+      type = {
+        code: typeInfo
+      };
     }
     else if (typeof typeInfo === 'string') {
       type = dataTypes.getByName(typeInfo);
     }
-    if (typeof typeInfo.code === 'number') {
-      type.code = typeInfo.code;
-      type.info = typeInfo.info;
+    else if (typeof typeInfo.code === 'number') {
+      type = typeInfo;
     }
-    if (typeof type.code !== 'number') {
+    if (type == null || typeof type.code !== 'number') {
       throw new TypeError('Type information not valid, only String and Number values are valid hints');
     }
   }
@@ -1692,94 +1842,122 @@ Encoder.prototype.encode = function (value, typeInfo) {
     throw new Error('Type not supported ' + type.code);
   }
 
-  return encoder.call(this, value, type.info);
+  return encoder.call(this, value, type);
 };
 
 /**
  * Try to guess the Cassandra type to be stored, based on the javascript value type
  * @param value
- * @returns {{code: number, info: object}|null}
+ * @returns {ColumnInfo | null}
  * @ignore
  * @internal
  */
 Encoder.guessDataType = function (value) {
-  let code = null;
-  let info = null;
   const esTypeName = (typeof value);
   if (esTypeName === 'number') {
-    code = dataTypes.double;
+    return {code : dataTypes.double};
   }
   else if (esTypeName === 'string') {
-    code = dataTypes.text;
     if (value.length === 36 && uuidRegex.test(value)){
-      code = dataTypes.uuid;
+      return {code : dataTypes.uuid};
     }
+    return {code : dataTypes.text};
+    
   }
   else if (esTypeName === 'boolean') {
-    code = dataTypes.boolean;
+    return {code : dataTypes.boolean};
   }
   else if (value instanceof Buffer) {
-    code = dataTypes.blob;
+    return {code : dataTypes.blob};
   }
   else if (value instanceof Date) {
-    code = dataTypes.timestamp;
+    return {code : dataTypes.timestamp};
   }
   else if (value instanceof Long) {
-    code = dataTypes.bigint;
+    return {code : dataTypes.bigint};
   }
   else if (value instanceof Integer) {
-    code = dataTypes.varint;
+    return {code : dataTypes.varint};
   }
   else if (value instanceof BigDecimal) {
-    code = dataTypes.decimal;
+    return {code : dataTypes.decimal};
   }
   else if (value instanceof types.Uuid) {
-    code = dataTypes.uuid;
+    return {code : dataTypes.uuid};
   }
   else if (value instanceof types.InetAddress) {
-    code = dataTypes.inet;
+    return {code : dataTypes.inet};
   }
   else if (value instanceof types.Tuple) {
-    code = dataTypes.tuple;
+    return {code : dataTypes.tuple};
   }
   else if (value instanceof types.LocalDate) {
-    code = dataTypes.date;
+    return {code : dataTypes.date};
   }
   else if (value instanceof types.LocalTime) {
-    code = dataTypes.time;
+    return {code : dataTypes.time};
   }
   else if (value instanceof types.Duration) {
-    code = dataTypes.custom;
-    info = customTypeNames.duration;
+    return {code : dataTypes.custom,
+      info : customTypeNames.duration};
   }
   // Map JS TypedArrays onto vectors
-  else if (Encoder.isTypedArray(value)) {
-    code = dataTypes.custom;
-    // TODO: another area that we have to generalize if we ever need to support vector subtypes other than float
-    info = buildParameterizedCustomType(customTypeNames.vector, [singleTypeNamesByDataType[dataTypes.float], value.length]);
+  else if (value instanceof types.Vector) {
+    if (value && value.length > 0) {
+      if (value instanceof Float32Array) {
+        return {
+          code: dataTypes.custom,
+          customTypeName: 'vector',
+          info: [ {code: dataTypes.float}, value.length]
+        };
+      }
+     
+      /** @type {ColumnInfo?} */
+      let subtypeColumnInfo = null;
+      // try to fetch the subtype from the Vector, or else guess
+      if (value.subtype) {
+        try {
+          subtypeColumnInfo = dataTypes.getByName(value.subtype);
+        } catch (TypeError) {
+          // ignore
+        }
+      } 
+      if (subtypeColumnInfo == null){
+        subtypeColumnInfo = this.guessDataType(value[0]);
+      }
+      if (subtypeColumnInfo != null) {
+        return {
+          code: dataTypes.custom,
+          customTypeName: 'vector',
+          info: [subtypeColumnInfo, value.length]
+        };
+      }
+      throw new TypeError("Cannot guess subtype from element " + value[0]);
+    } else {
+      throw new TypeError("Cannot guess subtype of empty vector");
+    }
   }
   else if (Array.isArray(value)) {
-    code = dataTypes.list;
+    return {code : dataTypes.list};
   }
   else if (value instanceof Geometry) {
-    code = dataTypes.custom;
     if (value instanceof LineString) {
-      info = customTypeNames.lineString;
+      return {code : dataTypes.custom,
+        info : customTypeNames.lineString};
     } else if (value instanceof Point) {
-      info = customTypeNames.point;
+      return {code : dataTypes.custom,
+        info : customTypeNames.point};
     } else if (value instanceof Polygon) {
-      info = customTypeNames.polygon;
+      return {code : dataTypes.custom,
+        info : customTypeNames.polygon};
     }
   }
   else if (value instanceof DateRange) {
-    code = dataTypes.custom;
-    info = customTypeNames.dateRange;
+    return {code : dataTypes.custom,
+      info : customTypeNames.dateRange};
   }
 
-  if (code === null) {
-    return null;
-  }
-  return { code: code, info: info };
+  return null;
 };
 
 /**
@@ -1938,7 +2116,7 @@ function encodeDateRange(value) {
  * @param {Number} length
  * @param {String} [open]
  * @param {String} [close]
- * @returns {Array}
+ * @returns {Array<String>}
  * @private
  */
 function parseParams(value, startIndex, length, open, close) {
@@ -1992,10 +2170,6 @@ function concatRoutingKey(parts, totalLength) {
   return routingKey;
 }
 
-function buildParameterizedCustomType(customTypeName, args) {
-  return `${customTypeName}(${args.join(',')})`;
-}
-
 function invertObject(obj) {
   const rv = {};
   for(const k in obj){
diff --git a/lib/errors.js b/lib/errors.js
index 8ec192f5..970c528b 100644
--- a/lib/errors.js
+++ b/lib/errors.js
@@ -164,6 +164,18 @@ function BusyConnectionError(address, maxRequestsPerConnection, connectionLength
 
 util.inherits(BusyConnectionError, DriverError);
 
+/**
+ * 
+ * @param {Long} long 
+ */
+function VIntOutOfRangeException(long){
+  const message = `Value ${long.toString} is out of range for a JavaScript Number`;
+  DriverError.call(this, message, this.constructor);
+  this.info = 'Represents a run-time exception when attempting to decode a vint and the JavaScript Number doesn\'t have enough space to fit the value that was decoded';
+}
+
+util.inherits(VIntOutOfRangeException, DriverError);
+
 exports.ArgumentError = ArgumentError;
 exports.AuthenticationError = AuthenticationError;
 exports.BusyConnectionError = BusyConnectionError;
@@ -172,4 +184,5 @@ exports.OperationTimedOutError = OperationTimedOutError;
 exports.DriverInternalError = DriverInternalError;
 exports.NoHostAvailableError = NoHostAvailableError;
 exports.NotSupportedError = NotSupportedError;
-exports.ResponseError = ResponseError;
\ No newline at end of file
+exports.ResponseError = ResponseError;
+exports.VIntOutOfRangeException = VIntOutOfRangeException;
\ No newline at end of file
diff --git a/lib/types/duration.js b/lib/types/duration.js
index aa1b4197..4dc084f0 100644
--- a/lib/types/duration.js
+++ b/lib/types/duration.js
@@ -17,6 +17,7 @@
 const Long = require('long');
 const util = require('util');
 const utils = require('../utils');
+const VIntCoding = utils.VIntCoding;
 
 /** @module types */
 
@@ -514,201 +515,4 @@ Builder.prototype.build = function () {
     new Duration(this._months, this._days, this._nanoseconds));
 };
 
-/**
- * Contains the methods for reading and writing vints into binary format.
- * Exposes only 2 internal methods, the rest are hidden.
- * @private
- */
-const VIntCoding = (function () {
-  /** @param {Long} n */
-  function encodeZigZag64(n) {
-    //     (n << 1) ^ (n >> 63);
-    return n.toUnsigned().shiftLeft(1).xor(n.shiftRight(63));
-  }
-
-  /** @param {Long} n */
-  function decodeZigZag64(n) {
-    //     (n >>> 1) ^ -(n & 1);
-    return n.shiftRightUnsigned(1).xor(n.and(Long.ONE).negate());
-  }
-
-  /**
-   * @param {Long} value
-   * @param {Buffer} buffer
-   * @returns {Number}
-   */
-  function writeVInt(value, buffer) {
-    return writeUnsignedVInt(encodeZigZag64(value), buffer);
-  }
-
-  /**
-   * @param {Long} value
-   * @param {Buffer} buffer
-   * @returns {number}
-   */
-  function writeUnsignedVInt(value, buffer) {
-    const size = computeUnsignedVIntSize(value);
-    if (size === 1) {
-      buffer[0] = value.getLowBits();
-      return 1;
-    }
-    encodeVInt(value, size, buffer);
-    return size;
-  }
-
-  /**
-   * @param {Long} value
-   * @returns {number}
-   */
-  function computeUnsignedVIntSize(value) {
-    const magnitude = numberOfLeadingZeros(value.or(Long.ONE));
-    return (639 - magnitude * 9) >> 6;
-  }
-
-  /**
-   * @param {Long} value
-   * @param {Number} size
-   * @param {Buffer} buffer
-   */
-  function encodeVInt(value, size, buffer) {
-    const extraBytes = size - 1;
-    let intValue = value.getLowBits();
-    let i;
-    let intBytes = 4;
-    for (i = extraBytes; i >= 0 && (intBytes--) > 0; i--) {
-      buffer[i] = 0xFF & intValue;
-      intValue >>= 8;
-    }
-    intValue = value.getHighBits();
-    for (; i >= 0; i--) {
-      buffer[i] = 0xFF & intValue;
-      intValue >>= 8;
-    }
-    buffer[0] |= encodeExtraBytesToRead(extraBytes);
-  }
-  /**
-   * Returns the number of zero bits preceding the highest-order one-bit in the binary representation of the value.
-   * @param {Long} value
-   * @returns {Number}
-   */
-  function numberOfLeadingZeros(value) {
-    if (value.equals(Long.ZERO)) {
-      return 64;
-    }
-    let n = 1;
-    let x = value.getHighBits();
-    if (x === 0) {
-      n += 32;
-      x = value.getLowBits();
-    }
-    if (x >>> 16 === 0) {
-      n += 16;
-      x <<= 16;
-    }
-    if (x >>> 24 === 0) {
-      n += 8;
-      x <<= 8;
-    }
-    if (x >>> 28 === 0) {
-      n += 4;
-      x <<= 4;
-    }
-    if (x >>> 30 === 0) {
-      n += 2;
-      x <<= 2;
-    }
-    n -= x >>> 31;
-    return n;
-  }
-
-
-  function encodeExtraBytesToRead(extraBytesToRead) {
-    return ~(0xff >> extraBytesToRead);
-  }
-
-  /**
-   * @param {Buffer} buffer
-   * @param {{value: number}} offset
-   * @returns {Long}
-   */
-  function readVInt(buffer, offset) {
-    return decodeZigZag64(readUnsignedVInt(buffer, offset));
-  }
-
-  /**
-   * @param {Buffer} input
-   * @param {{ value: number}} offset
-   * @returns {Long}
-   */
-  function readUnsignedVInt(input, offset) {
-    const firstByte = input[offset.value++];
-    if ((firstByte & 0x80) === 0) {
-      return Long.fromInt(firstByte);
-    }
-    const sByteInt = fromSignedByteToInt(firstByte);
-    const size = numberOfExtraBytesToRead(sByteInt);
-    let result = Long.fromInt(sByteInt & firstByteValueMask(size));
-    for (let ii = 0; ii < size; ii++) {
-      const b = Long.fromInt(input[offset.value++]);
-      //       (result << 8) | b
-      result = result.shiftLeft(8).or(b);
-    }
-    return result;
-  }
-
-  function fromSignedByteToInt(value) {
-    if (value > 0x7f) {
-      return value - 0x0100;
-    }
-    return value;
-  }
-
-  function numberOfLeadingZerosInt32(i) {
-    if (i === 0) {
-      return 32;
-    }
-    let n = 1;
-    if (i >>> 16 === 0) {
-      n += 16;
-      i <<= 16;
-    }
-    if (i >>> 24 === 0) {
-      n += 8;
-      i <<= 8;
-    }
-    if (i >>> 28 === 0) {
-      n += 4;
-      i <<= 4;
-    }
-    if (i >>> 30 === 0) {
-      n += 2;
-      i <<= 2;
-    }
-    n -= i >>> 31;
-    return n;
-  }
-
-  /**
-   * @param {Number} firstByte
-   * @returns {Number}
-   */
-  function numberOfExtraBytesToRead(firstByte) {
-    // Instead of counting 1s of the byte, we negate and count 0 of the byte
-    return numberOfLeadingZerosInt32(~firstByte) - 24;
-  }
-
-  /**
-   * @param {Number} extraBytesToRead
-   * @returns {Number}
-   */
-  function firstByteValueMask(extraBytesToRead) {
-    return 0xff >> extraBytesToRead;
-  }
-
-  return {
-    readVInt: readVInt,
-    writeVInt: writeVInt
-  };
-})();
-
 module.exports = Duration;
diff --git a/lib/types/index.d.ts b/lib/types/index.d.ts
index b03186cf..3826ed80 100644
--- a/lib/types/index.d.ts
+++ b/lib/types/index.d.ts
@@ -424,4 +424,45 @@ export namespace types {
 
     toJSON(): string;
   }
+
+  class Vector {
+    static get [Symbol.species](): typeof Vector;
+    /**
+       *
+       * @param {Float32Array | Array<any>} elements
+       * @param {string?} subtype
+       */
+    constructor(elements: Float32Array | Array<any>, subtype?: string | null);
+    elements: any[];
+    /**
+         * Returns the number of the elements.
+         * @type Number
+         */
+    length: number;
+    subtype: string;
+    /**
+       * Returns the string representation of the vector.
+       * @returns {string}
+       */
+    toString(): string;
+    /**
+       *
+       * @param {number} index
+       */
+    at(index: number): any;
+    /**
+       *
+       * @param {(value: any, index: number, array: any[]) => void} callback
+       */
+    forEach(callback: (value: any, index: number, array: any[]) => void): void;
+    /**
+     * @returns {string | null} get the subtype string, e.g., "float", but it's optional so it can return null
+     */
+    getSubtype(): string | null;
+    /**
+       *
+       * @returns {IterableIterator<any>}
+       */
+    [Symbol.iterator](): IterableIterator<any>;
+  }
 }
\ No newline at end of file
diff --git a/lib/types/index.js b/lib/types/index.js
index 953295a0..f28dbb55 100644
--- a/lib/types/index.js
+++ b/lib/types/index.js
@@ -135,8 +135,8 @@ const dataTypes = {
   tuple:      0x0031,
   /**
    * Returns the typeInfo of a given type name
-   * @param name
-   * @returns {{code: number, info: *|Object}}
+   * @param {string} name
+   * @returns {import('../encoder').ColumnInfo}
    */
   getByName:  function(name) {
     name = name.toLowerCase();
@@ -161,8 +161,16 @@ const dataTypes = {
           return this.getByName(x.trim());
         }, this)};
       }
+      const vectorMatches = /^vector<\s*(.+)\s*,\s*(\d+)\s*>$/.exec(name);
+      if(vectorMatches){
+        return {
+          code: this.custom,
+          customTypeName: 'vector',
+          info: [this.getByName(vectorMatches[1]), parseInt(vectorMatches[2], 10)]
+        };
+      }
     }
-    const typeInfo = { code: this[name], info: null};
+    const typeInfo = { code: this[name]};
     if (typeof typeInfo.code !== 'number') {
       throw new TypeError('Data type with name ' + name + ' not valid');
     }
@@ -174,8 +182,10 @@ const dataTypes = {
  * Map of Data types by code
  * @internal
  * @private
+ * @type {Record<number, string>}
  */
 const _dataTypesByCode = (function () {
+  /**@type {Record<number, string>} */
   const result = {};
   for (const key in dataTypes) {
     if (!dataTypes.hasOwnProperty(key)) {
@@ -402,10 +412,11 @@ function uuid(options, buffer, offset) {
 }
 
 /**
- * Gets the data type name for a given type definition
+ * Gets the data type name for a given type definition, it may not work for udt or custom type
  * @internal
  * @ignore
  * @throws {ArgumentError}
+ * @param {import('../encoder').ColumnInfo} item 
  */
 function getDataTypeNameByCode(item) {
   if (!item || typeof item.code !== 'number') {
@@ -415,9 +426,13 @@ function getDataTypeNameByCode(item) {
   if (!typeName) {
     throw new errors.ArgumentError(util.format('Type with code %d not found', item.code));
   }
-  if (!item.info) {
+  if (!('info' in item) || !item.info) {
     return typeName;
   }
+  // special case for vector
+  if (item.code === dataTypes.custom && 'customTypeName' in item && item.customTypeName === 'vector') {
+    return 'vector<' + getDataTypeNameByCode(item.info[0]) + ', ' + item.info[1] + '>';
+  }
   if (Array.isArray(item.info)) {
     return (typeName +
       '<' +
@@ -429,6 +444,9 @@ function getDataTypeNameByCode(item) {
   if (typeof item.info.code === 'number') {
     return typeName + '<' + getDataTypeNameByCode(item.info) + '>';
   }
+  if (item.code === dataTypes.udt) {
+    return (/**@type {UdtColumnInfo}*/item).info.name;
+  }
   return typeName;
 }
 
@@ -624,6 +642,7 @@ exports.DriverError = errors.DriverError;
 exports.TimeoutError = TimeoutError;
 exports.TimeUuid = TimeUuid;
 exports.Tuple = require('./tuple');
+exports.Vector = require('./vector');
 exports.Uuid = Uuid;
 exports.unset = unset;
 exports.generateTimestamp = generateTimestamp;
diff --git a/lib/types/vector.js b/lib/types/vector.js
new file mode 100644
index 00000000..308511ee
--- /dev/null
+++ b/lib/types/vector.js
@@ -0,0 +1,122 @@
+/*
+ * Copyright DataStax, Inc.
+ *
+ * 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.
+ */
+"use strict";
+/** @module types */
+/**
+ * Creates a new instance of Cql Vector, also compatible with Float32Array.
+ * @class
+ */
+const util = require('node:util');
+class Vector {
+  /**
+     *
+     * @param {Float32Array | Array<any>} elements
+     * @param {string} [subtype]
+     */
+  constructor (elements, subtype) {
+    if (elements instanceof Float32Array) {
+      this.elements = Array.from(elements);
+    }
+    else if (Array.isArray(elements)) {
+      this.elements = elements;
+    }
+    else {
+      throw new TypeError('Vector must be constructed with a Float32Array or an Array');
+    }
+    if (this.elements.length === 0) {
+      throw new TypeError('Vector must contain at least one value');
+    }
+    /**
+         * Returns the number of the elements.
+         * @type Number
+         */
+    this.length = this.elements.length;
+    this.subtype = subtype;
+    return new Proxy(this, {
+      get: function (obj, key) {
+        if (key === 'IDENTITY'){
+          return 'Vector';
+        } else if (typeof (key) === 'string' && (Number.isInteger(Number(key)))) // key is an index
+        {return obj.elements[key];}
+        return obj[key];
+      },
+      set: function (obj, key, value) {
+        if (typeof (key) === 'string' && (Number.isInteger(Number(key)))) // key is an index
+        {return obj.elements[key] = value;}
+        return obj[key] = value;
+      },
+      ownKeys: function (obj) {
+        return Reflect.ownKeys(elements);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        if (typeof (key) === 'string' && (Number.isInteger(Number(key)))){
+          // array index
+          return { enumerable: true, configurable: true};
+        }
+        return Reflect.getOwnPropertyDescriptor(target, key);
+                
+      }
+    });
+  }
+  /**
+     * Returns the string representation of the vector.
+     * @returns {string}
+     */
+  toString() {
+    return "[".concat(this.elements.toString(), "]");
+  }
+  /**
+     *
+     * @param {number} index
+     */
+  at(index) {
+    return this.elements[index];
+  }
+
+  /**
+   * 
+   * @returns {IterableIterator<any>} an iterator over the elements of the vector
+   */
+  [Symbol.iterator]() {
+    return this.elements[Symbol.iterator]();
+  }
+
+  static get [Symbol.species]() {
+    return Vector;
+  }
+
+  /**
+     * 
+     * @param {(value: any, index: number, array: any[]) => void} callback
+     */
+  forEach(callback) {
+    return this.elements.forEach(callback);
+  }
+
+  /**
+   * @returns {string | undefined} get the subtype string, e.g., "float", but it's optional so it can return null
+   */
+  getSubtype(){
+    return this.subtype;
+  }
+}
+
+Object.defineProperty(Vector, Symbol.hasInstance, {
+  value: function (i) { 
+    return (util.types.isProxy(i) && i.IDENTITY === 'Vector') || i instanceof Float32Array; }
+});
+
+module.exports = Vector;
diff --git a/lib/utils.js b/lib/utils.js
index 395f122c..dfc217a7 100644
--- a/lib/utils.js
+++ b/lib/utils.js
@@ -15,6 +15,7 @@
  */
 'use strict';
 
+const Long = require('long');
 const util = require('util');
 const net = require('net');
 const { EventEmitter } = require('events');
@@ -1040,6 +1041,335 @@ function whilst(condition, fn, callback) {
   }
 }
 
+
+/**
+ * Contains the methods for reading and writing vints into binary format.
+ * Exposes only 2 internal methods, the rest are hidden.
+ */
+const VIntCoding = (function () {
+  /** @param {Long} n */
+  function encodeZigZag64(n) {
+    //     (n << 1) ^ (n >> 63);
+    return n.toUnsigned().shiftLeft(1).xor(n.shiftRight(63));
+  }
+
+  /** @param {Long} n */
+  function decodeZigZag64(n) {
+    //     (n >>> 1) ^ -(n & 1);
+    return n.shiftRightUnsigned(1).xor(n.and(Long.ONE).negate());
+  }
+
+  /**
+   * @param {Long} value
+   * @param {Buffer} buffer
+   * @returns {Number}
+   */
+  function writeVInt(value, buffer) {
+    return writeUnsignedVInt(encodeZigZag64(value), buffer);
+  }
+
+  /**
+   * @param {Long} value
+   * @param {Buffer} buffer
+   * @returns {number}
+   */
+  function writeUnsignedVInt(value, buffer) {
+    const size = computeUnsignedVIntSize(value);
+    if (size === 1) {
+      buffer[0] = value.getLowBits();
+      return 1;
+    }
+    encodeVInt(value, size, buffer);
+    return size;
+  }
+
+  /**
+   * @param {Long} value
+   * @returns {number}
+   */
+  function computeUnsignedVIntSize(value) {
+    const magnitude = numberOfLeadingZeros(value.or(Long.ONE));
+    return (639 - magnitude * 9) >> 6;
+  }
+
+  /**
+   * @param {Long} value
+   * @param {Number} size
+   * @param {Buffer} buffer
+   */
+  function encodeVInt(value, size, buffer) {
+    const extraBytes = size - 1;
+    let intValue = value.getLowBits();
+    let i;
+    let intBytes = 4;
+    for (i = extraBytes; i >= 0 && (intBytes--) > 0; i--) {
+      buffer[i] = 0xFF & intValue;
+      intValue >>= 8;
+    }
+    intValue = value.getHighBits();
+    for (; i >= 0; i--) {
+      buffer[i] = 0xFF & intValue;
+      intValue >>= 8;
+    }
+    buffer[0] |= encodeExtraBytesToRead(extraBytes);
+  }
+  /**
+   * Returns the number of zero bits preceding the highest-order one-bit in the binary representation of the value.
+   * @param {Long} value
+   * @returns {Number}
+   */
+  function numberOfLeadingZeros(value) {
+    if (value.equals(Long.ZERO)) {
+      return 64;
+    }
+    let n = 1;
+    let x = value.getHighBits();
+    if (x === 0) {
+      n += 32;
+      x = value.getLowBits();
+    }
+    if (x >>> 16 === 0) {
+      n += 16;
+      x <<= 16;
+    }
+    if (x >>> 24 === 0) {
+      n += 8;
+      x <<= 8;
+    }
+    if (x >>> 28 === 0) {
+      n += 4;
+      x <<= 4;
+    }
+    if (x >>> 30 === 0) {
+      n += 2;
+      x <<= 2;
+    }
+    n -= x >>> 31;
+    return n;
+  }
+
+
+  function encodeExtraBytesToRead(extraBytesToRead) {
+    return ~(0xff >> extraBytesToRead);
+  }
+
+  /**
+   * @param {Buffer} buffer
+   * @param {{value: number}} offset
+   * @returns {Long}
+   */
+  function readVInt(buffer, offset) {
+    return decodeZigZag64(readUnsignedVInt(buffer, offset));
+  }
+
+  /**
+   * uvint_unpack
+   * @param {Buffer} input
+   * @param {{ value: number}} offset
+   * @returns {Long}
+   */
+  function readUnsignedVInt(input, offset) {
+    const firstByte = input[offset.value++];
+    if ((firstByte & 0x80) === 0) {
+      return Long.fromInt(firstByte);
+    }
+    const sByteInt = fromSignedByteToInt(firstByte);
+    const size = numberOfExtraBytesToRead(sByteInt);
+    let result = Long.fromInt(sByteInt & firstByteValueMask(size));
+    for (let ii = 0; ii < size; ii++) {
+      const b = Long.fromInt(input[offset.value++]);
+      //       (result << 8) | b
+      result = result.shiftLeft(8).or(b);
+    }
+    return result;
+  }
+
+  function fromSignedByteToInt(value) {
+    if (value > 0x7f) {
+      return value - 0x0100;
+    }
+    return value;
+  }
+
+  function numberOfLeadingZerosInt32(i) {
+    if (i === 0) {
+      return 32;
+    }
+    let n = 1;
+    if (i >>> 16 === 0) {
+      n += 16;
+      i <<= 16;
+    }
+    if (i >>> 24 === 0) {
+      n += 8;
+      i <<= 8;
+    }
+    if (i >>> 28 === 0) {
+      n += 4;
+      i <<= 4;
+    }
+    if (i >>> 30 === 0) {
+      n += 2;
+      i <<= 2;
+    }
+    n -= i >>> 31;
+    return n;
+  }
+
+  /**
+   * @param {Number} firstByte
+   * @returns {Number}
+   */
+  function numberOfExtraBytesToRead(firstByte) {
+    // Instead of counting 1s of the byte, we negate and count 0 of the byte
+    return numberOfLeadingZerosInt32(~firstByte) - 24;
+  }
+
+  /**
+   * @param {Number} extraBytesToRead
+   * @returns {Number}
+   */
+  function firstByteValueMask(extraBytesToRead) {
+    return 0xff >> extraBytesToRead;
+  }
+
+  /**
+   * @param {Number} value
+   * @param {Buffer} output
+   * @returns {void}
+   */
+  // eslint-disable-next-line no-unused-vars
+  function writeUnsignedVInt32(value, output) {
+    writeUnsignedVInt(Long.fromNumber(value), output);
+  }
+
+  /**
+   * Read up to a 32-bit integer back, using the unsigned (no zigzag) encoding.
+   *
+   * <p>Note this method is the same as {@link #readUnsignedVInt(DataInput)}, except that we do
+   * *not* block if there are not enough bytes in the buffer to reconstruct the value.
+   *
+   * @param {Buffer} input
+   * @param {Number} readerIndex
+   * @returns {Number}
+   * @throws VIntOutOfRangeException If the vint doesn't fit into a 32-bit integer
+   */
+  // eslint-disable-next-line no-unused-vars
+  function getUnsignedVInt32(input, readerIndex) {
+    return checkedCast(getUnsignedVInt(input, readerIndex, input.length));
+  }
+
+  /**
+   * 
+   * @param {Buffer} input 
+   * @param {Number} readerIndex 
+   * @param {Number} readerLimit 
+   * @returns {Long}
+   */
+  function getUnsignedVInt(input, readerIndex, readerLimit) {
+    if (readerIndex < 0)
+    {throw new errors.ArgumentError(
+      "Reader index should be non-negative, but was " + readerIndex);}
+
+    if (readerIndex >= readerLimit) {return Long.fromNumber(-1);}
+
+    const firstByte = /** @type {Number} */ (input.at(readerIndex++));
+
+    // Bail out early if this is one byte, necessary or it fails later
+    if (firstByte >= 0) {return Long.fromNumber(firstByte);}
+
+    const size = numberOfExtraBytesToRead(firstByte);
+    if (readerIndex + size > readerLimit) {return Long.fromNumber(-1);}
+
+    const retval = Long.fromNumber(firstByte & firstByteValueMask(size));
+    for (let ii = 0; ii < size; ii++) {
+      const b = /** @type {Number} */ (input.at(readerIndex++));
+      retval.shiftLeft(8);
+      retval.or(b & 0xff);
+    }
+
+    return retval;
+  }
+
+  /**
+   * 
+   * @param {Long} value 
+   * @returns {Number} 
+   */
+  function checkedCast(value) {
+    const result = value.toInt();
+    if (value.notEquals(result)) {throw new errors.VIntOutOfRangeException(value);}
+    return result;
+  }
+
+  /**
+   * 
+   * @param {Buffer} bytes 
+   * @returns {[number, number]} [size, bytes read]
+   */
+  function uvintUnpack(bytes) {
+    const firstByte = bytes[0];
+
+    if ((firstByte & 128) === 0) {
+      return [firstByte, 1];
+    }
+
+    const numExtraBytes = 8 - (~firstByte & 0xff).toString(2).length;
+    let rv = firstByte & (0xff >> numExtraBytes);
+    
+    for (let idx = 1; idx <= numExtraBytes; idx++) {
+      const newByte = bytes[idx];
+      rv <<= 8;
+      rv |= newByte & 0xff;
+    }
+
+    return [rv, numExtraBytes + 1];
+  }
+
+  /**
+ * 
+ * @param {Number} val 
+ * @returns {Buffer}
+ */
+  function uvintPack(val) {
+    const rv = [];
+    if (val < 128) {
+      rv.push(val);
+    } else {
+      let v = val;
+      let numExtraBytes = 0;
+      let numBits = v.toString(2).length;
+      let reservedBits = numExtraBytes + 1;
+
+      while (numBits > (8 - reservedBits)) {
+        numExtraBytes += 1;
+        numBits -= 8;
+        reservedBits = Math.min(numExtraBytes + 1, 8);
+        rv.push(v & 0xff);
+        v >>= 8;
+      }
+
+      if (numExtraBytes > 8) {
+        throw new Error(`Value ${val} is too big and cannot be encoded as vint`);
+      }
+
+      const n = 8 - numExtraBytes;
+      v |= (0xff >> n) << n;
+      rv.push(Math.abs(v));
+    }
+
+    rv.reverse();
+    return Buffer.from(rv);
+  }
+
+  return {
+    readVInt: readVInt,
+    writeVInt: writeVInt,
+    uvintPack: uvintPack,
+    uvintUnpack: uvintUnpack
+  };
+})();
+
 exports.adaptNamedParamsPrepared = adaptNamedParamsPrepared;
 exports.adaptNamedParamsWithHints = adaptNamedParamsWithHints;
 exports.AddressResolver = AddressResolver;
@@ -1084,4 +1414,5 @@ exports.timesSeries = timesSeries;
 exports.totalLength = totalLength;
 exports.validateFn = validateFn;
 exports.whilst = whilst;
-exports.HashSet = HashSet;
\ No newline at end of file
+exports.HashSet = HashSet;
+exports.VIntCoding = VIntCoding;
\ No newline at end of file
diff --git a/test/integration/short/vector-tests.js b/test/integration/short/vector-tests.js
new file mode 100644
index 00000000..77a3b522
--- /dev/null
+++ b/test/integration/short/vector-tests.js
@@ -0,0 +1,102 @@
+/*
+ * Copyright DataStax, Inc.
+ *
+ * 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.
+ */
+'use strict';
+const assert = require('assert');
+const helper = require('../../test-helper.js');
+
+const { types } = require('../../../index.js');
+const Vector = require('../../../lib/types/vector.js');
+const util = require('node:util');
+const vdescribe = helper.vdescribe;
+vdescribe('5.0.0', 'Vector tests', function () {
+  this.timeout(120000);
+
+  describe('#execute with vectors', function () {
+    const keyspace = helper.getRandomName('ks');
+    const table = keyspace + '.' + helper.getRandomName('table');
+    let createTableCql = `CREATE TABLE ${table} (id uuid PRIMARY KEY`;
+    helper.dataProviderWithCollections.forEach(data => {
+      // skip set<duration> because it's not allowed in C* 5.0
+      if (data.subtypeString === 'set<duration>') {
+        return;
+      }
+      createTableCql += `, ${subtypeStringToColumnName(data.subtypeString)} vector<${data.subtypeString}, 3>`;
+    });
+    createTableCql += ');';
+    const createUdtCql = `CREATE TYPE ${keyspace}.my_udt (f1 text);`;
+    const setupInfo = helper.setup(1, {
+      keyspace: keyspace,
+      queries: [createUdtCql, createTableCql]
+    });
+
+    const client = setupInfo.client;
+    if (!client) { throw new Error('client setup failed'); }
+
+    helper.dataProviderWithCollections.forEach(data => {
+      // skip set<duration> because it's not allowed in C* 5.0
+      if (data.subtypeString === 'set<duration>') {
+        return;
+      }
+      it('should insert, select, and update vector of subtype ' + data.subtypeString, function (done) {
+        const id = types.Uuid.random();
+        const vector = new Vector(data.value, data.subtypeString);
+        const query = `INSERT INTO ${table} (id, ${subtypeStringToColumnName(data.subtypeString)}) VALUES (?, ?)`;
+        client.execute(query, [id, vector], { prepare: true }, function (err) {
+          if (err) { return done(err); }
+          client.execute(`SELECT ${subtypeStringToColumnName(data.subtypeString)} FROM ${table} WHERE id = ?`, [id], { prepare: true }, function (err, result) {
+            if (err) { return done(err); }
+            assert.strictEqual(result.rows.length, 1);
+            assert.strictEqual(util.inspect(result.rows[0][subtypeStringToColumnName(data.subtypeString)]), util.inspect(vector));
+
+            const updatedValues = data.value.slice();
+            updatedValues[0] = updatedValues[1];
+            client.execute(`UPDATE ${table} SET ${subtypeStringToColumnName(data.subtypeString)} = ? WHERE id = ?`, [new Vector(updatedValues, data.subtypeString), id], { prepare: true }, function (err, result) {
+              if (err) { return done(err); }
+              done();
+            });
+          });
+        });
+      });
+
+      it('should insert and select vector of subtype ' + data.subtypeString + ' with prepare to be false', function (done) {
+        if (data.subtypeString === 'my_udt') {
+          this.skip();
+        }
+        const id = types.Uuid.random();
+        const vector = new Vector(data.value, data.subtypeString);
+        const query = `INSERT INTO ${table} (id, ${subtypeStringToColumnName(data.subtypeString)}) VALUES (?, ?)`;
+        client.execute(query, [id, vector], { prepare: false }, function (err) {
+          if (err) { return done(err); }
+          client.execute(`SELECT ${subtypeStringToColumnName(data.subtypeString)} FROM ${table} WHERE id = ?`, [id], { prepare: false }, function (err, result) {
+            if (err) { return done(err); }
+            assert.strictEqual(result.rows.length, 1);
+            assert.strictEqual(util.inspect(result.rows[0][subtypeStringToColumnName(data.subtypeString)]), util.inspect(vector));
+            done();
+          });
+        });
+      });
+    });
+  });
+});
+
+/**
+ * 
+ * @param {string} subtypeString 
+ * @returns 
+ */
+function subtypeStringToColumnName(subtypeString) {
+  return "v" + subtypeString.replace(/<|>|,| /g, '_');
+}
\ No newline at end of file
diff --git a/test/test-helper.js b/test/test-helper.js
index c342d1e3..2a01576b 100644
--- a/test/test-helper.js
+++ b/test/test-helper.js
@@ -22,6 +22,7 @@ const util = require('util');
 const path = require('path');
 const policies = require('../lib/policies');
 const types = require('../lib/types');
+// const { types } = require('../lib/types');
 const utils = require('../lib/utils');
 const spawn = require('child_process').spawn;
 const childProcessExec = require('child_process').exec;
@@ -32,6 +33,7 @@ const defaultOptions = require('../lib/client-options').defaultOptions;
 const { Host, HostMap } = require('../lib/host');
 const OperationState = require('../lib/operation-state');
 const promiseUtils = require('../lib/promise-utils');
+const Vector = types.Vector;
 
 util.inherits(RetryMultipleTimes, policies.retry.RetryPolicy);
 
@@ -1616,6 +1618,282 @@ helper.ads.getKrb5ConfigPath = function() {
   return path.join(this.dir, 'krb5.conf');
 };
 
+/**
+ * @type {Array<{subtypeString : string, typeInfo: import('../lib/encoder').VectorColumnInfo, value: Array}>}
+ */
+const dataProvider = [
+  {
+    subtypeString: 'float',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.float }, 3]
+    },
+    value: [1.1122000217437744, 2.212209939956665, 3.3999900817871094]
+  },
+  {
+    subtypeString: 'double',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.double }, 3]
+    },
+    value: [1.1, 2.2, 3.3]
+  },
+  {
+    subtypeString: 'varchar',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.text }, 3]
+    },
+    value: ['ab', 'b', 'cde']
+  },
+  {
+    subtypeString: 'bigint',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.bigint }, 3]
+    },
+    value: [new types.Long(1), new types.Long(2), new types.Long(3)]
+  },
+  {
+    subtypeString: 'blob',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.blob }, 3]
+    },
+    value: [Buffer.from([1, 2, 3]), Buffer.from([4, 5, 6]), Buffer.from([7, 8, 9])]
+  },
+  {
+    subtypeString: 'boolean',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.boolean }, 3]
+    },
+    value: [true, false, true]
+  },
+  {
+    subtypeString: 'decimal',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.decimal }, 3]
+    },
+    value: [types.BigDecimal.fromString('1.1'), types.BigDecimal.fromString('2.2'), types.BigDecimal.fromString('3.3')]
+  },
+  {
+    subtypeString: 'inet',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.inet }, 3]
+    },
+    value: [types.InetAddress.fromString('127.0.0.1'), types.InetAddress.fromString('0.0.0.0'), types.InetAddress.fromString('34.12.10.19')]
+  },
+  {
+    subtypeString: 'tinyint',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.tinyint }, 3]
+    },
+    value: [1, 2, 3]
+  },
+  {
+    subtypeString: 'smallint',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.smallint }, 3]
+    },
+    value: [1, 2, 3]
+  },
+  {
+    subtypeString: 'int',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.int }, 3]
+    },
+    value: [-1, 0, -3]
+  },
+  {
+    subtypeString: 'duration',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      info: [{
+        code: types.dataTypes.custom,
+        info: 'org.apache.cassandra.db.marshal.DurationType'
+      },3],
+      customTypeName: 'vector',
+    },
+    value: [new types.Duration(1, 2, 3), new types.Duration(4, 5, 6), new types.Duration(7, 8, 9)]
+  },
+  {
+    subtypeString: 'date',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.date }, 3]
+    },
+    value: [new types.LocalDate(2020, 1, 1), new types.LocalDate(2020, 2, 1), new types.LocalDate(2020, 3, 1)]
+  },
+  {
+    subtypeString: 'time',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.time }, 3]
+    },
+    value: [new types.LocalTime(types.Long.fromString('6331999999911')), new types.LocalTime(types.Long.fromString('6331999999911')), new types.LocalTime(types.Long.fromString('6331999999911'))]
+  },
+  {
+    subtypeString: 'timestamp',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.timestamp }, 3]
+    },
+    value: [new Date(2020, 1, 1, 1, 1, 1, 1), new Date(2020, 2, 1, 1, 1, 1, 1), new Date(2020, 3, 1, 1, 1, 1, 1)]
+  },
+  {
+    subtypeString: 'uuid',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.uuid }, 3]
+    },
+    value: [types.Uuid.random(), types.Uuid.random(), types.Uuid.random()]
+  },
+  {
+    subtypeString: 'timeuuid',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      customTypeName: 'vector',
+      info: [{ code: types.dataTypes.timeuuid }, 3]
+    },
+    value: [types.TimeUuid.now(), types.TimeUuid.now(), types.TimeUuid.now()]
+  }
+];
+
+helper.dataProvider = dataProvider;
+
+const dataProviderWithCollections = dataProvider.flatMap(data => [
+  data,
+  // vector<list<subtype>, 3>
+  {
+    subtypeString: 'list<' + data.subtypeString + '>',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      info: [{
+        code: types.dataTypes.list,
+        info: {
+          code: data.typeInfo.info[0].code,
+          info: data.typeInfo.info[0]["info"]
+        }
+      },3],
+      customTypeName: 'vector',
+    },
+    value: data.value.map(value => [value, value, value])
+  },
+  // vector<map<int, subtype>, 3>
+  {
+    subtypeString: 'map<int, ' + data.subtypeString + '>',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      info: [{
+        code: types.dataTypes.map,
+        info: [
+          { code: types.dataTypes.int },
+          {
+            code: data.typeInfo.info[0].code,
+            info: data.typeInfo.info[0]["info"]
+          }
+        ]
+      },3],
+      customTypeName: 'vector'
+    },
+    value: data.value.map((value) => ({ 1: value, 2: value, 3: value }))
+  },
+  // vector<set<subtype>, 3>
+  {
+    subtypeString: 'set<' + data.subtypeString + '>',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      info: [{
+        code: types.dataTypes.set,
+        info: {
+          code: data.typeInfo.info[0].code,
+          info: data.typeInfo.info[0]["info"]
+        }
+      },3],
+      customTypeName: 'vector',
+    },
+    value: data.value.map(value => [value, value, value])
+  },
+  // vector<tuple<subtype, subtype>, 3>
+  {
+    subtypeString: 'tuple<' + data.subtypeString + ', ' + data.subtypeString + '>',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      info: [{
+        code: types.dataTypes.tuple,
+        info: [
+          {
+            code: data.typeInfo.info[0].code,
+            info: data.typeInfo.info[0]["info"]
+          },
+          {
+            code: data.typeInfo.info[0].code,
+            info: data.typeInfo.info[0]["info"]
+          }
+        ]
+      },3],
+      customTypeName: 'vector',
+    },
+    value: data.value.map(value => new types.Tuple(value, value))
+  },
+  // vector<vector<subtype, 3>, 3>
+  {
+    subtypeString: 'vector<' + data.subtypeString + ', 3>',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      info: [{
+        code: types.dataTypes.custom,
+        info: [{
+          code: data.typeInfo.info[0].code,
+          info: data.typeInfo.info[0]["info"]
+        },3],
+        customTypeName: 'vector',
+      },3],
+      customTypeName: 'vector',
+    },
+    value: data.value.map(value => new Vector([value, value, value], data.subtypeString))
+  }
+]).concat([
+// vector<my_udt, 3>
+  {
+    subtypeString: 'my_udt',
+    typeInfo: {
+      code: types.dataTypes.custom,
+      info: [{
+        code: types.dataTypes.udt,
+        info: {
+          name: 'my_udt',
+          fields: [{ name: 'f1', type: { code: types.dataTypes.text } }],
+        }
+      }, 3],
+      customTypeName: 'vector',
+    },
+    value: [{ f1: 'a' }, { f1: 'b' }, { f1: 'c' }]
+  }
+]);
+
+helper.dataProviderWithCollections = dataProviderWithCollections;
 /**
  * A retry policy for testing purposes only, retries for a number of times
  * @param {Number} times
@@ -1762,6 +2040,8 @@ class OrderedLoadBalancingPolicy extends policies.loadBalancing.RoundRobinPolicy
   }
 }
 
+
+
 module.exports = helper;
 module.exports.RetryMultipleTimes = RetryMultipleTimes;
 module.exports.OrderedLoadBalancingPolicy = OrderedLoadBalancingPolicy;
diff --git a/test/unit/encoder-tests.js b/test/unit/encoder-tests.js
index 12b12395..354dcba9 100644
--- a/test/unit/encoder-tests.js
+++ b/test/unit/encoder-tests.js
@@ -20,9 +20,9 @@ const util = require('util');
 const utils = require('../../lib/utils');
 const tokenizer = require('../../lib/tokenizer');
 const token = require('../../lib/token');
-
+const Vector = require('../../lib/types/vector');
 const Encoder = require('../../lib/encoder');
-const types = require('../../lib/types');
+const { types } = require('../../index.js');
 const ExecutionOptions = require('../../lib/execution-options').ExecutionOptions;
 const dataTypes = types.dataTypes;
 const helper = require('../test-helper');
@@ -96,7 +96,7 @@ describe('encoder', function () {
   describe('#encode() and #decode()', function () {
     const typeEncoder = new Encoder(2, {});
     it('should encode and decode a guessed double', function () {
-      const value = 1111;
+      const value = 1111.1;
       const encoded = typeEncoder.encode(value);
       const decoded = typeEncoder.decode(encoded, {code: dataTypes.double});
       assert.strictEqual(decoded, value);
@@ -683,37 +683,44 @@ describe('encoder', function () {
       const encoder = new Encoder(4, {});
       const refVal = new Float32Array([1.2, 3.4, 5.6]);
       const guessedTypeObj = Encoder.guessDataType(refVal);
+      if (guessedTypeObj == null){
+        assert.fail();
+      }
       const encoded = encoder.encode(refVal, guessedTypeObj);
       const decoded = encoder.decode(encoded, guessedTypeObj);
-      helper.assertInstanceOf(decoded, Float32Array);
-      for (const k in decoded) {
-        if (decoded.hasOwnProperty(k)) {
-          assert.equal(decoded[k],refVal[k]);
-        }
-        else {
-          assert.fail();
-        }
+      helper.assertInstanceOf(decoded, Vector);
+      for (let i = 0; i < decoded.length; i++) {
+        assert.strictEqual(decoded[i],refVal[i]);
       }
     });
 
     it('should encode/decode FloatArray as vector, encoder provided with full type', function () {
       const encoder = new Encoder(4, {});
       const refVal = new Float32Array([1.2, 3.4, 5.6]);
-      const typeName = 'org.apache.cassandra.db.marshal.VectorType(org.apache.cassandra.db.marshal.FloatType,3)';
-      const typeObj = {code: dataTypes.custom, info: typeName};
+      /** @type {import('../../lib/encoder').VectorColumnInfo} */
+      const typeObj = {code: dataTypes.custom, info: [{code : dataTypes.float},3], customTypeName : 'vector'};
       const encoded = encoder.encode(refVal, typeObj);
       const decoded = encoder.decode(encoded, typeObj);
-      helper.assertInstanceOf(decoded, Float32Array);
-      for (const k in decoded) {
-        if (decoded.hasOwnProperty(k)) {
-          assert.equal(decoded[k],refVal[k]);
-        }
-        else {
-          assert.fail();
-        }
+      helper.assertInstanceOf(decoded, Vector);
+      for (let i = 0; i < decoded.length; i++) {
+        assert.strictEqual(decoded[i],refVal[i]);
       }
     });
 
+    it('should encode/decode Vector of texts as vector, encoder provided with full type', function () {
+      const encoder = new Encoder(4, {});
+      const refVal = new Vector(['a', 'bc', 'de']);
+      /** @type {import('../../lib/encoder').VectorColumnInfo} */
+      const typeObj = {code: dataTypes.custom, info: [{code : dataTypes.ascii},3], customTypeName : 'vector'};
+      const encoded = encoder.encode(refVal, typeObj);
+      const decoded = encoder.decode(encoded, typeObj);
+      helper.assertInstanceOf(decoded, Vector);
+      for (let k = 0; k < decoded.length; k++) {
+        assert.strictEqual(decoded[k],refVal[k]);
+      }
+    });
+
+
     it('should fail to encode if full type provided and input vector fails to match dimensions of type', function () {
       const encoder = new Encoder(4, {});
       const refVal = new Float32Array([1.2, 3.4, 5.6, 7.8]);
@@ -735,12 +742,24 @@ describe('encoder', function () {
       assert.throws(function() { encoder.encode(refVal, {code: dataTypes.custom, info: typeName}); }, TypeError);
     });
 
-    it('should fail to encode if full type provided and subtype is not FloatType', function () {
+    it('should encode/decode nested type as vector, encoder guesses type', function () {
       const encoder = new Encoder(4, {});
-      const refVal = new Float32Array([1, 2, 3]);
-      const typeName = 'org.apache.cassandra.db.marshal.VectorType(org.apache.cassandra.db.marshal.Int32Type,3)';
-      assert.throws(function() { encoder.encode(refVal, {code: dataTypes.custom, info: typeName}); }, TypeError);
+      const refVal = new Vector([new Float32Array([1.2, 3.4, 5.6]), new Float32Array([7.8, 9.0, 11.2])]);
+      const guessedTypeObj = Encoder.guessDataType(refVal);
+      if (guessedTypeObj == null){
+        assert.fail();
+        return;
+      }
+      const encoded = encoder.encode(refVal, guessedTypeObj);
+      const decoded = encoder.decode(encoded, guessedTypeObj);
+      helper.assertInstanceOf(decoded, Vector);
+      for (let i = 0; i < decoded.length; i++) {
+        for (let j = 0; j < decoded[i].length; j++) {
+          assert.strictEqual(decoded[i][j],refVal[i][j]);
+        }
+      }
     });
+
   });
 
   describe('#encode()', function () {
@@ -1090,9 +1109,8 @@ describe('encoder', function () {
       type = encoder.parseFqTypeName('org.apache.cassandra.db.marshal.VectorType(org.apache.cassandra.db.marshal.FloatType,10)');
       assert.strictEqual(dataTypes.custom, type.code);
       assert.ok(typeof type.info === 'object');
-      assert.strictEqual(Object.keys(type.info).length, 2);
-      assert.strictEqual(dataTypes.float, type.info["subtype"].code);
-      assert.strictEqual(10, type.info["dimensions"]);
+      assert.strictEqual(dataTypes.float, type.info[0].code);
+      assert.strictEqual(10, type.info[1]);
     });
 
     it('should parse frozen types', function () {
@@ -1208,7 +1226,7 @@ describe('encoder', function () {
         ['tuple<varchar,int>', dataTypes.tuple, [dataTypes.varchar, dataTypes.int]],
         ['frozen<list<timeuuid>>', dataTypes.list, dataTypes.timeuuid],
         ['map<text,frozen<list<int>>>', dataTypes.map, [dataTypes.text, dataTypes.list]],
-        ['vector<float,20>', dataTypes.custom, {subtype: {code: dataTypes.float}, dimensions: 20}]
+        ['vector<float,20>', dataTypes.custom, {code: dataTypes.float, dimension: 20}]
       ];
 
       for (const item of items) {
@@ -1224,8 +1242,8 @@ describe('encoder', function () {
           });
         }
         else if (typeof item[2] === 'object') {
-          assert.strictEqual(dataType.info.subtype.code, item[2].subtype.code);
-          assert.strictEqual(dataType.info.dimensions, item[2].dimensions);
+          assert.strictEqual(dataType.info[0].code, item[2].code);
+          assert.strictEqual(dataType.info[1], item[2].dimension);
         }
         else {
           assert.strictEqual(dataType.info.code, item[2]);
diff --git a/test/unit/encoder-vector-tests.js b/test/unit/encoder-vector-tests.js
new file mode 100644
index 00000000..4b3cc356
--- /dev/null
+++ b/test/unit/encoder-vector-tests.js
@@ -0,0 +1,74 @@
+/*
+ * Copyright DataStax, Inc.
+ *
+ * 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.
+ */
+'use strict';
+const { assert, util } = require('chai');
+const Encoder = require('../../lib/encoder');
+const { types } = require('../../index');
+const Vector = require('../../lib/types/vector');
+const helper = require('../test-helper');
+
+describe('Vector tests', function () {
+  const encoder = new Encoder(4, {});
+
+  helper.dataProviderWithCollections.forEach((data) => {
+    it(`should encode and decode vector of ${data.subtypeString}`, function () {
+      const vector = new Vector(data.value, data.subtypeString);
+      const encoded = encoder.encode(vector, data.typeInfo);
+      const decoded = encoder.decode(encoded, data.typeInfo);
+      assert.strictEqual(util.inspect(decoded), util.inspect(vector));
+    });
+
+    it(`should encode and decode vector of ${data.subtypeString} while guessing data type`, function (){
+      if (data.subtypeString === 'my_udt'){
+        // cannot guess udt type
+        this.skip();
+      }
+      const vector = new Vector(data.value, data.subtypeString);
+      const guessedType = Encoder.guessDataType(vector);
+      if (!guessedType) {
+        throw new Error('Can not guess type');
+      }
+      const encoded = encoder.encode(vector, guessedType);
+      const decoded = encoder.decode(encoded, guessedType);
+      assert.strictEqual(util.inspect(decoded), util.inspect(vector));
+    });
+
+    it(`should throw when providing less or more elements/bytes when encoding/decoding vector of ${data.subtypeString}`, function () {
+      const vector = new Vector(data.value, data.subtypeString);
+      const encoded = encoder.encode(vector, data.typeInfo);
+      const encodedBuffer = Buffer.from(encoded);
+      const encodedBufferShort = encodedBuffer.slice(0, encodedBuffer.length - 1);
+      const encodedBufferLong = Buffer.concat([encodedBuffer, Buffer.alloc(1)]);
+      assert.throws(() => encoder.decode(encodedBufferShort, data.typeInfo), 'Not enough bytes to decode the vector');
+      assert.throws(() => encoder.decode(encodedBufferLong, data.typeInfo), 'Extra bytes found after decoding the vector');
+
+      const shortVector = new Vector(data.value.slice(0, data.value.length - 1), data.subtypeString);
+      const longVector = new Vector(data.value.concat(data.value), data.subtypeString);
+      assert.throws(() => encoder.encode(shortVector, data.typeInfo), 'Expected vector with 3 dimensions, observed size of 2');
+      assert.throws(() => encoder.encode(longVector, data.typeInfo), 'Expected vector with 3 dimensions, observed size of 6');
+    });
+  });
+
+  it('should encode and decode vector of float', function(){
+    const vector = new Float32Array([1.1, 2.2, 3.3]);
+    const typeObj = { code: types.dataTypes.custom, info: [{code: types.dataTypes.float}, 3], customTypeName: 'vector' };
+    const encoded = encoder.encode(vector, typeObj);
+    const decoded = encoder.decode(encoded, typeObj);
+    for (let i = 0; i < vector.length; i++) {
+      assert.strictEqual(decoded[i], vector[i]);
+    }
+  });
+});
\ No newline at end of file