kvclient-js/lib/thrift/ondb_types.js

Oracle NoSQL Database node.js Client API.

//
// Autogenerated by Thrift Compiler (0.9.2)
//
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
//
var thrift = require('thrift');
var Thrift = thrift.Thrift;
var Q = thrift.Q;


var ttypes = module.exports = {};
ttypes.TModuleInfo = {
  'PROXY_SERVER' : 2,
  'JAVA_CLIENT' : 3
};
ttypes.TVerifyError = {
  'INVALID_KVSTORE_Name' : 1,
  'INVALID_KVSTORE_HelperHosts' : 2
};
ttypes.TSyncPolicy = {
  'NO_SYNC' : 1,
  'SYNC' : 2,
  'WRITE_NO_SYNC' : 3
};
ttypes.TReplicaAckPolicy = {
  'ALL' : 1,
  'NONE' : 2,
  'SIMPLE_MAJORITY' : 3
};
ttypes.TReturnChoice = {
  'ALL' : 1,
  'NONE' : 2,
  'VALUE' : 3,
  'VERSION' : 4
};
ttypes.TSimpleConsistency = {
  'ABSOLUTE' : 1,
  'NONE_REQUIRED' : 2,
  'NONE_REQUIRED_NO_MASTER' : 3
};
ttypes.TDirection = {
  'FORWARD' : 1,
  'REVERSE' : 2,
  'UNORDERED' : 3
};
ttypes.TOperationType = {
  'DELETE' : 1,
  'DELETE_IF_VERSION' : 2,
  'PUT' : 3,
  'PUT_IF_ABSENT' : 4,
  'PUT_IF_PRESENT' : 5,
  'PUT_IF_VERSION' : 6
};
TVerifyProperties = module.exports.TVerifyProperties = function(args) {
  this.kvStoreName = null;
  this.kvStoreHelperHosts = null;
  this.username = null;
  this.readZones = null;
  if (args) {
    if (args.kvStoreName !== undefined) {
      this.kvStoreName = args.kvStoreName;
    }
    if (args.kvStoreHelperHosts !== undefined) {
      this.kvStoreHelperHosts = args.kvStoreHelperHosts;
    }
    if (args.username !== undefined) {
      this.username = args.username;
    }
    if (args.readZones !== undefined) {
      this.readZones = args.readZones;
    }
  }
};
TVerifyProperties.prototype = {};
TVerifyProperties.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.kvStoreName = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.LIST) {
        var _size0 = 0;
        var _rtmp34;
        this.kvStoreHelperHosts = [];
        var _etype3 = 0;
        _rtmp34 = input.readListBegin();
        _etype3 = _rtmp34.etype;
        _size0 = _rtmp34.size;
        for (var _i5 = 0; _i5 < _size0; ++_i5)
        {
          var elem6 = null;
          elem6 = input.readString();
          this.kvStoreHelperHosts.push(elem6);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.username = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.LIST) {
        var _size7 = 0;
        var _rtmp311;
        this.readZones = [];
        var _etype10 = 0;
        _rtmp311 = input.readListBegin();
        _etype10 = _rtmp311.etype;
        _size7 = _rtmp311.size;
        for (var _i12 = 0; _i12 < _size7; ++_i12)
        {
          var elem13 = null;
          elem13 = input.readString();
          this.readZones.push(elem13);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TVerifyProperties.prototype.write = function(output) {
  output.writeStructBegin('TVerifyProperties');
  if (this.kvStoreName !== null && this.kvStoreName !== undefined) {
    output.writeFieldBegin('kvStoreName', Thrift.Type.STRING, 1);
    output.writeString(this.kvStoreName);
    output.writeFieldEnd();
  }
  if (this.kvStoreHelperHosts !== null && this.kvStoreHelperHosts !== undefined) {
    output.writeFieldBegin('kvStoreHelperHosts', Thrift.Type.LIST, 2);
    output.writeListBegin(Thrift.Type.STRING, this.kvStoreHelperHosts.length);
    for (var iter14 in this.kvStoreHelperHosts)
    {
      if (this.kvStoreHelperHosts.hasOwnProperty(iter14))
      {
        iter14 = this.kvStoreHelperHosts[iter14];
        output.writeString(iter14);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.username !== null && this.username !== undefined) {
    output.writeFieldBegin('username', Thrift.Type.STRING, 3);
    output.writeString(this.username);
    output.writeFieldEnd();
  }
  if (this.readZones !== null && this.readZones !== undefined) {
    output.writeFieldBegin('readZones', Thrift.Type.LIST, 4);
    output.writeListBegin(Thrift.Type.STRING, this.readZones.length);
    for (var iter15 in this.readZones)
    {
      if (this.readZones.hasOwnProperty(iter15))
      {
        iter15 = this.readZones[iter15];
        output.writeString(iter15);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TVerifyResult = module.exports.TVerifyResult = function(args) {
  this.isConnected = null;
  this.errorType = null;
  this.message = null;
  if (args) {
    if (args.isConnected !== undefined) {
      this.isConnected = args.isConnected;
    }
    if (args.errorType !== undefined) {
      this.errorType = args.errorType;
    }
    if (args.message !== undefined) {
      this.message = args.message;
    }
  }
};
TVerifyResult.prototype = {};
TVerifyResult.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.BOOL) {
        this.isConnected = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I32) {
        this.errorType = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.message = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TVerifyResult.prototype.write = function(output) {
  output.writeStructBegin('TVerifyResult');
  if (this.isConnected !== null && this.isConnected !== undefined) {
    output.writeFieldBegin('isConnected', Thrift.Type.BOOL, 1);
    output.writeBool(this.isConnected);
    output.writeFieldEnd();
  }
  if (this.errorType !== null && this.errorType !== undefined) {
    output.writeFieldBegin('errorType', Thrift.Type.I32, 2);
    output.writeI32(this.errorType);
    output.writeFieldEnd();
  }
  if (this.message !== null && this.message !== undefined) {
    output.writeFieldBegin('message', Thrift.Type.STRING, 3);
    output.writeString(this.message);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TDurability = module.exports.TDurability = function(args) {
  this.masterSync = null;
  this.replicaAck = null;
  this.replicaSync = null;
  if (args) {
    if (args.masterSync !== undefined) {
      this.masterSync = args.masterSync;
    }
    if (args.replicaAck !== undefined) {
      this.replicaAck = args.replicaAck;
    }
    if (args.replicaSync !== undefined) {
      this.replicaSync = args.replicaSync;
    }
  }
};
TDurability.prototype = {};
TDurability.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.I32) {
        this.masterSync = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I32) {
        this.replicaAck = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.I32) {
        this.replicaSync = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TDurability.prototype.write = function(output) {
  output.writeStructBegin('TDurability');
  if (this.masterSync !== null && this.masterSync !== undefined) {
    output.writeFieldBegin('masterSync', Thrift.Type.I32, 1);
    output.writeI32(this.masterSync);
    output.writeFieldEnd();
  }
  if (this.replicaAck !== null && this.replicaAck !== undefined) {
    output.writeFieldBegin('replicaAck', Thrift.Type.I32, 2);
    output.writeI32(this.replicaAck);
    output.writeFieldEnd();
  }
  if (this.replicaSync !== null && this.replicaSync !== undefined) {
    output.writeFieldBegin('replicaSync', Thrift.Type.I32, 3);
    output.writeI32(this.replicaSync);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TWriteOptions = module.exports.TWriteOptions = function(args) {
  this.durability = null;
  this.timeoutMs = null;
  this.returnChoice = null;
  if (args) {
    if (args.durability !== undefined) {
      this.durability = args.durability;
    }
    if (args.timeoutMs !== undefined) {
      this.timeoutMs = args.timeoutMs;
    }
    if (args.returnChoice !== undefined) {
      this.returnChoice = args.returnChoice;
    }
  }
};
TWriteOptions.prototype = {};
TWriteOptions.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.durability = new ttypes.TDurability();
        this.durability.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I64) {
        this.timeoutMs = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.I32) {
        this.returnChoice = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TWriteOptions.prototype.write = function(output) {
  output.writeStructBegin('TWriteOptions');
  if (this.durability !== null && this.durability !== undefined) {
    output.writeFieldBegin('durability', Thrift.Type.STRUCT, 1);
    this.durability.write(output);
    output.writeFieldEnd();
  }
  if (this.timeoutMs !== null && this.timeoutMs !== undefined) {
    output.writeFieldBegin('timeoutMs', Thrift.Type.I64, 2);
    output.writeI64(this.timeoutMs);
    output.writeFieldEnd();
  }
  if (this.returnChoice !== null && this.returnChoice !== undefined) {
    output.writeFieldBegin('returnChoice', Thrift.Type.I32, 3);
    output.writeI32(this.returnChoice);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TTimeConsistency = module.exports.TTimeConsistency = function(args) {
  this.permissibleLag = null;
  this.timeoutMs = null;
  if (args) {
    if (args.permissibleLag !== undefined) {
      this.permissibleLag = args.permissibleLag;
    }
    if (args.timeoutMs !== undefined) {
      this.timeoutMs = args.timeoutMs;
    }
  }
};
TTimeConsistency.prototype = {};
TTimeConsistency.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.I64) {
        this.permissibleLag = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I64) {
        this.timeoutMs = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TTimeConsistency.prototype.write = function(output) {
  output.writeStructBegin('TTimeConsistency');
  if (this.permissibleLag !== null && this.permissibleLag !== undefined) {
    output.writeFieldBegin('permissibleLag', Thrift.Type.I64, 1);
    output.writeI64(this.permissibleLag);
    output.writeFieldEnd();
  }
  if (this.timeoutMs !== null && this.timeoutMs !== undefined) {
    output.writeFieldBegin('timeoutMs', Thrift.Type.I64, 2);
    output.writeI64(this.timeoutMs);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TVersionConsistency = module.exports.TVersionConsistency = function(args) {
  this.version = null;
  this.timeoutMs = null;
  if (args) {
    if (args.version !== undefined) {
      this.version = args.version;
    }
    if (args.timeoutMs !== undefined) {
      this.timeoutMs = args.timeoutMs;
    }
  }
};
TVersionConsistency.prototype = {};
TVersionConsistency.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.version = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I64) {
        this.timeoutMs = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TVersionConsistency.prototype.write = function(output) {
  output.writeStructBegin('TVersionConsistency');
  if (this.version !== null && this.version !== undefined) {
    output.writeFieldBegin('version', Thrift.Type.STRING, 1);
    output.writeBinary(this.version);
    output.writeFieldEnd();
  }
  if (this.timeoutMs !== null && this.timeoutMs !== undefined) {
    output.writeFieldBegin('timeoutMs', Thrift.Type.I64, 2);
    output.writeI64(this.timeoutMs);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TConsistency = module.exports.TConsistency = function(args) {
  this.simple = null;
  this.time = null;
  this.version = null;
  if (args) {
    if (args.simple !== undefined) {
      this.simple = args.simple;
    }
    if (args.time !== undefined) {
      this.time = args.time;
    }
    if (args.version !== undefined) {
      this.version = args.version;
    }
  }
};
TConsistency.prototype = {};
TConsistency.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.I32) {
        this.simple = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.time = new ttypes.TTimeConsistency();
        this.time.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRUCT) {
        this.version = new ttypes.TVersionConsistency();
        this.version.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TConsistency.prototype.write = function(output) {
  output.writeStructBegin('TConsistency');
  if (this.simple !== null && this.simple !== undefined) {
    output.writeFieldBegin('simple', Thrift.Type.I32, 1);
    output.writeI32(this.simple);
    output.writeFieldEnd();
  }
  if (this.time !== null && this.time !== undefined) {
    output.writeFieldBegin('time', Thrift.Type.STRUCT, 2);
    this.time.write(output);
    output.writeFieldEnd();
  }
  if (this.version !== null && this.version !== undefined) {
    output.writeFieldBegin('version', Thrift.Type.STRUCT, 3);
    this.version.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TReadOptions = module.exports.TReadOptions = function(args) {
  this.consistency = null;
  this.timeoutMs = null;
  if (args) {
    if (args.consistency !== undefined) {
      this.consistency = args.consistency;
    }
    if (args.timeoutMs !== undefined) {
      this.timeoutMs = args.timeoutMs;
    }
  }
};
TReadOptions.prototype = {};
TReadOptions.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.consistency = new ttypes.TConsistency();
        this.consistency.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I64) {
        this.timeoutMs = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TReadOptions.prototype.write = function(output) {
  output.writeStructBegin('TReadOptions');
  if (this.consistency !== null && this.consistency !== undefined) {
    output.writeFieldBegin('consistency', Thrift.Type.STRUCT, 1);
    this.consistency.write(output);
    output.writeFieldEnd();
  }
  if (this.timeoutMs !== null && this.timeoutMs !== undefined) {
    output.writeFieldBegin('timeoutMs', Thrift.Type.I64, 2);
    output.writeI64(this.timeoutMs);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TRow = module.exports.TRow = function(args) {
  this.jsonRow = null;
  if (args) {
    if (args.jsonRow !== undefined) {
      this.jsonRow = args.jsonRow;
    }
  }
};
TRow.prototype = {};
TRow.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.jsonRow = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TRow.prototype.write = function(output) {
  output.writeStructBegin('TRow');
  if (this.jsonRow !== null && this.jsonRow !== undefined) {
    output.writeFieldBegin('jsonRow', Thrift.Type.STRING, 1);
    output.writeString(this.jsonRow);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TWriteResult = module.exports.TWriteResult = function(args) {
  this.currentRowVersion = null;
  this.previousRow = null;
  this.previousRowVersion = null;
  this.wasDeleted = null;
  if (args) {
    if (args.currentRowVersion !== undefined) {
      this.currentRowVersion = args.currentRowVersion;
    }
    if (args.previousRow !== undefined) {
      this.previousRow = args.previousRow;
    }
    if (args.previousRowVersion !== undefined) {
      this.previousRowVersion = args.previousRowVersion;
    }
    if (args.wasDeleted !== undefined) {
      this.wasDeleted = args.wasDeleted;
    }
  }
};
TWriteResult.prototype = {};
TWriteResult.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.currentRowVersion = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.previousRow = new ttypes.TRow();
        this.previousRow.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.previousRowVersion = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.BOOL) {
        this.wasDeleted = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TWriteResult.prototype.write = function(output) {
  output.writeStructBegin('TWriteResult');
  if (this.currentRowVersion !== null && this.currentRowVersion !== undefined) {
    output.writeFieldBegin('currentRowVersion', Thrift.Type.STRING, 1);
    output.writeBinary(this.currentRowVersion);
    output.writeFieldEnd();
  }
  if (this.previousRow !== null && this.previousRow !== undefined) {
    output.writeFieldBegin('previousRow', Thrift.Type.STRUCT, 2);
    this.previousRow.write(output);
    output.writeFieldEnd();
  }
  if (this.previousRowVersion !== null && this.previousRowVersion !== undefined) {
    output.writeFieldBegin('previousRowVersion', Thrift.Type.STRING, 3);
    output.writeBinary(this.previousRowVersion);
    output.writeFieldEnd();
  }
  if (this.wasDeleted !== null && this.wasDeleted !== undefined) {
    output.writeFieldBegin('wasDeleted', Thrift.Type.BOOL, 4);
    output.writeBool(this.wasDeleted);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TGetResult = module.exports.TGetResult = function(args) {
  this.currentRow = null;
  this.currentRowVersion = null;
  if (args) {
    if (args.currentRow !== undefined) {
      this.currentRow = args.currentRow;
    }
    if (args.currentRowVersion !== undefined) {
      this.currentRowVersion = args.currentRowVersion;
    }
  }
};
TGetResult.prototype = {};
TGetResult.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.currentRow = new ttypes.TRow();
        this.currentRow.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.currentRowVersion = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TGetResult.prototype.write = function(output) {
  output.writeStructBegin('TGetResult');
  if (this.currentRow !== null && this.currentRow !== undefined) {
    output.writeFieldBegin('currentRow', Thrift.Type.STRUCT, 1);
    this.currentRow.write(output);
    output.writeFieldEnd();
  }
  if (this.currentRowVersion !== null && this.currentRowVersion !== undefined) {
    output.writeFieldBegin('currentRowVersion', Thrift.Type.STRING, 2);
    output.writeBinary(this.currentRowVersion);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TFieldRange = module.exports.TFieldRange = function(args) {
  this.fieldName = null;
  this.startValue = null;
  this.startIsInclusive = null;
  this.endValue = null;
  this.endIsInclusive = null;
  if (args) {
    if (args.fieldName !== undefined) {
      this.fieldName = args.fieldName;
    }
    if (args.startValue !== undefined) {
      this.startValue = args.startValue;
    }
    if (args.startIsInclusive !== undefined) {
      this.startIsInclusive = args.startIsInclusive;
    }
    if (args.endValue !== undefined) {
      this.endValue = args.endValue;
    }
    if (args.endIsInclusive !== undefined) {
      this.endIsInclusive = args.endIsInclusive;
    }
  }
};
TFieldRange.prototype = {};
TFieldRange.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.fieldName = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.startValue = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.BOOL) {
        this.startIsInclusive = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRING) {
        this.endValue = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.BOOL) {
        this.endIsInclusive = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TFieldRange.prototype.write = function(output) {
  output.writeStructBegin('TFieldRange');
  if (this.fieldName !== null && this.fieldName !== undefined) {
    output.writeFieldBegin('fieldName', Thrift.Type.STRING, 1);
    output.writeString(this.fieldName);
    output.writeFieldEnd();
  }
  if (this.startValue !== null && this.startValue !== undefined) {
    output.writeFieldBegin('startValue', Thrift.Type.STRING, 2);
    output.writeString(this.startValue);
    output.writeFieldEnd();
  }
  if (this.startIsInclusive !== null && this.startIsInclusive !== undefined) {
    output.writeFieldBegin('startIsInclusive', Thrift.Type.BOOL, 3);
    output.writeBool(this.startIsInclusive);
    output.writeFieldEnd();
  }
  if (this.endValue !== null && this.endValue !== undefined) {
    output.writeFieldBegin('endValue', Thrift.Type.STRING, 4);
    output.writeString(this.endValue);
    output.writeFieldEnd();
  }
  if (this.endIsInclusive !== null && this.endIsInclusive !== undefined) {
    output.writeFieldBegin('endIsInclusive', Thrift.Type.BOOL, 5);
    output.writeBool(this.endIsInclusive);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TRowAndMetadata = module.exports.TRowAndMetadata = function(args) {
  this.jsonRow = null;
  this.rowVersion = null;
  this.tableId = null;
  if (args) {
    if (args.jsonRow !== undefined) {
      this.jsonRow = args.jsonRow;
    }
    if (args.rowVersion !== undefined) {
      this.rowVersion = args.rowVersion;
    }
    if (args.tableId !== undefined) {
      this.tableId = args.tableId;
    }
  }
};
TRowAndMetadata.prototype = {};
TRowAndMetadata.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.jsonRow = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.rowVersion = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.I32) {
        this.tableId = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TRowAndMetadata.prototype.write = function(output) {
  output.writeStructBegin('TRowAndMetadata');
  if (this.jsonRow !== null && this.jsonRow !== undefined) {
    output.writeFieldBegin('jsonRow', Thrift.Type.STRING, 1);
    output.writeString(this.jsonRow);
    output.writeFieldEnd();
  }
  if (this.rowVersion !== null && this.rowVersion !== undefined) {
    output.writeFieldBegin('rowVersion', Thrift.Type.STRING, 2);
    output.writeBinary(this.rowVersion);
    output.writeFieldEnd();
  }
  if (this.tableId !== null && this.tableId !== undefined) {
    output.writeFieldBegin('tableId', Thrift.Type.I32, 3);
    output.writeI32(this.tableId);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TMultiGetResult = module.exports.TMultiGetResult = function(args) {
  this.idToTableNames = null;
  this.rowsWithMetadata = null;
  if (args) {
    if (args.idToTableNames !== undefined) {
      this.idToTableNames = args.idToTableNames;
    }
    if (args.rowsWithMetadata !== undefined) {
      this.rowsWithMetadata = args.rowsWithMetadata;
    }
  }
};
TMultiGetResult.prototype = {};
TMultiGetResult.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.MAP) {
        var _size16 = 0;
        var _rtmp320;
        this.idToTableNames = {};
        var _ktype17 = 0;
        var _vtype18 = 0;
        _rtmp320 = input.readMapBegin();
        _ktype17 = _rtmp320.ktype;
        _vtype18 = _rtmp320.vtype;
        _size16 = _rtmp320.size;
        for (var _i21 = 0; _i21 < _size16; ++_i21)
        {
          var key22 = null;
          var val23 = null;
          key22 = input.readI32();
          val23 = input.readString();
          this.idToTableNames[key22] = val23;
        }
        input.readMapEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.LIST) {
        var _size24 = 0;
        var _rtmp328;
        this.rowsWithMetadata = [];
        var _etype27 = 0;
        _rtmp328 = input.readListBegin();
        _etype27 = _rtmp328.etype;
        _size24 = _rtmp328.size;
        for (var _i29 = 0; _i29 < _size24; ++_i29)
        {
          var elem30 = null;
          elem30 = new ttypes.TRowAndMetadata();
          elem30.read(input);
          this.rowsWithMetadata.push(elem30);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TMultiGetResult.prototype.write = function(output) {
  output.writeStructBegin('TMultiGetResult');
  if (this.idToTableNames !== null && this.idToTableNames !== undefined) {
    output.writeFieldBegin('idToTableNames', Thrift.Type.MAP, 1);
    output.writeMapBegin(Thrift.Type.I32, Thrift.Type.STRING, Thrift.objectLength(this.idToTableNames));
    for (var kiter31 in this.idToTableNames)
    {
      if (this.idToTableNames.hasOwnProperty(kiter31))
      {
        var viter32 = this.idToTableNames[kiter31];
        output.writeI32(kiter31);
        output.writeString(viter32);
      }
    }
    output.writeMapEnd();
    output.writeFieldEnd();
  }
  if (this.rowsWithMetadata !== null && this.rowsWithMetadata !== undefined) {
    output.writeFieldBegin('rowsWithMetadata', Thrift.Type.LIST, 2);
    output.writeListBegin(Thrift.Type.STRUCT, this.rowsWithMetadata.length);
    for (var iter33 in this.rowsWithMetadata)
    {
      if (this.rowsWithMetadata.hasOwnProperty(iter33))
      {
        iter33 = this.rowsWithMetadata[iter33];
        iter33.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TIteratorResult = module.exports.TIteratorResult = function(args) {
  this.iteratorId = null;
  this.result = null;
  this.hasMore = null;
  if (args) {
    if (args.iteratorId !== undefined) {
      this.iteratorId = args.iteratorId;
    }
    if (args.result !== undefined) {
      this.result = args.result;
    }
    if (args.hasMore !== undefined) {
      this.hasMore = args.hasMore;
    }
  }
};
TIteratorResult.prototype = {};
TIteratorResult.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.I64) {
        this.iteratorId = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.result = new ttypes.TMultiGetResult();
        this.result.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.BOOL) {
        this.hasMore = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TIteratorResult.prototype.write = function(output) {
  output.writeStructBegin('TIteratorResult');
  if (this.iteratorId !== null && this.iteratorId !== undefined) {
    output.writeFieldBegin('iteratorId', Thrift.Type.I64, 1);
    output.writeI64(this.iteratorId);
    output.writeFieldEnd();
  }
  if (this.result !== null && this.result !== undefined) {
    output.writeFieldBegin('result', Thrift.Type.STRUCT, 2);
    this.result.write(output);
    output.writeFieldEnd();
  }
  if (this.hasMore !== null && this.hasMore !== undefined) {
    output.writeFieldBegin('hasMore', Thrift.Type.BOOL, 3);
    output.writeBool(this.hasMore);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TStatementResult = module.exports.TStatementResult = function(args) {
  this.planId = null;
  this.info = null;
  this.infoAsJson = null;
  this.isSuccessful = null;
  this.errorMessage = null;
  this.isCancelled = null;
  this.isDone = null;
  if (args) {
    if (args.planId !== undefined) {
      this.planId = args.planId;
    }
    if (args.info !== undefined) {
      this.info = args.info;
    }
    if (args.infoAsJson !== undefined) {
      this.infoAsJson = args.infoAsJson;
    }
    if (args.isSuccessful !== undefined) {
      this.isSuccessful = args.isSuccessful;
    }
    if (args.errorMessage !== undefined) {
      this.errorMessage = args.errorMessage;
    }
    if (args.isCancelled !== undefined) {
      this.isCancelled = args.isCancelled;
    }
    if (args.isDone !== undefined) {
      this.isDone = args.isDone;
    }
  }
};
TStatementResult.prototype = {};
TStatementResult.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.I32) {
        this.planId = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.info = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.infoAsJson = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.BOOL) {
        this.isSuccessful = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.STRING) {
        this.errorMessage = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 6:
      if (ftype == Thrift.Type.BOOL) {
        this.isCancelled = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 7:
      if (ftype == Thrift.Type.BOOL) {
        this.isDone = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TStatementResult.prototype.write = function(output) {
  output.writeStructBegin('TStatementResult');
  if (this.planId !== null && this.planId !== undefined) {
    output.writeFieldBegin('planId', Thrift.Type.I32, 1);
    output.writeI32(this.planId);
    output.writeFieldEnd();
  }
  if (this.info !== null && this.info !== undefined) {
    output.writeFieldBegin('info', Thrift.Type.STRING, 2);
    output.writeString(this.info);
    output.writeFieldEnd();
  }
  if (this.infoAsJson !== null && this.infoAsJson !== undefined) {
    output.writeFieldBegin('infoAsJson', Thrift.Type.STRING, 3);
    output.writeString(this.infoAsJson);
    output.writeFieldEnd();
  }
  if (this.isSuccessful !== null && this.isSuccessful !== undefined) {
    output.writeFieldBegin('isSuccessful', Thrift.Type.BOOL, 4);
    output.writeBool(this.isSuccessful);
    output.writeFieldEnd();
  }
  if (this.errorMessage !== null && this.errorMessage !== undefined) {
    output.writeFieldBegin('errorMessage', Thrift.Type.STRING, 5);
    output.writeString(this.errorMessage);
    output.writeFieldEnd();
  }
  if (this.isCancelled !== null && this.isCancelled !== undefined) {
    output.writeFieldBegin('isCancelled', Thrift.Type.BOOL, 6);
    output.writeBool(this.isCancelled);
    output.writeFieldEnd();
  }
  if (this.isDone !== null && this.isDone !== undefined) {
    output.writeFieldBegin('isDone', Thrift.Type.BOOL, 7);
    output.writeBool(this.isDone);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TOperation = module.exports.TOperation = function(args) {
  this.tableName = null;
  this.type = null;
  this.row = null;
  this.returnChoice = null;
  this.abortIfUnsuccessful = null;
  this.matchVersion = null;
  if (args) {
    if (args.tableName !== undefined) {
      this.tableName = args.tableName;
    }
    if (args.type !== undefined) {
      this.type = args.type;
    }
    if (args.row !== undefined) {
      this.row = args.row;
    }
    if (args.returnChoice !== undefined) {
      this.returnChoice = args.returnChoice;
    }
    if (args.abortIfUnsuccessful !== undefined) {
      this.abortIfUnsuccessful = args.abortIfUnsuccessful;
    }
    if (args.matchVersion !== undefined) {
      this.matchVersion = args.matchVersion;
    }
  }
};
TOperation.prototype = {};
TOperation.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.tableName = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I32) {
        this.type = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRUCT) {
        this.row = new ttypes.TRow();
        this.row.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.I32) {
        this.returnChoice = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.BOOL) {
        this.abortIfUnsuccessful = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 6:
      if (ftype == Thrift.Type.STRING) {
        this.matchVersion = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TOperation.prototype.write = function(output) {
  output.writeStructBegin('TOperation');
  if (this.tableName !== null && this.tableName !== undefined) {
    output.writeFieldBegin('tableName', Thrift.Type.STRING, 1);
    output.writeString(this.tableName);
    output.writeFieldEnd();
  }
  if (this.type !== null && this.type !== undefined) {
    output.writeFieldBegin('type', Thrift.Type.I32, 2);
    output.writeI32(this.type);
    output.writeFieldEnd();
  }
  if (this.row !== null && this.row !== undefined) {
    output.writeFieldBegin('row', Thrift.Type.STRUCT, 3);
    this.row.write(output);
    output.writeFieldEnd();
  }
  if (this.returnChoice !== null && this.returnChoice !== undefined) {
    output.writeFieldBegin('returnChoice', Thrift.Type.I32, 4);
    output.writeI32(this.returnChoice);
    output.writeFieldEnd();
  }
  if (this.abortIfUnsuccessful !== null && this.abortIfUnsuccessful !== undefined) {
    output.writeFieldBegin('abortIfUnsuccessful', Thrift.Type.BOOL, 5);
    output.writeBool(this.abortIfUnsuccessful);
    output.writeFieldEnd();
  }
  if (this.matchVersion !== null && this.matchVersion !== undefined) {
    output.writeFieldBegin('matchVersion', Thrift.Type.STRING, 6);
    output.writeBinary(this.matchVersion);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TDurabilityException = module.exports.TDurabilityException = function(args) {
  Thrift.TException.call(this, "TDurabilityException")
  this.name = "TDurabilityException"
  this.availableReplicas = null;
  this.commitPolicy = null;
  this.requiredNodeCount = null;
  this.message = null;
  if (args) {
    if (args.availableReplicas !== undefined) {
      this.availableReplicas = args.availableReplicas;
    }
    if (args.commitPolicy !== undefined) {
      this.commitPolicy = args.commitPolicy;
    }
    if (args.requiredNodeCount !== undefined) {
      this.requiredNodeCount = args.requiredNodeCount;
    }
    if (args.message !== undefined) {
      this.message = args.message;
    }
  }
};
Thrift.inherits(TDurabilityException, Thrift.TException);
TDurabilityException.prototype.name = 'TDurabilityException';
TDurabilityException.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.LIST) {
        var _size34 = 0;
        var _rtmp338;
        this.availableReplicas = [];
        var _etype37 = 0;
        _rtmp338 = input.readListBegin();
        _etype37 = _rtmp338.etype;
        _size34 = _rtmp338.size;
        for (var _i39 = 0; _i39 < _size34; ++_i39)
        {
          var elem40 = null;
          elem40 = input.readString();
          this.availableReplicas.push(elem40);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I32) {
        this.commitPolicy = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.I32) {
        this.requiredNodeCount = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRING) {
        this.message = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TDurabilityException.prototype.write = function(output) {
  output.writeStructBegin('TDurabilityException');
  if (this.availableReplicas !== null && this.availableReplicas !== undefined) {
    output.writeFieldBegin('availableReplicas', Thrift.Type.LIST, 1);
    output.writeListBegin(Thrift.Type.STRING, this.availableReplicas.length);
    for (var iter41 in this.availableReplicas)
    {
      if (this.availableReplicas.hasOwnProperty(iter41))
      {
        iter41 = this.availableReplicas[iter41];
        output.writeString(iter41);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.commitPolicy !== null && this.commitPolicy !== undefined) {
    output.writeFieldBegin('commitPolicy', Thrift.Type.I32, 2);
    output.writeI32(this.commitPolicy);
    output.writeFieldEnd();
  }
  if (this.requiredNodeCount !== null && this.requiredNodeCount !== undefined) {
    output.writeFieldBegin('requiredNodeCount', Thrift.Type.I32, 3);
    output.writeI32(this.requiredNodeCount);
    output.writeFieldEnd();
  }
  if (this.message !== null && this.message !== undefined) {
    output.writeFieldBegin('message', Thrift.Type.STRING, 4);
    output.writeString(this.message);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TRequestTimeoutException = module.exports.TRequestTimeoutException = function(args) {
  Thrift.TException.call(this, "TRequestTimeoutException")
  this.name = "TRequestTimeoutException"
  this.message = null;
  this.timeoutMs = null;
  if (args) {
    if (args.message !== undefined) {
      this.message = args.message;
    }
    if (args.timeoutMs !== undefined) {
      this.timeoutMs = args.timeoutMs;
    }
  }
};
Thrift.inherits(TRequestTimeoutException, Thrift.TException);
TRequestTimeoutException.prototype.name = 'TRequestTimeoutException';
TRequestTimeoutException.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.message = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I64) {
        this.timeoutMs = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TRequestTimeoutException.prototype.write = function(output) {
  output.writeStructBegin('TRequestTimeoutException');
  if (this.message !== null && this.message !== undefined) {
    output.writeFieldBegin('message', Thrift.Type.STRING, 1);
    output.writeString(this.message);
    output.writeFieldEnd();
  }
  if (this.timeoutMs !== null && this.timeoutMs !== undefined) {
    output.writeFieldBegin('timeoutMs', Thrift.Type.I64, 2);
    output.writeI64(this.timeoutMs);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

TFaultException = module.exports.TFaultException = function(args) {
  Thrift.TException.call(this, "TFaultException")
  this.name = "TFaultException"
  this.faultClassName = null;
  this.remoteStackTrace = null;
  this.wasLoggedRemotely = null;
  this.message = null;
  if (args) {
    if (args.faultClassName !== undefined) {
      this.faultClassName = args.faultClassName;
    }
    if (args.remoteStackTrace !== undefined) {
      this.remoteStackTrace = args.remoteStackTrace;
    }
    if (args.wasLoggedRemotely !== undefined) {
      this.wasLoggedRemotely = args.wasLoggedRemotely;
    }
    if (args.message !== undefined) {
      this.message = args.message;
    }
  }
};
Thrift.inherits(TFaultException, Thrift.TException);
TFaultException.prototype.name = 'TFaultException';
TFaultException.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.faultClassName = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.remoteStackTrace = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.BOOL) {
        this.wasLoggedRemotely = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRING) {
        this.message = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TFaultException.prototype.write = function(output) {
  output.writeStructBegin('TFaultException');
  if (this.faultClassName !== null && this.faultClassName !== undefined) {
    output.writeFieldBegin('faultClassName', Thrift.Type.STRING, 1);
    output.writeString(this.faultClassName);
    output.writeFieldEnd();
  }
  if (this.remoteStackTrace !== null && this.remoteStackTrace !== undefined) {
    output.writeFieldBegin('remoteStackTrace', Thrift.Type.STRING, 2);
    output.writeString(this.remoteStackTrace);
    output.writeFieldEnd();
  }
  if (this.wasLoggedRemotely !== null && this.wasLoggedRemotely !== undefined) {
    output.w