/**
 * Autogenerated by Thrift Compiler (0.14.1)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#ifndef IClientRPCService_H
#define IClientRPCService_H

#include <thrift/TDispatchProcessor.h>
#include <thrift/async/TConcurrentClientSyncInfo.h>
#include <memory>
#include "client_types.h"



#ifdef _MSC_VER
  #pragma warning( push )
  #pragma warning (disable : 4250 ) //inheriting methods via dominance 
#endif

class IClientRPCServiceIf {
 public:
  virtual ~IClientRPCServiceIf() {}
  virtual void executeQueryStatementV2(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req) = 0;
  virtual void executeUpdateStatementV2(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req) = 0;
  virtual void executeStatementV2(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req) = 0;
  virtual void executeRawDataQueryV2(TSExecuteStatementResp& _return, const TSRawDataQueryReq& req) = 0;
  virtual void executeLastDataQueryV2(TSExecuteStatementResp& _return, const TSLastDataQueryReq& req) = 0;
  virtual void executeFastLastDataQueryForOneDeviceV2(TSExecuteStatementResp& _return, const TSFastLastDataQueryForOneDeviceReq& req) = 0;
  virtual void executeAggregationQueryV2(TSExecuteStatementResp& _return, const TSAggregationQueryReq& req) = 0;
  virtual void executeGroupByQueryIntervalQuery(TSExecuteStatementResp& _return, const TSGroupByQueryIntervalReq& req) = 0;
  virtual void fetchResultsV2(TSFetchResultsResp& _return, const TSFetchResultsReq& req) = 0;
  virtual void openSession(TSOpenSessionResp& _return, const TSOpenSessionReq& req) = 0;
  virtual void closeSession( ::TSStatus& _return, const TSCloseSessionReq& req) = 0;
  virtual void executeStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req) = 0;
  virtual void executeBatchStatement( ::TSStatus& _return, const TSExecuteBatchStatementReq& req) = 0;
  virtual void executeQueryStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req) = 0;
  virtual void executeUpdateStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req) = 0;
  virtual void fetchResults(TSFetchResultsResp& _return, const TSFetchResultsReq& req) = 0;
  virtual void fetchMetadata(TSFetchMetadataResp& _return, const TSFetchMetadataReq& req) = 0;
  virtual void cancelOperation( ::TSStatus& _return, const TSCancelOperationReq& req) = 0;
  virtual void closeOperation( ::TSStatus& _return, const TSCloseOperationReq& req) = 0;
  virtual void getTimeZone(TSGetTimeZoneResp& _return, const int64_t sessionId) = 0;
  virtual void setTimeZone( ::TSStatus& _return, const TSSetTimeZoneReq& req) = 0;
  virtual void getProperties(ServerProperties& _return) = 0;
  virtual void setStorageGroup( ::TSStatus& _return, const int64_t sessionId, const std::string& storageGroup) = 0;
  virtual void createTimeseries( ::TSStatus& _return, const TSCreateTimeseriesReq& req) = 0;
  virtual void createAlignedTimeseries( ::TSStatus& _return, const TSCreateAlignedTimeseriesReq& req) = 0;
  virtual void createMultiTimeseries( ::TSStatus& _return, const TSCreateMultiTimeseriesReq& req) = 0;
  virtual void deleteTimeseries( ::TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & path) = 0;
  virtual void deleteStorageGroups( ::TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & storageGroup) = 0;
  virtual void insertRecord( ::TSStatus& _return, const TSInsertRecordReq& req) = 0;
  virtual void insertStringRecord( ::TSStatus& _return, const TSInsertStringRecordReq& req) = 0;
  virtual void insertTablet( ::TSStatus& _return, const TSInsertTabletReq& req) = 0;
  virtual void insertTablets( ::TSStatus& _return, const TSInsertTabletsReq& req) = 0;
  virtual void insertRecords( ::TSStatus& _return, const TSInsertRecordsReq& req) = 0;
  virtual void insertRecordsOfOneDevice( ::TSStatus& _return, const TSInsertRecordsOfOneDeviceReq& req) = 0;
  virtual void insertStringRecordsOfOneDevice( ::TSStatus& _return, const TSInsertStringRecordsOfOneDeviceReq& req) = 0;
  virtual void insertStringRecords( ::TSStatus& _return, const TSInsertStringRecordsReq& req) = 0;
  virtual void testInsertTablet( ::TSStatus& _return, const TSInsertTabletReq& req) = 0;
  virtual void testInsertTablets( ::TSStatus& _return, const TSInsertTabletsReq& req) = 0;
  virtual void testInsertRecord( ::TSStatus& _return, const TSInsertRecordReq& req) = 0;
  virtual void testInsertStringRecord( ::TSStatus& _return, const TSInsertStringRecordReq& req) = 0;
  virtual void testInsertRecords( ::TSStatus& _return, const TSInsertRecordsReq& req) = 0;
  virtual void testInsertRecordsOfOneDevice( ::TSStatus& _return, const TSInsertRecordsOfOneDeviceReq& req) = 0;
  virtual void testInsertStringRecords( ::TSStatus& _return, const TSInsertStringRecordsReq& req) = 0;
  virtual void deleteData( ::TSStatus& _return, const TSDeleteDataReq& req) = 0;
  virtual void executeRawDataQuery(TSExecuteStatementResp& _return, const TSRawDataQueryReq& req) = 0;
  virtual void executeLastDataQuery(TSExecuteStatementResp& _return, const TSLastDataQueryReq& req) = 0;
  virtual void executeAggregationQuery(TSExecuteStatementResp& _return, const TSAggregationQueryReq& req) = 0;
  virtual int64_t requestStatementId(const int64_t sessionId) = 0;
  virtual void createSchemaTemplate( ::TSStatus& _return, const TSCreateSchemaTemplateReq& req) = 0;
  virtual void appendSchemaTemplate( ::TSStatus& _return, const TSAppendSchemaTemplateReq& req) = 0;
  virtual void pruneSchemaTemplate( ::TSStatus& _return, const TSPruneSchemaTemplateReq& req) = 0;
  virtual void querySchemaTemplate(TSQueryTemplateResp& _return, const TSQueryTemplateReq& req) = 0;
  virtual void showConfigurationTemplate( ::TShowConfigurationTemplateResp& _return) = 0;
  virtual void showConfiguration( ::TShowConfigurationResp& _return, const int32_t nodeId) = 0;
  virtual void setSchemaTemplate( ::TSStatus& _return, const TSSetSchemaTemplateReq& req) = 0;
  virtual void unsetSchemaTemplate( ::TSStatus& _return, const TSUnsetSchemaTemplateReq& req) = 0;
  virtual void dropSchemaTemplate( ::TSStatus& _return, const TSDropSchemaTemplateReq& req) = 0;
  virtual void createTimeseriesUsingSchemaTemplate( ::TSStatus& _return, const TCreateTimeseriesUsingSchemaTemplateReq& req) = 0;
  virtual void handshake( ::TSStatus& _return, const TSyncIdentityInfo& info) = 0;
  virtual void sendPipeData( ::TSStatus& _return, const std::string& buff) = 0;
  virtual void sendFile( ::TSStatus& _return, const TSyncTransportMetaInfo& metaInfo, const std::string& buff) = 0;
  virtual void pipeTransfer(TPipeTransferResp& _return, const TPipeTransferReq& req) = 0;
  virtual void pipeSubscribe(TPipeSubscribeResp& _return, const TPipeSubscribeReq& req) = 0;
  virtual void getBackupConfiguration(TSBackupConfigurationResp& _return) = 0;
  virtual void fetchAllConnectionsInfo(TSConnectionInfoResp& _return) = 0;

  /**
   * For other node's call
   */
  virtual void testConnectionEmptyRPC( ::TSStatus& _return) = 0;
};

class IClientRPCServiceIfFactory {
 public:
  typedef IClientRPCServiceIf Handler;

  virtual ~IClientRPCServiceIfFactory() {}

  virtual IClientRPCServiceIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
  virtual void releaseHandler(IClientRPCServiceIf* /* handler */) = 0;
};

class IClientRPCServiceIfSingletonFactory : virtual public IClientRPCServiceIfFactory {
 public:
  IClientRPCServiceIfSingletonFactory(const ::std::shared_ptr<IClientRPCServiceIf>& iface) : iface_(iface) {}
  virtual ~IClientRPCServiceIfSingletonFactory() {}

  virtual IClientRPCServiceIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
    return iface_.get();
  }
  virtual void releaseHandler(IClientRPCServiceIf* /* handler */) {}

 protected:
  ::std::shared_ptr<IClientRPCServiceIf> iface_;
};

class IClientRPCServiceNull : virtual public IClientRPCServiceIf {
 public:
  virtual ~IClientRPCServiceNull() {}
  void executeQueryStatementV2(TSExecuteStatementResp& /* _return */, const TSExecuteStatementReq& /* req */) {
    return;
  }
  void executeUpdateStatementV2(TSExecuteStatementResp& /* _return */, const TSExecuteStatementReq& /* req */) {
    return;
  }
  void executeStatementV2(TSExecuteStatementResp& /* _return */, const TSExecuteStatementReq& /* req */) {
    return;
  }
  void executeRawDataQueryV2(TSExecuteStatementResp& /* _return */, const TSRawDataQueryReq& /* req */) {
    return;
  }
  void executeLastDataQueryV2(TSExecuteStatementResp& /* _return */, const TSLastDataQueryReq& /* req */) {
    return;
  }
  void executeFastLastDataQueryForOneDeviceV2(TSExecuteStatementResp& /* _return */, const TSFastLastDataQueryForOneDeviceReq& /* req */) {
    return;
  }
  void executeAggregationQueryV2(TSExecuteStatementResp& /* _return */, const TSAggregationQueryReq& /* req */) {
    return;
  }
  void executeGroupByQueryIntervalQuery(TSExecuteStatementResp& /* _return */, const TSGroupByQueryIntervalReq& /* req */) {
    return;
  }
  void fetchResultsV2(TSFetchResultsResp& /* _return */, const TSFetchResultsReq& /* req */) {
    return;
  }
  void openSession(TSOpenSessionResp& /* _return */, const TSOpenSessionReq& /* req */) {
    return;
  }
  void closeSession( ::TSStatus& /* _return */, const TSCloseSessionReq& /* req */) {
    return;
  }
  void executeStatement(TSExecuteStatementResp& /* _return */, const TSExecuteStatementReq& /* req */) {
    return;
  }
  void executeBatchStatement( ::TSStatus& /* _return */, const TSExecuteBatchStatementReq& /* req */) {
    return;
  }
  void executeQueryStatement(TSExecuteStatementResp& /* _return */, const TSExecuteStatementReq& /* req */) {
    return;
  }
  void executeUpdateStatement(TSExecuteStatementResp& /* _return */, const TSExecuteStatementReq& /* req */) {
    return;
  }
  void fetchResults(TSFetchResultsResp& /* _return */, const TSFetchResultsReq& /* req */) {
    return;
  }
  void fetchMetadata(TSFetchMetadataResp& /* _return */, const TSFetchMetadataReq& /* req */) {
    return;
  }
  void cancelOperation( ::TSStatus& /* _return */, const TSCancelOperationReq& /* req */) {
    return;
  }
  void closeOperation( ::TSStatus& /* _return */, const TSCloseOperationReq& /* req */) {
    return;
  }
  void getTimeZone(TSGetTimeZoneResp& /* _return */, const int64_t /* sessionId */) {
    return;
  }
  void setTimeZone( ::TSStatus& /* _return */, const TSSetTimeZoneReq& /* req */) {
    return;
  }
  void getProperties(ServerProperties& /* _return */) {
    return;
  }
  void setStorageGroup( ::TSStatus& /* _return */, const int64_t /* sessionId */, const std::string& /* storageGroup */) {
    return;
  }
  void createTimeseries( ::TSStatus& /* _return */, const TSCreateTimeseriesReq& /* req */) {
    return;
  }
  void createAlignedTimeseries( ::TSStatus& /* _return */, const TSCreateAlignedTimeseriesReq& /* req */) {
    return;
  }
  void createMultiTimeseries( ::TSStatus& /* _return */, const TSCreateMultiTimeseriesReq& /* req */) {
    return;
  }
  void deleteTimeseries( ::TSStatus& /* _return */, const int64_t /* sessionId */, const std::vector<std::string> & /* path */) {
    return;
  }
  void deleteStorageGroups( ::TSStatus& /* _return */, const int64_t /* sessionId */, const std::vector<std::string> & /* storageGroup */) {
    return;
  }
  void insertRecord( ::TSStatus& /* _return */, const TSInsertRecordReq& /* req */) {
    return;
  }
  void insertStringRecord( ::TSStatus& /* _return */, const TSInsertStringRecordReq& /* req */) {
    return;
  }
  void insertTablet( ::TSStatus& /* _return */, const TSInsertTabletReq& /* req */) {
    return;
  }
  void insertTablets( ::TSStatus& /* _return */, const TSInsertTabletsReq& /* req */) {
    return;
  }
  void insertRecords( ::TSStatus& /* _return */, const TSInsertRecordsReq& /* req */) {
    return;
  }
  void insertRecordsOfOneDevice( ::TSStatus& /* _return */, const TSInsertRecordsOfOneDeviceReq& /* req */) {
    return;
  }
  void insertStringRecordsOfOneDevice( ::TSStatus& /* _return */, const TSInsertStringRecordsOfOneDeviceReq& /* req */) {
    return;
  }
  void insertStringRecords( ::TSStatus& /* _return */, const TSInsertStringRecordsReq& /* req */) {
    return;
  }
  void testInsertTablet( ::TSStatus& /* _return */, const TSInsertTabletReq& /* req */) {
    return;
  }
  void testInsertTablets( ::TSStatus& /* _return */, const TSInsertTabletsReq& /* req */) {
    return;
  }
  void testInsertRecord( ::TSStatus& /* _return */, const TSInsertRecordReq& /* req */) {
    return;
  }
  void testInsertStringRecord( ::TSStatus& /* _return */, const TSInsertStringRecordReq& /* req */) {
    return;
  }
  void testInsertRecords( ::TSStatus& /* _return */, const TSInsertRecordsReq& /* req */) {
    return;
  }
  void testInsertRecordsOfOneDevice( ::TSStatus& /* _return */, const TSInsertRecordsOfOneDeviceReq& /* req */) {
    return;
  }
  void testInsertStringRecords( ::TSStatus& /* _return */, const TSInsertStringRecordsReq& /* req */) {
    return;
  }
  void deleteData( ::TSStatus& /* _return */, const TSDeleteDataReq& /* req */) {
    return;
  }
  void executeRawDataQuery(TSExecuteStatementResp& /* _return */, const TSRawDataQueryReq& /* req */) {
    return;
  }
  void executeLastDataQuery(TSExecuteStatementResp& /* _return */, const TSLastDataQueryReq& /* req */) {
    return;
  }
  void executeAggregationQuery(TSExecuteStatementResp& /* _return */, const TSAggregationQueryReq& /* req */) {
    return;
  }
  int64_t requestStatementId(const int64_t /* sessionId */) {
    int64_t _return = 0;
    return _return;
  }
  void createSchemaTemplate( ::TSStatus& /* _return */, const TSCreateSchemaTemplateReq& /* req */) {
    return;
  }
  void appendSchemaTemplate( ::TSStatus& /* _return */, const TSAppendSchemaTemplateReq& /* req */) {
    return;
  }
  void pruneSchemaTemplate( ::TSStatus& /* _return */, const TSPruneSchemaTemplateReq& /* req */) {
    return;
  }
  void querySchemaTemplate(TSQueryTemplateResp& /* _return */, const TSQueryTemplateReq& /* req */) {
    return;
  }
  void showConfigurationTemplate( ::TShowConfigurationTemplateResp& /* _return */) {
    return;
  }
  void showConfiguration( ::TShowConfigurationResp& /* _return */, const int32_t /* nodeId */) {
    return;
  }
  void setSchemaTemplate( ::TSStatus& /* _return */, const TSSetSchemaTemplateReq& /* req */) {
    return;
  }
  void unsetSchemaTemplate( ::TSStatus& /* _return */, const TSUnsetSchemaTemplateReq& /* req */) {
    return;
  }
  void dropSchemaTemplate( ::TSStatus& /* _return */, const TSDropSchemaTemplateReq& /* req */) {
    return;
  }
  void createTimeseriesUsingSchemaTemplate( ::TSStatus& /* _return */, const TCreateTimeseriesUsingSchemaTemplateReq& /* req */) {
    return;
  }
  void handshake( ::TSStatus& /* _return */, const TSyncIdentityInfo& /* info */) {
    return;
  }
  void sendPipeData( ::TSStatus& /* _return */, const std::string& /* buff */) {
    return;
  }
  void sendFile( ::TSStatus& /* _return */, const TSyncTransportMetaInfo& /* metaInfo */, const std::string& /* buff */) {
    return;
  }
  void pipeTransfer(TPipeTransferResp& /* _return */, const TPipeTransferReq& /* req */) {
    return;
  }
  void pipeSubscribe(TPipeSubscribeResp& /* _return */, const TPipeSubscribeReq& /* req */) {
    return;
  }
  void getBackupConfiguration(TSBackupConfigurationResp& /* _return */) {
    return;
  }
  void fetchAllConnectionsInfo(TSConnectionInfoResp& /* _return */) {
    return;
  }
  void testConnectionEmptyRPC( ::TSStatus& /* _return */) {
    return;
  }
};

typedef struct _IClientRPCService_executeQueryStatementV2_args__isset {
  _IClientRPCService_executeQueryStatementV2_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_executeQueryStatementV2_args__isset;

class IClientRPCService_executeQueryStatementV2_args {
 public:

  IClientRPCService_executeQueryStatementV2_args(const IClientRPCService_executeQueryStatementV2_args&);
  IClientRPCService_executeQueryStatementV2_args& operator=(const IClientRPCService_executeQueryStatementV2_args&);
  IClientRPCService_executeQueryStatementV2_args() {
  }

  virtual ~IClientRPCService_executeQueryStatementV2_args() noexcept;
  TSExecuteStatementReq req;

  _IClientRPCService_executeQueryStatementV2_args__isset __isset;

  void __set_req(const TSExecuteStatementReq& val);

  bool operator == (const IClientRPCService_executeQueryStatementV2_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeQueryStatementV2_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeQueryStatementV2_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_executeQueryStatementV2_pargs {
 public:


  virtual ~IClientRPCService_executeQueryStatementV2_pargs() noexcept;
  const TSExecuteStatementReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeQueryStatementV2_result__isset {
  _IClientRPCService_executeQueryStatementV2_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeQueryStatementV2_result__isset;

class IClientRPCService_executeQueryStatementV2_result {
 public:

  IClientRPCService_executeQueryStatementV2_result(const IClientRPCService_executeQueryStatementV2_result&);
  IClientRPCService_executeQueryStatementV2_result& operator=(const IClientRPCService_executeQueryStatementV2_result&);
  IClientRPCService_executeQueryStatementV2_result() {
  }

  virtual ~IClientRPCService_executeQueryStatementV2_result() noexcept;
  TSExecuteStatementResp success;

  _IClientRPCService_executeQueryStatementV2_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

  bool operator == (const IClientRPCService_executeQueryStatementV2_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeQueryStatementV2_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeQueryStatementV2_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeQueryStatementV2_presult__isset {
  _IClientRPCService_executeQueryStatementV2_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeQueryStatementV2_presult__isset;

class IClientRPCService_executeQueryStatementV2_presult {
 public:


  virtual ~IClientRPCService_executeQueryStatementV2_presult() noexcept;
  TSExecuteStatementResp* success;

  _IClientRPCService_executeQueryStatementV2_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_executeUpdateStatementV2_args__isset {
  _IClientRPCService_executeUpdateStatementV2_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_executeUpdateStatementV2_args__isset;

class IClientRPCService_executeUpdateStatementV2_args {
 public:

  IClientRPCService_executeUpdateStatementV2_args(const IClientRPCService_executeUpdateStatementV2_args&);
  IClientRPCService_executeUpdateStatementV2_args& operator=(const IClientRPCService_executeUpdateStatementV2_args&);
  IClientRPCService_executeUpdateStatementV2_args() {
  }

  virtual ~IClientRPCService_executeUpdateStatementV2_args() noexcept;
  TSExecuteStatementReq req;

  _IClientRPCService_executeUpdateStatementV2_args__isset __isset;

  void __set_req(const TSExecuteStatementReq& val);

  bool operator == (const IClientRPCService_executeUpdateStatementV2_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeUpdateStatementV2_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeUpdateStatementV2_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_executeUpdateStatementV2_pargs {
 public:


  virtual ~IClientRPCService_executeUpdateStatementV2_pargs() noexcept;
  const TSExecuteStatementReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeUpdateStatementV2_result__isset {
  _IClientRPCService_executeUpdateStatementV2_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeUpdateStatementV2_result__isset;

class IClientRPCService_executeUpdateStatementV2_result {
 public:

  IClientRPCService_executeUpdateStatementV2_result(const IClientRPCService_executeUpdateStatementV2_result&);
  IClientRPCService_executeUpdateStatementV2_result& operator=(const IClientRPCService_executeUpdateStatementV2_result&);
  IClientRPCService_executeUpdateStatementV2_result() {
  }

  virtual ~IClientRPCService_executeUpdateStatementV2_result() noexcept;
  TSExecuteStatementResp success;

  _IClientRPCService_executeUpdateStatementV2_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

  bool operator == (const IClientRPCService_executeUpdateStatementV2_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeUpdateStatementV2_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeUpdateStatementV2_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeUpdateStatementV2_presult__isset {
  _IClientRPCService_executeUpdateStatementV2_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeUpdateStatementV2_presult__isset;

class IClientRPCService_executeUpdateStatementV2_presult {
 public:


  virtual ~IClientRPCService_executeUpdateStatementV2_presult() noexcept;
  TSExecuteStatementResp* success;

  _IClientRPCService_executeUpdateStatementV2_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_executeStatementV2_args__isset {
  _IClientRPCService_executeStatementV2_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_executeStatementV2_args__isset;

class IClientRPCService_executeStatementV2_args {
 public:

  IClientRPCService_executeStatementV2_args(const IClientRPCService_executeStatementV2_args&);
  IClientRPCService_executeStatementV2_args& operator=(const IClientRPCService_executeStatementV2_args&);
  IClientRPCService_executeStatementV2_args() {
  }

  virtual ~IClientRPCService_executeStatementV2_args() noexcept;
  TSExecuteStatementReq req;

  _IClientRPCService_executeStatementV2_args__isset __isset;

  void __set_req(const TSExecuteStatementReq& val);

  bool operator == (const IClientRPCService_executeStatementV2_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeStatementV2_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeStatementV2_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_executeStatementV2_pargs {
 public:


  virtual ~IClientRPCService_executeStatementV2_pargs() noexcept;
  const TSExecuteStatementReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeStatementV2_result__isset {
  _IClientRPCService_executeStatementV2_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeStatementV2_result__isset;

class IClientRPCService_executeStatementV2_result {
 public:

  IClientRPCService_executeStatementV2_result(const IClientRPCService_executeStatementV2_result&);
  IClientRPCService_executeStatementV2_result& operator=(const IClientRPCService_executeStatementV2_result&);
  IClientRPCService_executeStatementV2_result() {
  }

  virtual ~IClientRPCService_executeStatementV2_result() noexcept;
  TSExecuteStatementResp success;

  _IClientRPCService_executeStatementV2_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

  bool operator == (const IClientRPCService_executeStatementV2_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeStatementV2_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeStatementV2_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeStatementV2_presult__isset {
  _IClientRPCService_executeStatementV2_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeStatementV2_presult__isset;

class IClientRPCService_executeStatementV2_presult {
 public:


  virtual ~IClientRPCService_executeStatementV2_presult() noexcept;
  TSExecuteStatementResp* success;

  _IClientRPCService_executeStatementV2_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_executeRawDataQueryV2_args__isset {
  _IClientRPCService_executeRawDataQueryV2_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_executeRawDataQueryV2_args__isset;

class IClientRPCService_executeRawDataQueryV2_args {
 public:

  IClientRPCService_executeRawDataQueryV2_args(const IClientRPCService_executeRawDataQueryV2_args&);
  IClientRPCService_executeRawDataQueryV2_args& operator=(const IClientRPCService_executeRawDataQueryV2_args&);
  IClientRPCService_executeRawDataQueryV2_args() {
  }

  virtual ~IClientRPCService_executeRawDataQueryV2_args() noexcept;
  TSRawDataQueryReq req;

  _IClientRPCService_executeRawDataQueryV2_args__isset __isset;

  void __set_req(const TSRawDataQueryReq& val);

  bool operator == (const IClientRPCService_executeRawDataQueryV2_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeRawDataQueryV2_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeRawDataQueryV2_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_executeRawDataQueryV2_pargs {
 public:


  virtual ~IClientRPCService_executeRawDataQueryV2_pargs() noexcept;
  const TSRawDataQueryReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeRawDataQueryV2_result__isset {
  _IClientRPCService_executeRawDataQueryV2_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeRawDataQueryV2_result__isset;

class IClientRPCService_executeRawDataQueryV2_result {
 public:

  IClientRPCService_executeRawDataQueryV2_result(const IClientRPCService_executeRawDataQueryV2_result&);
  IClientRPCService_executeRawDataQueryV2_result& operator=(const IClientRPCService_executeRawDataQueryV2_result&);
  IClientRPCService_executeRawDataQueryV2_result() {
  }

  virtual ~IClientRPCService_executeRawDataQueryV2_result() noexcept;
  TSExecuteStatementResp success;

  _IClientRPCService_executeRawDataQueryV2_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

  bool operator == (const IClientRPCService_executeRawDataQueryV2_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeRawDataQueryV2_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeRawDataQueryV2_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeRawDataQueryV2_presult__isset {
  _IClientRPCService_executeRawDataQueryV2_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeRawDataQueryV2_presult__isset;

class IClientRPCService_executeRawDataQueryV2_presult {
 public:


  virtual ~IClientRPCService_executeRawDataQueryV2_presult() noexcept;
  TSExecuteStatementResp* success;

  _IClientRPCService_executeRawDataQueryV2_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_executeLastDataQueryV2_args__isset {
  _IClientRPCService_executeLastDataQueryV2_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_executeLastDataQueryV2_args__isset;

class IClientRPCService_executeLastDataQueryV2_args {
 public:

  IClientRPCService_executeLastDataQueryV2_args(const IClientRPCService_executeLastDataQueryV2_args&);
  IClientRPCService_executeLastDataQueryV2_args& operator=(const IClientRPCService_executeLastDataQueryV2_args&);
  IClientRPCService_executeLastDataQueryV2_args() {
  }

  virtual ~IClientRPCService_executeLastDataQueryV2_args() noexcept;
  TSLastDataQueryReq req;

  _IClientRPCService_executeLastDataQueryV2_args__isset __isset;

  void __set_req(const TSLastDataQueryReq& val);

  bool operator == (const IClientRPCService_executeLastDataQueryV2_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeLastDataQueryV2_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeLastDataQueryV2_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_executeLastDataQueryV2_pargs {
 public:


  virtual ~IClientRPCService_executeLastDataQueryV2_pargs() noexcept;
  const TSLastDataQueryReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeLastDataQueryV2_result__isset {
  _IClientRPCService_executeLastDataQueryV2_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeLastDataQueryV2_result__isset;

class IClientRPCService_executeLastDataQueryV2_result {
 public:

  IClientRPCService_executeLastDataQueryV2_result(const IClientRPCService_executeLastDataQueryV2_result&);
  IClientRPCService_executeLastDataQueryV2_result& operator=(const IClientRPCService_executeLastDataQueryV2_result&);
  IClientRPCService_executeLastDataQueryV2_result() {
  }

  virtual ~IClientRPCService_executeLastDataQueryV2_result() noexcept;
  TSExecuteStatementResp success;

  _IClientRPCService_executeLastDataQueryV2_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

  bool operator == (const IClientRPCService_executeLastDataQueryV2_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeLastDataQueryV2_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeLastDataQueryV2_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeLastDataQueryV2_presult__isset {
  _IClientRPCService_executeLastDataQueryV2_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeLastDataQueryV2_presult__isset;

class IClientRPCService_executeLastDataQueryV2_presult {
 public:


  virtual ~IClientRPCService_executeLastDataQueryV2_presult() noexcept;
  TSExecuteStatementResp* success;

  _IClientRPCService_executeLastDataQueryV2_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_executeFastLastDataQueryForOneDeviceV2_args__isset {
  _IClientRPCService_executeFastLastDataQueryForOneDeviceV2_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_executeFastLastDataQueryForOneDeviceV2_args__isset;

class IClientRPCService_executeFastLastDataQueryForOneDeviceV2_args {
 public:

  IClientRPCService_executeFastLastDataQueryForOneDeviceV2_args(const IClientRPCService_executeFastLastDataQueryForOneDeviceV2_args&);
  IClientRPCService_executeFastLastDataQueryForOneDeviceV2_args& operator=(const IClientRPCService_executeFastLastDataQueryForOneDeviceV2_args&);
  IClientRPCService_executeFastLastDataQueryForOneDeviceV2_args() {
  }

  virtual ~IClientRPCService_executeFastLastDataQueryForOneDeviceV2_args() noexcept;
  TSFastLastDataQueryForOneDeviceReq req;

  _IClientRPCService_executeFastLastDataQueryForOneDeviceV2_args__isset __isset;

  void __set_req(const TSFastLastDataQueryForOneDeviceReq& val);

  bool operator == (const IClientRPCService_executeFastLastDataQueryForOneDeviceV2_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeFastLastDataQueryForOneDeviceV2_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeFastLastDataQueryForOneDeviceV2_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_executeFastLastDataQueryForOneDeviceV2_pargs {
 public:


  virtual ~IClientRPCService_executeFastLastDataQueryForOneDeviceV2_pargs() noexcept;
  const TSFastLastDataQueryForOneDeviceReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeFastLastDataQueryForOneDeviceV2_result__isset {
  _IClientRPCService_executeFastLastDataQueryForOneDeviceV2_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeFastLastDataQueryForOneDeviceV2_result__isset;

class IClientRPCService_executeFastLastDataQueryForOneDeviceV2_result {
 public:

  IClientRPCService_executeFastLastDataQueryForOneDeviceV2_result(const IClientRPCService_executeFastLastDataQueryForOneDeviceV2_result&);
  IClientRPCService_executeFastLastDataQueryForOneDeviceV2_result& operator=(const IClientRPCService_executeFastLastDataQueryForOneDeviceV2_result&);
  IClientRPCService_executeFastLastDataQueryForOneDeviceV2_result() {
  }

  virtual ~IClientRPCService_executeFastLastDataQueryForOneDeviceV2_result() noexcept;
  TSExecuteStatementResp success;

  _IClientRPCService_executeFastLastDataQueryForOneDeviceV2_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

  bool operator == (const IClientRPCService_executeFastLastDataQueryForOneDeviceV2_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeFastLastDataQueryForOneDeviceV2_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeFastLastDataQueryForOneDeviceV2_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeFastLastDataQueryForOneDeviceV2_presult__isset {
  _IClientRPCService_executeFastLastDataQueryForOneDeviceV2_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeFastLastDataQueryForOneDeviceV2_presult__isset;

class IClientRPCService_executeFastLastDataQueryForOneDeviceV2_presult {
 public:


  virtual ~IClientRPCService_executeFastLastDataQueryForOneDeviceV2_presult() noexcept;
  TSExecuteStatementResp* success;

  _IClientRPCService_executeFastLastDataQueryForOneDeviceV2_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_executeAggregationQueryV2_args__isset {
  _IClientRPCService_executeAggregationQueryV2_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_executeAggregationQueryV2_args__isset;

class IClientRPCService_executeAggregationQueryV2_args {
 public:

  IClientRPCService_executeAggregationQueryV2_args(const IClientRPCService_executeAggregationQueryV2_args&);
  IClientRPCService_executeAggregationQueryV2_args& operator=(const IClientRPCService_executeAggregationQueryV2_args&);
  IClientRPCService_executeAggregationQueryV2_args() {
  }

  virtual ~IClientRPCService_executeAggregationQueryV2_args() noexcept;
  TSAggregationQueryReq req;

  _IClientRPCService_executeAggregationQueryV2_args__isset __isset;

  void __set_req(const TSAggregationQueryReq& val);

  bool operator == (const IClientRPCService_executeAggregationQueryV2_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeAggregationQueryV2_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeAggregationQueryV2_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_executeAggregationQueryV2_pargs {
 public:


  virtual ~IClientRPCService_executeAggregationQueryV2_pargs() noexcept;
  const TSAggregationQueryReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeAggregationQueryV2_result__isset {
  _IClientRPCService_executeAggregationQueryV2_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeAggregationQueryV2_result__isset;

class IClientRPCService_executeAggregationQueryV2_result {
 public:

  IClientRPCService_executeAggregationQueryV2_result(const IClientRPCService_executeAggregationQueryV2_result&);
  IClientRPCService_executeAggregationQueryV2_result& operator=(const IClientRPCService_executeAggregationQueryV2_result&);
  IClientRPCService_executeAggregationQueryV2_result() {
  }

  virtual ~IClientRPCService_executeAggregationQueryV2_result() noexcept;
  TSExecuteStatementResp success;

  _IClientRPCService_executeAggregationQueryV2_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

  bool operator == (const IClientRPCService_executeAggregationQueryV2_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeAggregationQueryV2_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeAggregationQueryV2_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeAggregationQueryV2_presult__isset {
  _IClientRPCService_executeAggregationQueryV2_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeAggregationQueryV2_presult__isset;

class IClientRPCService_executeAggregationQueryV2_presult {
 public:


  virtual ~IClientRPCService_executeAggregationQueryV2_presult() noexcept;
  TSExecuteStatementResp* success;

  _IClientRPCService_executeAggregationQueryV2_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_executeGroupByQueryIntervalQuery_args__isset {
  _IClientRPCService_executeGroupByQueryIntervalQuery_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_executeGroupByQueryIntervalQuery_args__isset;

class IClientRPCService_executeGroupByQueryIntervalQuery_args {
 public:

  IClientRPCService_executeGroupByQueryIntervalQuery_args(const IClientRPCService_executeGroupByQueryIntervalQuery_args&);
  IClientRPCService_executeGroupByQueryIntervalQuery_args& operator=(const IClientRPCService_executeGroupByQueryIntervalQuery_args&);
  IClientRPCService_executeGroupByQueryIntervalQuery_args() {
  }

  virtual ~IClientRPCService_executeGroupByQueryIntervalQuery_args() noexcept;
  TSGroupByQueryIntervalReq req;

  _IClientRPCService_executeGroupByQueryIntervalQuery_args__isset __isset;

  void __set_req(const TSGroupByQueryIntervalReq& val);

  bool operator == (const IClientRPCService_executeGroupByQueryIntervalQuery_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeGroupByQueryIntervalQuery_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeGroupByQueryIntervalQuery_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_executeGroupByQueryIntervalQuery_pargs {
 public:


  virtual ~IClientRPCService_executeGroupByQueryIntervalQuery_pargs() noexcept;
  const TSGroupByQueryIntervalReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeGroupByQueryIntervalQuery_result__isset {
  _IClientRPCService_executeGroupByQueryIntervalQuery_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeGroupByQueryIntervalQuery_result__isset;

class IClientRPCService_executeGroupByQueryIntervalQuery_result {
 public:

  IClientRPCService_executeGroupByQueryIntervalQuery_result(const IClientRPCService_executeGroupByQueryIntervalQuery_result&);
  IClientRPCService_executeGroupByQueryIntervalQuery_result& operator=(const IClientRPCService_executeGroupByQueryIntervalQuery_result&);
  IClientRPCService_executeGroupByQueryIntervalQuery_result() {
  }

  virtual ~IClientRPCService_executeGroupByQueryIntervalQuery_result() noexcept;
  TSExecuteStatementResp success;

  _IClientRPCService_executeGroupByQueryIntervalQuery_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

  bool operator == (const IClientRPCService_executeGroupByQueryIntervalQuery_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeGroupByQueryIntervalQuery_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeGroupByQueryIntervalQuery_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeGroupByQueryIntervalQuery_presult__isset {
  _IClientRPCService_executeGroupByQueryIntervalQuery_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeGroupByQueryIntervalQuery_presult__isset;

class IClientRPCService_executeGroupByQueryIntervalQuery_presult {
 public:


  virtual ~IClientRPCService_executeGroupByQueryIntervalQuery_presult() noexcept;
  TSExecuteStatementResp* success;

  _IClientRPCService_executeGroupByQueryIntervalQuery_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_fetchResultsV2_args__isset {
  _IClientRPCService_fetchResultsV2_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_fetchResultsV2_args__isset;

class IClientRPCService_fetchResultsV2_args {
 public:

  IClientRPCService_fetchResultsV2_args(const IClientRPCService_fetchResultsV2_args&);
  IClientRPCService_fetchResultsV2_args& operator=(const IClientRPCService_fetchResultsV2_args&);
  IClientRPCService_fetchResultsV2_args() {
  }

  virtual ~IClientRPCService_fetchResultsV2_args() noexcept;
  TSFetchResultsReq req;

  _IClientRPCService_fetchResultsV2_args__isset __isset;

  void __set_req(const TSFetchResultsReq& val);

  bool operator == (const IClientRPCService_fetchResultsV2_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_fetchResultsV2_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_fetchResultsV2_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_fetchResultsV2_pargs {
 public:


  virtual ~IClientRPCService_fetchResultsV2_pargs() noexcept;
  const TSFetchResultsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_fetchResultsV2_result__isset {
  _IClientRPCService_fetchResultsV2_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_fetchResultsV2_result__isset;

class IClientRPCService_fetchResultsV2_result {
 public:

  IClientRPCService_fetchResultsV2_result(const IClientRPCService_fetchResultsV2_result&);
  IClientRPCService_fetchResultsV2_result& operator=(const IClientRPCService_fetchResultsV2_result&);
  IClientRPCService_fetchResultsV2_result() {
  }

  virtual ~IClientRPCService_fetchResultsV2_result() noexcept;
  TSFetchResultsResp success;

  _IClientRPCService_fetchResultsV2_result__isset __isset;

  void __set_success(const TSFetchResultsResp& val);

  bool operator == (const IClientRPCService_fetchResultsV2_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_fetchResultsV2_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_fetchResultsV2_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_fetchResultsV2_presult__isset {
  _IClientRPCService_fetchResultsV2_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_fetchResultsV2_presult__isset;

class IClientRPCService_fetchResultsV2_presult {
 public:


  virtual ~IClientRPCService_fetchResultsV2_presult() noexcept;
  TSFetchResultsResp* success;

  _IClientRPCService_fetchResultsV2_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_openSession_args__isset {
  _IClientRPCService_openSession_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_openSession_args__isset;

class IClientRPCService_openSession_args {
 public:

  IClientRPCService_openSession_args(const IClientRPCService_openSession_args&);
  IClientRPCService_openSession_args& operator=(const IClientRPCService_openSession_args&);
  IClientRPCService_openSession_args() {
  }

  virtual ~IClientRPCService_openSession_args() noexcept;
  TSOpenSessionReq req;

  _IClientRPCService_openSession_args__isset __isset;

  void __set_req(const TSOpenSessionReq& val);

  bool operator == (const IClientRPCService_openSession_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_openSession_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_openSession_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_openSession_pargs {
 public:


  virtual ~IClientRPCService_openSession_pargs() noexcept;
  const TSOpenSessionReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_openSession_result__isset {
  _IClientRPCService_openSession_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_openSession_result__isset;

class IClientRPCService_openSession_result {
 public:

  IClientRPCService_openSession_result(const IClientRPCService_openSession_result&);
  IClientRPCService_openSession_result& operator=(const IClientRPCService_openSession_result&);
  IClientRPCService_openSession_result() {
  }

  virtual ~IClientRPCService_openSession_result() noexcept;
  TSOpenSessionResp success;

  _IClientRPCService_openSession_result__isset __isset;

  void __set_success(const TSOpenSessionResp& val);

  bool operator == (const IClientRPCService_openSession_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_openSession_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_openSession_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_openSession_presult__isset {
  _IClientRPCService_openSession_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_openSession_presult__isset;

class IClientRPCService_openSession_presult {
 public:


  virtual ~IClientRPCService_openSession_presult() noexcept;
  TSOpenSessionResp* success;

  _IClientRPCService_openSession_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_closeSession_args__isset {
  _IClientRPCService_closeSession_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_closeSession_args__isset;

class IClientRPCService_closeSession_args {
 public:

  IClientRPCService_closeSession_args(const IClientRPCService_closeSession_args&);
  IClientRPCService_closeSession_args& operator=(const IClientRPCService_closeSession_args&);
  IClientRPCService_closeSession_args() {
  }

  virtual ~IClientRPCService_closeSession_args() noexcept;
  TSCloseSessionReq req;

  _IClientRPCService_closeSession_args__isset __isset;

  void __set_req(const TSCloseSessionReq& val);

  bool operator == (const IClientRPCService_closeSession_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_closeSession_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_closeSession_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_closeSession_pargs {
 public:


  virtual ~IClientRPCService_closeSession_pargs() noexcept;
  const TSCloseSessionReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_closeSession_result__isset {
  _IClientRPCService_closeSession_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_closeSession_result__isset;

class IClientRPCService_closeSession_result {
 public:

  IClientRPCService_closeSession_result(const IClientRPCService_closeSession_result&);
  IClientRPCService_closeSession_result& operator=(const IClientRPCService_closeSession_result&);
  IClientRPCService_closeSession_result() {
  }

  virtual ~IClientRPCService_closeSession_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_closeSession_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_closeSession_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_closeSession_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_closeSession_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_closeSession_presult__isset {
  _IClientRPCService_closeSession_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_closeSession_presult__isset;

class IClientRPCService_closeSession_presult {
 public:


  virtual ~IClientRPCService_closeSession_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_closeSession_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_executeStatement_args__isset {
  _IClientRPCService_executeStatement_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_executeStatement_args__isset;

class IClientRPCService_executeStatement_args {
 public:

  IClientRPCService_executeStatement_args(const IClientRPCService_executeStatement_args&);
  IClientRPCService_executeStatement_args& operator=(const IClientRPCService_executeStatement_args&);
  IClientRPCService_executeStatement_args() {
  }

  virtual ~IClientRPCService_executeStatement_args() noexcept;
  TSExecuteStatementReq req;

  _IClientRPCService_executeStatement_args__isset __isset;

  void __set_req(const TSExecuteStatementReq& val);

  bool operator == (const IClientRPCService_executeStatement_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeStatement_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeStatement_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_executeStatement_pargs {
 public:


  virtual ~IClientRPCService_executeStatement_pargs() noexcept;
  const TSExecuteStatementReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeStatement_result__isset {
  _IClientRPCService_executeStatement_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeStatement_result__isset;

class IClientRPCService_executeStatement_result {
 public:

  IClientRPCService_executeStatement_result(const IClientRPCService_executeStatement_result&);
  IClientRPCService_executeStatement_result& operator=(const IClientRPCService_executeStatement_result&);
  IClientRPCService_executeStatement_result() {
  }

  virtual ~IClientRPCService_executeStatement_result() noexcept;
  TSExecuteStatementResp success;

  _IClientRPCService_executeStatement_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

  bool operator == (const IClientRPCService_executeStatement_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeStatement_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeStatement_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeStatement_presult__isset {
  _IClientRPCService_executeStatement_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeStatement_presult__isset;

class IClientRPCService_executeStatement_presult {
 public:


  virtual ~IClientRPCService_executeStatement_presult() noexcept;
  TSExecuteStatementResp* success;

  _IClientRPCService_executeStatement_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_executeBatchStatement_args__isset {
  _IClientRPCService_executeBatchStatement_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_executeBatchStatement_args__isset;

class IClientRPCService_executeBatchStatement_args {
 public:

  IClientRPCService_executeBatchStatement_args(const IClientRPCService_executeBatchStatement_args&);
  IClientRPCService_executeBatchStatement_args& operator=(const IClientRPCService_executeBatchStatement_args&);
  IClientRPCService_executeBatchStatement_args() {
  }

  virtual ~IClientRPCService_executeBatchStatement_args() noexcept;
  TSExecuteBatchStatementReq req;

  _IClientRPCService_executeBatchStatement_args__isset __isset;

  void __set_req(const TSExecuteBatchStatementReq& val);

  bool operator == (const IClientRPCService_executeBatchStatement_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeBatchStatement_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeBatchStatement_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_executeBatchStatement_pargs {
 public:


  virtual ~IClientRPCService_executeBatchStatement_pargs() noexcept;
  const TSExecuteBatchStatementReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeBatchStatement_result__isset {
  _IClientRPCService_executeBatchStatement_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeBatchStatement_result__isset;

class IClientRPCService_executeBatchStatement_result {
 public:

  IClientRPCService_executeBatchStatement_result(const IClientRPCService_executeBatchStatement_result&);
  IClientRPCService_executeBatchStatement_result& operator=(const IClientRPCService_executeBatchStatement_result&);
  IClientRPCService_executeBatchStatement_result() {
  }

  virtual ~IClientRPCService_executeBatchStatement_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_executeBatchStatement_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_executeBatchStatement_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeBatchStatement_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeBatchStatement_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeBatchStatement_presult__isset {
  _IClientRPCService_executeBatchStatement_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeBatchStatement_presult__isset;

class IClientRPCService_executeBatchStatement_presult {
 public:


  virtual ~IClientRPCService_executeBatchStatement_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_executeBatchStatement_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_executeQueryStatement_args__isset {
  _IClientRPCService_executeQueryStatement_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_executeQueryStatement_args__isset;

class IClientRPCService_executeQueryStatement_args {
 public:

  IClientRPCService_executeQueryStatement_args(const IClientRPCService_executeQueryStatement_args&);
  IClientRPCService_executeQueryStatement_args& operator=(const IClientRPCService_executeQueryStatement_args&);
  IClientRPCService_executeQueryStatement_args() {
  }

  virtual ~IClientRPCService_executeQueryStatement_args() noexcept;
  TSExecuteStatementReq req;

  _IClientRPCService_executeQueryStatement_args__isset __isset;

  void __set_req(const TSExecuteStatementReq& val);

  bool operator == (const IClientRPCService_executeQueryStatement_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeQueryStatement_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeQueryStatement_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_executeQueryStatement_pargs {
 public:


  virtual ~IClientRPCService_executeQueryStatement_pargs() noexcept;
  const TSExecuteStatementReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeQueryStatement_result__isset {
  _IClientRPCService_executeQueryStatement_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeQueryStatement_result__isset;

class IClientRPCService_executeQueryStatement_result {
 public:

  IClientRPCService_executeQueryStatement_result(const IClientRPCService_executeQueryStatement_result&);
  IClientRPCService_executeQueryStatement_result& operator=(const IClientRPCService_executeQueryStatement_result&);
  IClientRPCService_executeQueryStatement_result() {
  }

  virtual ~IClientRPCService_executeQueryStatement_result() noexcept;
  TSExecuteStatementResp success;

  _IClientRPCService_executeQueryStatement_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

  bool operator == (const IClientRPCService_executeQueryStatement_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeQueryStatement_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeQueryStatement_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeQueryStatement_presult__isset {
  _IClientRPCService_executeQueryStatement_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeQueryStatement_presult__isset;

class IClientRPCService_executeQueryStatement_presult {
 public:


  virtual ~IClientRPCService_executeQueryStatement_presult() noexcept;
  TSExecuteStatementResp* success;

  _IClientRPCService_executeQueryStatement_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_executeUpdateStatement_args__isset {
  _IClientRPCService_executeUpdateStatement_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_executeUpdateStatement_args__isset;

class IClientRPCService_executeUpdateStatement_args {
 public:

  IClientRPCService_executeUpdateStatement_args(const IClientRPCService_executeUpdateStatement_args&);
  IClientRPCService_executeUpdateStatement_args& operator=(const IClientRPCService_executeUpdateStatement_args&);
  IClientRPCService_executeUpdateStatement_args() {
  }

  virtual ~IClientRPCService_executeUpdateStatement_args() noexcept;
  TSExecuteStatementReq req;

  _IClientRPCService_executeUpdateStatement_args__isset __isset;

  void __set_req(const TSExecuteStatementReq& val);

  bool operator == (const IClientRPCService_executeUpdateStatement_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeUpdateStatement_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeUpdateStatement_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_executeUpdateStatement_pargs {
 public:


  virtual ~IClientRPCService_executeUpdateStatement_pargs() noexcept;
  const TSExecuteStatementReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeUpdateStatement_result__isset {
  _IClientRPCService_executeUpdateStatement_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeUpdateStatement_result__isset;

class IClientRPCService_executeUpdateStatement_result {
 public:

  IClientRPCService_executeUpdateStatement_result(const IClientRPCService_executeUpdateStatement_result&);
  IClientRPCService_executeUpdateStatement_result& operator=(const IClientRPCService_executeUpdateStatement_result&);
  IClientRPCService_executeUpdateStatement_result() {
  }

  virtual ~IClientRPCService_executeUpdateStatement_result() noexcept;
  TSExecuteStatementResp success;

  _IClientRPCService_executeUpdateStatement_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

  bool operator == (const IClientRPCService_executeUpdateStatement_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeUpdateStatement_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeUpdateStatement_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeUpdateStatement_presult__isset {
  _IClientRPCService_executeUpdateStatement_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeUpdateStatement_presult__isset;

class IClientRPCService_executeUpdateStatement_presult {
 public:


  virtual ~IClientRPCService_executeUpdateStatement_presult() noexcept;
  TSExecuteStatementResp* success;

  _IClientRPCService_executeUpdateStatement_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_fetchResults_args__isset {
  _IClientRPCService_fetchResults_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_fetchResults_args__isset;

class IClientRPCService_fetchResults_args {
 public:

  IClientRPCService_fetchResults_args(const IClientRPCService_fetchResults_args&);
  IClientRPCService_fetchResults_args& operator=(const IClientRPCService_fetchResults_args&);
  IClientRPCService_fetchResults_args() {
  }

  virtual ~IClientRPCService_fetchResults_args() noexcept;
  TSFetchResultsReq req;

  _IClientRPCService_fetchResults_args__isset __isset;

  void __set_req(const TSFetchResultsReq& val);

  bool operator == (const IClientRPCService_fetchResults_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_fetchResults_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_fetchResults_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_fetchResults_pargs {
 public:


  virtual ~IClientRPCService_fetchResults_pargs() noexcept;
  const TSFetchResultsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_fetchResults_result__isset {
  _IClientRPCService_fetchResults_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_fetchResults_result__isset;

class IClientRPCService_fetchResults_result {
 public:

  IClientRPCService_fetchResults_result(const IClientRPCService_fetchResults_result&);
  IClientRPCService_fetchResults_result& operator=(const IClientRPCService_fetchResults_result&);
  IClientRPCService_fetchResults_result() {
  }

  virtual ~IClientRPCService_fetchResults_result() noexcept;
  TSFetchResultsResp success;

  _IClientRPCService_fetchResults_result__isset __isset;

  void __set_success(const TSFetchResultsResp& val);

  bool operator == (const IClientRPCService_fetchResults_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_fetchResults_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_fetchResults_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_fetchResults_presult__isset {
  _IClientRPCService_fetchResults_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_fetchResults_presult__isset;

class IClientRPCService_fetchResults_presult {
 public:


  virtual ~IClientRPCService_fetchResults_presult() noexcept;
  TSFetchResultsResp* success;

  _IClientRPCService_fetchResults_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_fetchMetadata_args__isset {
  _IClientRPCService_fetchMetadata_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_fetchMetadata_args__isset;

class IClientRPCService_fetchMetadata_args {
 public:

  IClientRPCService_fetchMetadata_args(const IClientRPCService_fetchMetadata_args&);
  IClientRPCService_fetchMetadata_args& operator=(const IClientRPCService_fetchMetadata_args&);
  IClientRPCService_fetchMetadata_args() {
  }

  virtual ~IClientRPCService_fetchMetadata_args() noexcept;
  TSFetchMetadataReq req;

  _IClientRPCService_fetchMetadata_args__isset __isset;

  void __set_req(const TSFetchMetadataReq& val);

  bool operator == (const IClientRPCService_fetchMetadata_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_fetchMetadata_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_fetchMetadata_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_fetchMetadata_pargs {
 public:


  virtual ~IClientRPCService_fetchMetadata_pargs() noexcept;
  const TSFetchMetadataReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_fetchMetadata_result__isset {
  _IClientRPCService_fetchMetadata_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_fetchMetadata_result__isset;

class IClientRPCService_fetchMetadata_result {
 public:

  IClientRPCService_fetchMetadata_result(const IClientRPCService_fetchMetadata_result&);
  IClientRPCService_fetchMetadata_result& operator=(const IClientRPCService_fetchMetadata_result&);
  IClientRPCService_fetchMetadata_result() {
  }

  virtual ~IClientRPCService_fetchMetadata_result() noexcept;
  TSFetchMetadataResp success;

  _IClientRPCService_fetchMetadata_result__isset __isset;

  void __set_success(const TSFetchMetadataResp& val);

  bool operator == (const IClientRPCService_fetchMetadata_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_fetchMetadata_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_fetchMetadata_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_fetchMetadata_presult__isset {
  _IClientRPCService_fetchMetadata_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_fetchMetadata_presult__isset;

class IClientRPCService_fetchMetadata_presult {
 public:


  virtual ~IClientRPCService_fetchMetadata_presult() noexcept;
  TSFetchMetadataResp* success;

  _IClientRPCService_fetchMetadata_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_cancelOperation_args__isset {
  _IClientRPCService_cancelOperation_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_cancelOperation_args__isset;

class IClientRPCService_cancelOperation_args {
 public:

  IClientRPCService_cancelOperation_args(const IClientRPCService_cancelOperation_args&);
  IClientRPCService_cancelOperation_args& operator=(const IClientRPCService_cancelOperation_args&);
  IClientRPCService_cancelOperation_args() {
  }

  virtual ~IClientRPCService_cancelOperation_args() noexcept;
  TSCancelOperationReq req;

  _IClientRPCService_cancelOperation_args__isset __isset;

  void __set_req(const TSCancelOperationReq& val);

  bool operator == (const IClientRPCService_cancelOperation_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_cancelOperation_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_cancelOperation_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_cancelOperation_pargs {
 public:


  virtual ~IClientRPCService_cancelOperation_pargs() noexcept;
  const TSCancelOperationReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_cancelOperation_result__isset {
  _IClientRPCService_cancelOperation_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_cancelOperation_result__isset;

class IClientRPCService_cancelOperation_result {
 public:

  IClientRPCService_cancelOperation_result(const IClientRPCService_cancelOperation_result&);
  IClientRPCService_cancelOperation_result& operator=(const IClientRPCService_cancelOperation_result&);
  IClientRPCService_cancelOperation_result() {
  }

  virtual ~IClientRPCService_cancelOperation_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_cancelOperation_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_cancelOperation_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_cancelOperation_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_cancelOperation_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_cancelOperation_presult__isset {
  _IClientRPCService_cancelOperation_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_cancelOperation_presult__isset;

class IClientRPCService_cancelOperation_presult {
 public:


  virtual ~IClientRPCService_cancelOperation_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_cancelOperation_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_closeOperation_args__isset {
  _IClientRPCService_closeOperation_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_closeOperation_args__isset;

class IClientRPCService_closeOperation_args {
 public:

  IClientRPCService_closeOperation_args(const IClientRPCService_closeOperation_args&);
  IClientRPCService_closeOperation_args& operator=(const IClientRPCService_closeOperation_args&);
  IClientRPCService_closeOperation_args() {
  }

  virtual ~IClientRPCService_closeOperation_args() noexcept;
  TSCloseOperationReq req;

  _IClientRPCService_closeOperation_args__isset __isset;

  void __set_req(const TSCloseOperationReq& val);

  bool operator == (const IClientRPCService_closeOperation_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_closeOperation_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_closeOperation_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_closeOperation_pargs {
 public:


  virtual ~IClientRPCService_closeOperation_pargs() noexcept;
  const TSCloseOperationReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_closeOperation_result__isset {
  _IClientRPCService_closeOperation_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_closeOperation_result__isset;

class IClientRPCService_closeOperation_result {
 public:

  IClientRPCService_closeOperation_result(const IClientRPCService_closeOperation_result&);
  IClientRPCService_closeOperation_result& operator=(const IClientRPCService_closeOperation_result&);
  IClientRPCService_closeOperation_result() {
  }

  virtual ~IClientRPCService_closeOperation_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_closeOperation_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_closeOperation_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_closeOperation_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_closeOperation_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_closeOperation_presult__isset {
  _IClientRPCService_closeOperation_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_closeOperation_presult__isset;

class IClientRPCService_closeOperation_presult {
 public:


  virtual ~IClientRPCService_closeOperation_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_closeOperation_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_getTimeZone_args__isset {
  _IClientRPCService_getTimeZone_args__isset() : sessionId(false) {}
  bool sessionId :1;
} _IClientRPCService_getTimeZone_args__isset;

class IClientRPCService_getTimeZone_args {
 public:

  IClientRPCService_getTimeZone_args(const IClientRPCService_getTimeZone_args&);
  IClientRPCService_getTimeZone_args& operator=(const IClientRPCService_getTimeZone_args&);
  IClientRPCService_getTimeZone_args() : sessionId(0) {
  }

  virtual ~IClientRPCService_getTimeZone_args() noexcept;
  int64_t sessionId;

  _IClientRPCService_getTimeZone_args__isset __isset;

  void __set_sessionId(const int64_t val);

  bool operator == (const IClientRPCService_getTimeZone_args & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_getTimeZone_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_getTimeZone_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_getTimeZone_pargs {
 public:


  virtual ~IClientRPCService_getTimeZone_pargs() noexcept;
  const int64_t* sessionId;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_getTimeZone_result__isset {
  _IClientRPCService_getTimeZone_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_getTimeZone_result__isset;

class IClientRPCService_getTimeZone_result {
 public:

  IClientRPCService_getTimeZone_result(const IClientRPCService_getTimeZone_result&);
  IClientRPCService_getTimeZone_result& operator=(const IClientRPCService_getTimeZone_result&);
  IClientRPCService_getTimeZone_result() {
  }

  virtual ~IClientRPCService_getTimeZone_result() noexcept;
  TSGetTimeZoneResp success;

  _IClientRPCService_getTimeZone_result__isset __isset;

  void __set_success(const TSGetTimeZoneResp& val);

  bool operator == (const IClientRPCService_getTimeZone_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_getTimeZone_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_getTimeZone_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_getTimeZone_presult__isset {
  _IClientRPCService_getTimeZone_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_getTimeZone_presult__isset;

class IClientRPCService_getTimeZone_presult {
 public:


  virtual ~IClientRPCService_getTimeZone_presult() noexcept;
  TSGetTimeZoneResp* success;

  _IClientRPCService_getTimeZone_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_setTimeZone_args__isset {
  _IClientRPCService_setTimeZone_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_setTimeZone_args__isset;

class IClientRPCService_setTimeZone_args {
 public:

  IClientRPCService_setTimeZone_args(const IClientRPCService_setTimeZone_args&);
  IClientRPCService_setTimeZone_args& operator=(const IClientRPCService_setTimeZone_args&);
  IClientRPCService_setTimeZone_args() {
  }

  virtual ~IClientRPCService_setTimeZone_args() noexcept;
  TSSetTimeZoneReq req;

  _IClientRPCService_setTimeZone_args__isset __isset;

  void __set_req(const TSSetTimeZoneReq& val);

  bool operator == (const IClientRPCService_setTimeZone_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_setTimeZone_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_setTimeZone_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_setTimeZone_pargs {
 public:


  virtual ~IClientRPCService_setTimeZone_pargs() noexcept;
  const TSSetTimeZoneReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_setTimeZone_result__isset {
  _IClientRPCService_setTimeZone_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_setTimeZone_result__isset;

class IClientRPCService_setTimeZone_result {
 public:

  IClientRPCService_setTimeZone_result(const IClientRPCService_setTimeZone_result&);
  IClientRPCService_setTimeZone_result& operator=(const IClientRPCService_setTimeZone_result&);
  IClientRPCService_setTimeZone_result() {
  }

  virtual ~IClientRPCService_setTimeZone_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_setTimeZone_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_setTimeZone_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_setTimeZone_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_setTimeZone_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_setTimeZone_presult__isset {
  _IClientRPCService_setTimeZone_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_setTimeZone_presult__isset;

class IClientRPCService_setTimeZone_presult {
 public:


  virtual ~IClientRPCService_setTimeZone_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_setTimeZone_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class IClientRPCService_getProperties_args {
 public:

  IClientRPCService_getProperties_args(const IClientRPCService_getProperties_args&);
  IClientRPCService_getProperties_args& operator=(const IClientRPCService_getProperties_args&);
  IClientRPCService_getProperties_args() {
  }

  virtual ~IClientRPCService_getProperties_args() noexcept;

  bool operator == (const IClientRPCService_getProperties_args & /* rhs */) const
  {
    return true;
  }
  bool operator != (const IClientRPCService_getProperties_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_getProperties_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_getProperties_pargs {
 public:


  virtual ~IClientRPCService_getProperties_pargs() noexcept;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_getProperties_result__isset {
  _IClientRPCService_getProperties_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_getProperties_result__isset;

class IClientRPCService_getProperties_result {
 public:

  IClientRPCService_getProperties_result(const IClientRPCService_getProperties_result&);
  IClientRPCService_getProperties_result& operator=(const IClientRPCService_getProperties_result&);
  IClientRPCService_getProperties_result() {
  }

  virtual ~IClientRPCService_getProperties_result() noexcept;
  ServerProperties success;

  _IClientRPCService_getProperties_result__isset __isset;

  void __set_success(const ServerProperties& val);

  bool operator == (const IClientRPCService_getProperties_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_getProperties_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_getProperties_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_getProperties_presult__isset {
  _IClientRPCService_getProperties_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_getProperties_presult__isset;

class IClientRPCService_getProperties_presult {
 public:


  virtual ~IClientRPCService_getProperties_presult() noexcept;
  ServerProperties* success;

  _IClientRPCService_getProperties_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_setStorageGroup_args__isset {
  _IClientRPCService_setStorageGroup_args__isset() : sessionId(false), storageGroup(false) {}
  bool sessionId :1;
  bool storageGroup :1;
} _IClientRPCService_setStorageGroup_args__isset;

class IClientRPCService_setStorageGroup_args {
 public:

  IClientRPCService_setStorageGroup_args(const IClientRPCService_setStorageGroup_args&);
  IClientRPCService_setStorageGroup_args& operator=(const IClientRPCService_setStorageGroup_args&);
  IClientRPCService_setStorageGroup_args() : sessionId(0), storageGroup() {
  }

  virtual ~IClientRPCService_setStorageGroup_args() noexcept;
  int64_t sessionId;
  std::string storageGroup;

  _IClientRPCService_setStorageGroup_args__isset __isset;

  void __set_sessionId(const int64_t val);

  void __set_storageGroup(const std::string& val);

  bool operator == (const IClientRPCService_setStorageGroup_args & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(storageGroup == rhs.storageGroup))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_setStorageGroup_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_setStorageGroup_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_setStorageGroup_pargs {
 public:


  virtual ~IClientRPCService_setStorageGroup_pargs() noexcept;
  const int64_t* sessionId;
  const std::string* storageGroup;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_setStorageGroup_result__isset {
  _IClientRPCService_setStorageGroup_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_setStorageGroup_result__isset;

class IClientRPCService_setStorageGroup_result {
 public:

  IClientRPCService_setStorageGroup_result(const IClientRPCService_setStorageGroup_result&);
  IClientRPCService_setStorageGroup_result& operator=(const IClientRPCService_setStorageGroup_result&);
  IClientRPCService_setStorageGroup_result() {
  }

  virtual ~IClientRPCService_setStorageGroup_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_setStorageGroup_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_setStorageGroup_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_setStorageGroup_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_setStorageGroup_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_setStorageGroup_presult__isset {
  _IClientRPCService_setStorageGroup_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_setStorageGroup_presult__isset;

class IClientRPCService_setStorageGroup_presult {
 public:


  virtual ~IClientRPCService_setStorageGroup_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_setStorageGroup_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_createTimeseries_args__isset {
  _IClientRPCService_createTimeseries_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_createTimeseries_args__isset;

class IClientRPCService_createTimeseries_args {
 public:

  IClientRPCService_createTimeseries_args(const IClientRPCService_createTimeseries_args&);
  IClientRPCService_createTimeseries_args& operator=(const IClientRPCService_createTimeseries_args&);
  IClientRPCService_createTimeseries_args() {
  }

  virtual ~IClientRPCService_createTimeseries_args() noexcept;
  TSCreateTimeseriesReq req;

  _IClientRPCService_createTimeseries_args__isset __isset;

  void __set_req(const TSCreateTimeseriesReq& val);

  bool operator == (const IClientRPCService_createTimeseries_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_createTimeseries_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_createTimeseries_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_createTimeseries_pargs {
 public:


  virtual ~IClientRPCService_createTimeseries_pargs() noexcept;
  const TSCreateTimeseriesReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_createTimeseries_result__isset {
  _IClientRPCService_createTimeseries_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_createTimeseries_result__isset;

class IClientRPCService_createTimeseries_result {
 public:

  IClientRPCService_createTimeseries_result(const IClientRPCService_createTimeseries_result&);
  IClientRPCService_createTimeseries_result& operator=(const IClientRPCService_createTimeseries_result&);
  IClientRPCService_createTimeseries_result() {
  }

  virtual ~IClientRPCService_createTimeseries_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_createTimeseries_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_createTimeseries_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_createTimeseries_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_createTimeseries_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_createTimeseries_presult__isset {
  _IClientRPCService_createTimeseries_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_createTimeseries_presult__isset;

class IClientRPCService_createTimeseries_presult {
 public:


  virtual ~IClientRPCService_createTimeseries_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_createTimeseries_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_createAlignedTimeseries_args__isset {
  _IClientRPCService_createAlignedTimeseries_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_createAlignedTimeseries_args__isset;

class IClientRPCService_createAlignedTimeseries_args {
 public:

  IClientRPCService_createAlignedTimeseries_args(const IClientRPCService_createAlignedTimeseries_args&);
  IClientRPCService_createAlignedTimeseries_args& operator=(const IClientRPCService_createAlignedTimeseries_args&);
  IClientRPCService_createAlignedTimeseries_args() {
  }

  virtual ~IClientRPCService_createAlignedTimeseries_args() noexcept;
  TSCreateAlignedTimeseriesReq req;

  _IClientRPCService_createAlignedTimeseries_args__isset __isset;

  void __set_req(const TSCreateAlignedTimeseriesReq& val);

  bool operator == (const IClientRPCService_createAlignedTimeseries_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_createAlignedTimeseries_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_createAlignedTimeseries_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_createAlignedTimeseries_pargs {
 public:


  virtual ~IClientRPCService_createAlignedTimeseries_pargs() noexcept;
  const TSCreateAlignedTimeseriesReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_createAlignedTimeseries_result__isset {
  _IClientRPCService_createAlignedTimeseries_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_createAlignedTimeseries_result__isset;

class IClientRPCService_createAlignedTimeseries_result {
 public:

  IClientRPCService_createAlignedTimeseries_result(const IClientRPCService_createAlignedTimeseries_result&);
  IClientRPCService_createAlignedTimeseries_result& operator=(const IClientRPCService_createAlignedTimeseries_result&);
  IClientRPCService_createAlignedTimeseries_result() {
  }

  virtual ~IClientRPCService_createAlignedTimeseries_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_createAlignedTimeseries_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_createAlignedTimeseries_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_createAlignedTimeseries_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_createAlignedTimeseries_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_createAlignedTimeseries_presult__isset {
  _IClientRPCService_createAlignedTimeseries_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_createAlignedTimeseries_presult__isset;

class IClientRPCService_createAlignedTimeseries_presult {
 public:


  virtual ~IClientRPCService_createAlignedTimeseries_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_createAlignedTimeseries_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_createMultiTimeseries_args__isset {
  _IClientRPCService_createMultiTimeseries_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_createMultiTimeseries_args__isset;

class IClientRPCService_createMultiTimeseries_args {
 public:

  IClientRPCService_createMultiTimeseries_args(const IClientRPCService_createMultiTimeseries_args&);
  IClientRPCService_createMultiTimeseries_args& operator=(const IClientRPCService_createMultiTimeseries_args&);
  IClientRPCService_createMultiTimeseries_args() {
  }

  virtual ~IClientRPCService_createMultiTimeseries_args() noexcept;
  TSCreateMultiTimeseriesReq req;

  _IClientRPCService_createMultiTimeseries_args__isset __isset;

  void __set_req(const TSCreateMultiTimeseriesReq& val);

  bool operator == (const IClientRPCService_createMultiTimeseries_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_createMultiTimeseries_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_createMultiTimeseries_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_createMultiTimeseries_pargs {
 public:


  virtual ~IClientRPCService_createMultiTimeseries_pargs() noexcept;
  const TSCreateMultiTimeseriesReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_createMultiTimeseries_result__isset {
  _IClientRPCService_createMultiTimeseries_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_createMultiTimeseries_result__isset;

class IClientRPCService_createMultiTimeseries_result {
 public:

  IClientRPCService_createMultiTimeseries_result(const IClientRPCService_createMultiTimeseries_result&);
  IClientRPCService_createMultiTimeseries_result& operator=(const IClientRPCService_createMultiTimeseries_result&);
  IClientRPCService_createMultiTimeseries_result() {
  }

  virtual ~IClientRPCService_createMultiTimeseries_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_createMultiTimeseries_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_createMultiTimeseries_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_createMultiTimeseries_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_createMultiTimeseries_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_createMultiTimeseries_presult__isset {
  _IClientRPCService_createMultiTimeseries_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_createMultiTimeseries_presult__isset;

class IClientRPCService_createMultiTimeseries_presult {
 public:


  virtual ~IClientRPCService_createMultiTimeseries_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_createMultiTimeseries_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_deleteTimeseries_args__isset {
  _IClientRPCService_deleteTimeseries_args__isset() : sessionId(false), path(false) {}
  bool sessionId :1;
  bool path :1;
} _IClientRPCService_deleteTimeseries_args__isset;

class IClientRPCService_deleteTimeseries_args {
 public:

  IClientRPCService_deleteTimeseries_args(const IClientRPCService_deleteTimeseries_args&);
  IClientRPCService_deleteTimeseries_args& operator=(const IClientRPCService_deleteTimeseries_args&);
  IClientRPCService_deleteTimeseries_args() : sessionId(0) {
  }

  virtual ~IClientRPCService_deleteTimeseries_args() noexcept;
  int64_t sessionId;
  std::vector<std::string>  path;

  _IClientRPCService_deleteTimeseries_args__isset __isset;

  void __set_sessionId(const int64_t val);

  void __set_path(const std::vector<std::string> & val);

  bool operator == (const IClientRPCService_deleteTimeseries_args & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(path == rhs.path))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_deleteTimeseries_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_deleteTimeseries_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_deleteTimeseries_pargs {
 public:


  virtual ~IClientRPCService_deleteTimeseries_pargs() noexcept;
  const int64_t* sessionId;
  const std::vector<std::string> * path;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_deleteTimeseries_result__isset {
  _IClientRPCService_deleteTimeseries_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_deleteTimeseries_result__isset;

class IClientRPCService_deleteTimeseries_result {
 public:

  IClientRPCService_deleteTimeseries_result(const IClientRPCService_deleteTimeseries_result&);
  IClientRPCService_deleteTimeseries_result& operator=(const IClientRPCService_deleteTimeseries_result&);
  IClientRPCService_deleteTimeseries_result() {
  }

  virtual ~IClientRPCService_deleteTimeseries_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_deleteTimeseries_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_deleteTimeseries_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_deleteTimeseries_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_deleteTimeseries_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_deleteTimeseries_presult__isset {
  _IClientRPCService_deleteTimeseries_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_deleteTimeseries_presult__isset;

class IClientRPCService_deleteTimeseries_presult {
 public:


  virtual ~IClientRPCService_deleteTimeseries_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_deleteTimeseries_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_deleteStorageGroups_args__isset {
  _IClientRPCService_deleteStorageGroups_args__isset() : sessionId(false), storageGroup(false) {}
  bool sessionId :1;
  bool storageGroup :1;
} _IClientRPCService_deleteStorageGroups_args__isset;

class IClientRPCService_deleteStorageGroups_args {
 public:

  IClientRPCService_deleteStorageGroups_args(const IClientRPCService_deleteStorageGroups_args&);
  IClientRPCService_deleteStorageGroups_args& operator=(const IClientRPCService_deleteStorageGroups_args&);
  IClientRPCService_deleteStorageGroups_args() : sessionId(0) {
  }

  virtual ~IClientRPCService_deleteStorageGroups_args() noexcept;
  int64_t sessionId;
  std::vector<std::string>  storageGroup;

  _IClientRPCService_deleteStorageGroups_args__isset __isset;

  void __set_sessionId(const int64_t val);

  void __set_storageGroup(const std::vector<std::string> & val);

  bool operator == (const IClientRPCService_deleteStorageGroups_args & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(storageGroup == rhs.storageGroup))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_deleteStorageGroups_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_deleteStorageGroups_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_deleteStorageGroups_pargs {
 public:


  virtual ~IClientRPCService_deleteStorageGroups_pargs() noexcept;
  const int64_t* sessionId;
  const std::vector<std::string> * storageGroup;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_deleteStorageGroups_result__isset {
  _IClientRPCService_deleteStorageGroups_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_deleteStorageGroups_result__isset;

class IClientRPCService_deleteStorageGroups_result {
 public:

  IClientRPCService_deleteStorageGroups_result(const IClientRPCService_deleteStorageGroups_result&);
  IClientRPCService_deleteStorageGroups_result& operator=(const IClientRPCService_deleteStorageGroups_result&);
  IClientRPCService_deleteStorageGroups_result() {
  }

  virtual ~IClientRPCService_deleteStorageGroups_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_deleteStorageGroups_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_deleteStorageGroups_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_deleteStorageGroups_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_deleteStorageGroups_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_deleteStorageGroups_presult__isset {
  _IClientRPCService_deleteStorageGroups_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_deleteStorageGroups_presult__isset;

class IClientRPCService_deleteStorageGroups_presult {
 public:


  virtual ~IClientRPCService_deleteStorageGroups_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_deleteStorageGroups_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_insertRecord_args__isset {
  _IClientRPCService_insertRecord_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_insertRecord_args__isset;

class IClientRPCService_insertRecord_args {
 public:

  IClientRPCService_insertRecord_args(const IClientRPCService_insertRecord_args&);
  IClientRPCService_insertRecord_args& operator=(const IClientRPCService_insertRecord_args&);
  IClientRPCService_insertRecord_args() {
  }

  virtual ~IClientRPCService_insertRecord_args() noexcept;
  TSInsertRecordReq req;

  _IClientRPCService_insertRecord_args__isset __isset;

  void __set_req(const TSInsertRecordReq& val);

  bool operator == (const IClientRPCService_insertRecord_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertRecord_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertRecord_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_insertRecord_pargs {
 public:


  virtual ~IClientRPCService_insertRecord_pargs() noexcept;
  const TSInsertRecordReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertRecord_result__isset {
  _IClientRPCService_insertRecord_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertRecord_result__isset;

class IClientRPCService_insertRecord_result {
 public:

  IClientRPCService_insertRecord_result(const IClientRPCService_insertRecord_result&);
  IClientRPCService_insertRecord_result& operator=(const IClientRPCService_insertRecord_result&);
  IClientRPCService_insertRecord_result() {
  }

  virtual ~IClientRPCService_insertRecord_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_insertRecord_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_insertRecord_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertRecord_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertRecord_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertRecord_presult__isset {
  _IClientRPCService_insertRecord_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertRecord_presult__isset;

class IClientRPCService_insertRecord_presult {
 public:


  virtual ~IClientRPCService_insertRecord_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_insertRecord_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_insertStringRecord_args__isset {
  _IClientRPCService_insertStringRecord_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_insertStringRecord_args__isset;

class IClientRPCService_insertStringRecord_args {
 public:

  IClientRPCService_insertStringRecord_args(const IClientRPCService_insertStringRecord_args&);
  IClientRPCService_insertStringRecord_args& operator=(const IClientRPCService_insertStringRecord_args&);
  IClientRPCService_insertStringRecord_args() {
  }

  virtual ~IClientRPCService_insertStringRecord_args() noexcept;
  TSInsertStringRecordReq req;

  _IClientRPCService_insertStringRecord_args__isset __isset;

  void __set_req(const TSInsertStringRecordReq& val);

  bool operator == (const IClientRPCService_insertStringRecord_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertStringRecord_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertStringRecord_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_insertStringRecord_pargs {
 public:


  virtual ~IClientRPCService_insertStringRecord_pargs() noexcept;
  const TSInsertStringRecordReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertStringRecord_result__isset {
  _IClientRPCService_insertStringRecord_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertStringRecord_result__isset;

class IClientRPCService_insertStringRecord_result {
 public:

  IClientRPCService_insertStringRecord_result(const IClientRPCService_insertStringRecord_result&);
  IClientRPCService_insertStringRecord_result& operator=(const IClientRPCService_insertStringRecord_result&);
  IClientRPCService_insertStringRecord_result() {
  }

  virtual ~IClientRPCService_insertStringRecord_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_insertStringRecord_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_insertStringRecord_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertStringRecord_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertStringRecord_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertStringRecord_presult__isset {
  _IClientRPCService_insertStringRecord_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertStringRecord_presult__isset;

class IClientRPCService_insertStringRecord_presult {
 public:


  virtual ~IClientRPCService_insertStringRecord_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_insertStringRecord_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_insertTablet_args__isset {
  _IClientRPCService_insertTablet_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_insertTablet_args__isset;

class IClientRPCService_insertTablet_args {
 public:

  IClientRPCService_insertTablet_args(const IClientRPCService_insertTablet_args&);
  IClientRPCService_insertTablet_args& operator=(const IClientRPCService_insertTablet_args&);
  IClientRPCService_insertTablet_args() {
  }

  virtual ~IClientRPCService_insertTablet_args() noexcept;
  TSInsertTabletReq req;

  _IClientRPCService_insertTablet_args__isset __isset;

  void __set_req(const TSInsertTabletReq& val);

  bool operator == (const IClientRPCService_insertTablet_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertTablet_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertTablet_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_insertTablet_pargs {
 public:


  virtual ~IClientRPCService_insertTablet_pargs() noexcept;
  const TSInsertTabletReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertTablet_result__isset {
  _IClientRPCService_insertTablet_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertTablet_result__isset;

class IClientRPCService_insertTablet_result {
 public:

  IClientRPCService_insertTablet_result(const IClientRPCService_insertTablet_result&);
  IClientRPCService_insertTablet_result& operator=(const IClientRPCService_insertTablet_result&);
  IClientRPCService_insertTablet_result() {
  }

  virtual ~IClientRPCService_insertTablet_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_insertTablet_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_insertTablet_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertTablet_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertTablet_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertTablet_presult__isset {
  _IClientRPCService_insertTablet_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertTablet_presult__isset;

class IClientRPCService_insertTablet_presult {
 public:


  virtual ~IClientRPCService_insertTablet_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_insertTablet_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_insertTablets_args__isset {
  _IClientRPCService_insertTablets_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_insertTablets_args__isset;

class IClientRPCService_insertTablets_args {
 public:

  IClientRPCService_insertTablets_args(const IClientRPCService_insertTablets_args&);
  IClientRPCService_insertTablets_args& operator=(const IClientRPCService_insertTablets_args&);
  IClientRPCService_insertTablets_args() {
  }

  virtual ~IClientRPCService_insertTablets_args() noexcept;
  TSInsertTabletsReq req;

  _IClientRPCService_insertTablets_args__isset __isset;

  void __set_req(const TSInsertTabletsReq& val);

  bool operator == (const IClientRPCService_insertTablets_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertTablets_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertTablets_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_insertTablets_pargs {
 public:


  virtual ~IClientRPCService_insertTablets_pargs() noexcept;
  const TSInsertTabletsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertTablets_result__isset {
  _IClientRPCService_insertTablets_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertTablets_result__isset;

class IClientRPCService_insertTablets_result {
 public:

  IClientRPCService_insertTablets_result(const IClientRPCService_insertTablets_result&);
  IClientRPCService_insertTablets_result& operator=(const IClientRPCService_insertTablets_result&);
  IClientRPCService_insertTablets_result() {
  }

  virtual ~IClientRPCService_insertTablets_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_insertTablets_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_insertTablets_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertTablets_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertTablets_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertTablets_presult__isset {
  _IClientRPCService_insertTablets_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertTablets_presult__isset;

class IClientRPCService_insertTablets_presult {
 public:


  virtual ~IClientRPCService_insertTablets_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_insertTablets_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_insertRecords_args__isset {
  _IClientRPCService_insertRecords_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_insertRecords_args__isset;

class IClientRPCService_insertRecords_args {
 public:

  IClientRPCService_insertRecords_args(const IClientRPCService_insertRecords_args&);
  IClientRPCService_insertRecords_args& operator=(const IClientRPCService_insertRecords_args&);
  IClientRPCService_insertRecords_args() {
  }

  virtual ~IClientRPCService_insertRecords_args() noexcept;
  TSInsertRecordsReq req;

  _IClientRPCService_insertRecords_args__isset __isset;

  void __set_req(const TSInsertRecordsReq& val);

  bool operator == (const IClientRPCService_insertRecords_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertRecords_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertRecords_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_insertRecords_pargs {
 public:


  virtual ~IClientRPCService_insertRecords_pargs() noexcept;
  const TSInsertRecordsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertRecords_result__isset {
  _IClientRPCService_insertRecords_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertRecords_result__isset;

class IClientRPCService_insertRecords_result {
 public:

  IClientRPCService_insertRecords_result(const IClientRPCService_insertRecords_result&);
  IClientRPCService_insertRecords_result& operator=(const IClientRPCService_insertRecords_result&);
  IClientRPCService_insertRecords_result() {
  }

  virtual ~IClientRPCService_insertRecords_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_insertRecords_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_insertRecords_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertRecords_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertRecords_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertRecords_presult__isset {
  _IClientRPCService_insertRecords_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertRecords_presult__isset;

class IClientRPCService_insertRecords_presult {
 public:


  virtual ~IClientRPCService_insertRecords_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_insertRecords_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_insertRecordsOfOneDevice_args__isset {
  _IClientRPCService_insertRecordsOfOneDevice_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_insertRecordsOfOneDevice_args__isset;

class IClientRPCService_insertRecordsOfOneDevice_args {
 public:

  IClientRPCService_insertRecordsOfOneDevice_args(const IClientRPCService_insertRecordsOfOneDevice_args&);
  IClientRPCService_insertRecordsOfOneDevice_args& operator=(const IClientRPCService_insertRecordsOfOneDevice_args&);
  IClientRPCService_insertRecordsOfOneDevice_args() {
  }

  virtual ~IClientRPCService_insertRecordsOfOneDevice_args() noexcept;
  TSInsertRecordsOfOneDeviceReq req;

  _IClientRPCService_insertRecordsOfOneDevice_args__isset __isset;

  void __set_req(const TSInsertRecordsOfOneDeviceReq& val);

  bool operator == (const IClientRPCService_insertRecordsOfOneDevice_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertRecordsOfOneDevice_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertRecordsOfOneDevice_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_insertRecordsOfOneDevice_pargs {
 public:


  virtual ~IClientRPCService_insertRecordsOfOneDevice_pargs() noexcept;
  const TSInsertRecordsOfOneDeviceReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertRecordsOfOneDevice_result__isset {
  _IClientRPCService_insertRecordsOfOneDevice_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertRecordsOfOneDevice_result__isset;

class IClientRPCService_insertRecordsOfOneDevice_result {
 public:

  IClientRPCService_insertRecordsOfOneDevice_result(const IClientRPCService_insertRecordsOfOneDevice_result&);
  IClientRPCService_insertRecordsOfOneDevice_result& operator=(const IClientRPCService_insertRecordsOfOneDevice_result&);
  IClientRPCService_insertRecordsOfOneDevice_result() {
  }

  virtual ~IClientRPCService_insertRecordsOfOneDevice_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_insertRecordsOfOneDevice_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_insertRecordsOfOneDevice_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertRecordsOfOneDevice_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertRecordsOfOneDevice_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertRecordsOfOneDevice_presult__isset {
  _IClientRPCService_insertRecordsOfOneDevice_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertRecordsOfOneDevice_presult__isset;

class IClientRPCService_insertRecordsOfOneDevice_presult {
 public:


  virtual ~IClientRPCService_insertRecordsOfOneDevice_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_insertRecordsOfOneDevice_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_insertStringRecordsOfOneDevice_args__isset {
  _IClientRPCService_insertStringRecordsOfOneDevice_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_insertStringRecordsOfOneDevice_args__isset;

class IClientRPCService_insertStringRecordsOfOneDevice_args {
 public:

  IClientRPCService_insertStringRecordsOfOneDevice_args(const IClientRPCService_insertStringRecordsOfOneDevice_args&);
  IClientRPCService_insertStringRecordsOfOneDevice_args& operator=(const IClientRPCService_insertStringRecordsOfOneDevice_args&);
  IClientRPCService_insertStringRecordsOfOneDevice_args() {
  }

  virtual ~IClientRPCService_insertStringRecordsOfOneDevice_args() noexcept;
  TSInsertStringRecordsOfOneDeviceReq req;

  _IClientRPCService_insertStringRecordsOfOneDevice_args__isset __isset;

  void __set_req(const TSInsertStringRecordsOfOneDeviceReq& val);

  bool operator == (const IClientRPCService_insertStringRecordsOfOneDevice_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertStringRecordsOfOneDevice_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertStringRecordsOfOneDevice_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_insertStringRecordsOfOneDevice_pargs {
 public:


  virtual ~IClientRPCService_insertStringRecordsOfOneDevice_pargs() noexcept;
  const TSInsertStringRecordsOfOneDeviceReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertStringRecordsOfOneDevice_result__isset {
  _IClientRPCService_insertStringRecordsOfOneDevice_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertStringRecordsOfOneDevice_result__isset;

class IClientRPCService_insertStringRecordsOfOneDevice_result {
 public:

  IClientRPCService_insertStringRecordsOfOneDevice_result(const IClientRPCService_insertStringRecordsOfOneDevice_result&);
  IClientRPCService_insertStringRecordsOfOneDevice_result& operator=(const IClientRPCService_insertStringRecordsOfOneDevice_result&);
  IClientRPCService_insertStringRecordsOfOneDevice_result() {
  }

  virtual ~IClientRPCService_insertStringRecordsOfOneDevice_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_insertStringRecordsOfOneDevice_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_insertStringRecordsOfOneDevice_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertStringRecordsOfOneDevice_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertStringRecordsOfOneDevice_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertStringRecordsOfOneDevice_presult__isset {
  _IClientRPCService_insertStringRecordsOfOneDevice_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertStringRecordsOfOneDevice_presult__isset;

class IClientRPCService_insertStringRecordsOfOneDevice_presult {
 public:


  virtual ~IClientRPCService_insertStringRecordsOfOneDevice_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_insertStringRecordsOfOneDevice_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_insertStringRecords_args__isset {
  _IClientRPCService_insertStringRecords_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_insertStringRecords_args__isset;

class IClientRPCService_insertStringRecords_args {
 public:

  IClientRPCService_insertStringRecords_args(const IClientRPCService_insertStringRecords_args&);
  IClientRPCService_insertStringRecords_args& operator=(const IClientRPCService_insertStringRecords_args&);
  IClientRPCService_insertStringRecords_args() {
  }

  virtual ~IClientRPCService_insertStringRecords_args() noexcept;
  TSInsertStringRecordsReq req;

  _IClientRPCService_insertStringRecords_args__isset __isset;

  void __set_req(const TSInsertStringRecordsReq& val);

  bool operator == (const IClientRPCService_insertStringRecords_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertStringRecords_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertStringRecords_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_insertStringRecords_pargs {
 public:


  virtual ~IClientRPCService_insertStringRecords_pargs() noexcept;
  const TSInsertStringRecordsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertStringRecords_result__isset {
  _IClientRPCService_insertStringRecords_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertStringRecords_result__isset;

class IClientRPCService_insertStringRecords_result {
 public:

  IClientRPCService_insertStringRecords_result(const IClientRPCService_insertStringRecords_result&);
  IClientRPCService_insertStringRecords_result& operator=(const IClientRPCService_insertStringRecords_result&);
  IClientRPCService_insertStringRecords_result() {
  }

  virtual ~IClientRPCService_insertStringRecords_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_insertStringRecords_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_insertStringRecords_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_insertStringRecords_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_insertStringRecords_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_insertStringRecords_presult__isset {
  _IClientRPCService_insertStringRecords_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_insertStringRecords_presult__isset;

class IClientRPCService_insertStringRecords_presult {
 public:


  virtual ~IClientRPCService_insertStringRecords_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_insertStringRecords_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_testInsertTablet_args__isset {
  _IClientRPCService_testInsertTablet_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_testInsertTablet_args__isset;

class IClientRPCService_testInsertTablet_args {
 public:

  IClientRPCService_testInsertTablet_args(const IClientRPCService_testInsertTablet_args&);
  IClientRPCService_testInsertTablet_args& operator=(const IClientRPCService_testInsertTablet_args&);
  IClientRPCService_testInsertTablet_args() {
  }

  virtual ~IClientRPCService_testInsertTablet_args() noexcept;
  TSInsertTabletReq req;

  _IClientRPCService_testInsertTablet_args__isset __isset;

  void __set_req(const TSInsertTabletReq& val);

  bool operator == (const IClientRPCService_testInsertTablet_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_testInsertTablet_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testInsertTablet_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_testInsertTablet_pargs {
 public:


  virtual ~IClientRPCService_testInsertTablet_pargs() noexcept;
  const TSInsertTabletReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testInsertTablet_result__isset {
  _IClientRPCService_testInsertTablet_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testInsertTablet_result__isset;

class IClientRPCService_testInsertTablet_result {
 public:

  IClientRPCService_testInsertTablet_result(const IClientRPCService_testInsertTablet_result&);
  IClientRPCService_testInsertTablet_result& operator=(const IClientRPCService_testInsertTablet_result&);
  IClientRPCService_testInsertTablet_result() {
  }

  virtual ~IClientRPCService_testInsertTablet_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_testInsertTablet_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_testInsertTablet_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_testInsertTablet_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testInsertTablet_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testInsertTablet_presult__isset {
  _IClientRPCService_testInsertTablet_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testInsertTablet_presult__isset;

class IClientRPCService_testInsertTablet_presult {
 public:


  virtual ~IClientRPCService_testInsertTablet_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_testInsertTablet_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_testInsertTablets_args__isset {
  _IClientRPCService_testInsertTablets_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_testInsertTablets_args__isset;

class IClientRPCService_testInsertTablets_args {
 public:

  IClientRPCService_testInsertTablets_args(const IClientRPCService_testInsertTablets_args&);
  IClientRPCService_testInsertTablets_args& operator=(const IClientRPCService_testInsertTablets_args&);
  IClientRPCService_testInsertTablets_args() {
  }

  virtual ~IClientRPCService_testInsertTablets_args() noexcept;
  TSInsertTabletsReq req;

  _IClientRPCService_testInsertTablets_args__isset __isset;

  void __set_req(const TSInsertTabletsReq& val);

  bool operator == (const IClientRPCService_testInsertTablets_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_testInsertTablets_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testInsertTablets_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_testInsertTablets_pargs {
 public:


  virtual ~IClientRPCService_testInsertTablets_pargs() noexcept;
  const TSInsertTabletsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testInsertTablets_result__isset {
  _IClientRPCService_testInsertTablets_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testInsertTablets_result__isset;

class IClientRPCService_testInsertTablets_result {
 public:

  IClientRPCService_testInsertTablets_result(const IClientRPCService_testInsertTablets_result&);
  IClientRPCService_testInsertTablets_result& operator=(const IClientRPCService_testInsertTablets_result&);
  IClientRPCService_testInsertTablets_result() {
  }

  virtual ~IClientRPCService_testInsertTablets_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_testInsertTablets_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_testInsertTablets_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_testInsertTablets_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testInsertTablets_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testInsertTablets_presult__isset {
  _IClientRPCService_testInsertTablets_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testInsertTablets_presult__isset;

class IClientRPCService_testInsertTablets_presult {
 public:


  virtual ~IClientRPCService_testInsertTablets_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_testInsertTablets_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_testInsertRecord_args__isset {
  _IClientRPCService_testInsertRecord_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_testInsertRecord_args__isset;

class IClientRPCService_testInsertRecord_args {
 public:

  IClientRPCService_testInsertRecord_args(const IClientRPCService_testInsertRecord_args&);
  IClientRPCService_testInsertRecord_args& operator=(const IClientRPCService_testInsertRecord_args&);
  IClientRPCService_testInsertRecord_args() {
  }

  virtual ~IClientRPCService_testInsertRecord_args() noexcept;
  TSInsertRecordReq req;

  _IClientRPCService_testInsertRecord_args__isset __isset;

  void __set_req(const TSInsertRecordReq& val);

  bool operator == (const IClientRPCService_testInsertRecord_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_testInsertRecord_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testInsertRecord_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_testInsertRecord_pargs {
 public:


  virtual ~IClientRPCService_testInsertRecord_pargs() noexcept;
  const TSInsertRecordReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testInsertRecord_result__isset {
  _IClientRPCService_testInsertRecord_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testInsertRecord_result__isset;

class IClientRPCService_testInsertRecord_result {
 public:

  IClientRPCService_testInsertRecord_result(const IClientRPCService_testInsertRecord_result&);
  IClientRPCService_testInsertRecord_result& operator=(const IClientRPCService_testInsertRecord_result&);
  IClientRPCService_testInsertRecord_result() {
  }

  virtual ~IClientRPCService_testInsertRecord_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_testInsertRecord_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_testInsertRecord_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_testInsertRecord_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testInsertRecord_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testInsertRecord_presult__isset {
  _IClientRPCService_testInsertRecord_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testInsertRecord_presult__isset;

class IClientRPCService_testInsertRecord_presult {
 public:


  virtual ~IClientRPCService_testInsertRecord_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_testInsertRecord_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_testInsertStringRecord_args__isset {
  _IClientRPCService_testInsertStringRecord_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_testInsertStringRecord_args__isset;

class IClientRPCService_testInsertStringRecord_args {
 public:

  IClientRPCService_testInsertStringRecord_args(const IClientRPCService_testInsertStringRecord_args&);
  IClientRPCService_testInsertStringRecord_args& operator=(const IClientRPCService_testInsertStringRecord_args&);
  IClientRPCService_testInsertStringRecord_args() {
  }

  virtual ~IClientRPCService_testInsertStringRecord_args() noexcept;
  TSInsertStringRecordReq req;

  _IClientRPCService_testInsertStringRecord_args__isset __isset;

  void __set_req(const TSInsertStringRecordReq& val);

  bool operator == (const IClientRPCService_testInsertStringRecord_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_testInsertStringRecord_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testInsertStringRecord_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_testInsertStringRecord_pargs {
 public:


  virtual ~IClientRPCService_testInsertStringRecord_pargs() noexcept;
  const TSInsertStringRecordReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testInsertStringRecord_result__isset {
  _IClientRPCService_testInsertStringRecord_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testInsertStringRecord_result__isset;

class IClientRPCService_testInsertStringRecord_result {
 public:

  IClientRPCService_testInsertStringRecord_result(const IClientRPCService_testInsertStringRecord_result&);
  IClientRPCService_testInsertStringRecord_result& operator=(const IClientRPCService_testInsertStringRecord_result&);
  IClientRPCService_testInsertStringRecord_result() {
  }

  virtual ~IClientRPCService_testInsertStringRecord_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_testInsertStringRecord_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_testInsertStringRecord_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_testInsertStringRecord_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testInsertStringRecord_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testInsertStringRecord_presult__isset {
  _IClientRPCService_testInsertStringRecord_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testInsertStringRecord_presult__isset;

class IClientRPCService_testInsertStringRecord_presult {
 public:


  virtual ~IClientRPCService_testInsertStringRecord_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_testInsertStringRecord_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_testInsertRecords_args__isset {
  _IClientRPCService_testInsertRecords_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_testInsertRecords_args__isset;

class IClientRPCService_testInsertRecords_args {
 public:

  IClientRPCService_testInsertRecords_args(const IClientRPCService_testInsertRecords_args&);
  IClientRPCService_testInsertRecords_args& operator=(const IClientRPCService_testInsertRecords_args&);
  IClientRPCService_testInsertRecords_args() {
  }

  virtual ~IClientRPCService_testInsertRecords_args() noexcept;
  TSInsertRecordsReq req;

  _IClientRPCService_testInsertRecords_args__isset __isset;

  void __set_req(const TSInsertRecordsReq& val);

  bool operator == (const IClientRPCService_testInsertRecords_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_testInsertRecords_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testInsertRecords_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_testInsertRecords_pargs {
 public:


  virtual ~IClientRPCService_testInsertRecords_pargs() noexcept;
  const TSInsertRecordsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testInsertRecords_result__isset {
  _IClientRPCService_testInsertRecords_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testInsertRecords_result__isset;

class IClientRPCService_testInsertRecords_result {
 public:

  IClientRPCService_testInsertRecords_result(const IClientRPCService_testInsertRecords_result&);
  IClientRPCService_testInsertRecords_result& operator=(const IClientRPCService_testInsertRecords_result&);
  IClientRPCService_testInsertRecords_result() {
  }

  virtual ~IClientRPCService_testInsertRecords_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_testInsertRecords_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_testInsertRecords_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_testInsertRecords_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testInsertRecords_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testInsertRecords_presult__isset {
  _IClientRPCService_testInsertRecords_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testInsertRecords_presult__isset;

class IClientRPCService_testInsertRecords_presult {
 public:


  virtual ~IClientRPCService_testInsertRecords_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_testInsertRecords_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_testInsertRecordsOfOneDevice_args__isset {
  _IClientRPCService_testInsertRecordsOfOneDevice_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_testInsertRecordsOfOneDevice_args__isset;

class IClientRPCService_testInsertRecordsOfOneDevice_args {
 public:

  IClientRPCService_testInsertRecordsOfOneDevice_args(const IClientRPCService_testInsertRecordsOfOneDevice_args&);
  IClientRPCService_testInsertRecordsOfOneDevice_args& operator=(const IClientRPCService_testInsertRecordsOfOneDevice_args&);
  IClientRPCService_testInsertRecordsOfOneDevice_args() {
  }

  virtual ~IClientRPCService_testInsertRecordsOfOneDevice_args() noexcept;
  TSInsertRecordsOfOneDeviceReq req;

  _IClientRPCService_testInsertRecordsOfOneDevice_args__isset __isset;

  void __set_req(const TSInsertRecordsOfOneDeviceReq& val);

  bool operator == (const IClientRPCService_testInsertRecordsOfOneDevice_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_testInsertRecordsOfOneDevice_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testInsertRecordsOfOneDevice_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_testInsertRecordsOfOneDevice_pargs {
 public:


  virtual ~IClientRPCService_testInsertRecordsOfOneDevice_pargs() noexcept;
  const TSInsertRecordsOfOneDeviceReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testInsertRecordsOfOneDevice_result__isset {
  _IClientRPCService_testInsertRecordsOfOneDevice_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testInsertRecordsOfOneDevice_result__isset;

class IClientRPCService_testInsertRecordsOfOneDevice_result {
 public:

  IClientRPCService_testInsertRecordsOfOneDevice_result(const IClientRPCService_testInsertRecordsOfOneDevice_result&);
  IClientRPCService_testInsertRecordsOfOneDevice_result& operator=(const IClientRPCService_testInsertRecordsOfOneDevice_result&);
  IClientRPCService_testInsertRecordsOfOneDevice_result() {
  }

  virtual ~IClientRPCService_testInsertRecordsOfOneDevice_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_testInsertRecordsOfOneDevice_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_testInsertRecordsOfOneDevice_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_testInsertRecordsOfOneDevice_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testInsertRecordsOfOneDevice_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testInsertRecordsOfOneDevice_presult__isset {
  _IClientRPCService_testInsertRecordsOfOneDevice_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testInsertRecordsOfOneDevice_presult__isset;

class IClientRPCService_testInsertRecordsOfOneDevice_presult {
 public:


  virtual ~IClientRPCService_testInsertRecordsOfOneDevice_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_testInsertRecordsOfOneDevice_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_testInsertStringRecords_args__isset {
  _IClientRPCService_testInsertStringRecords_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_testInsertStringRecords_args__isset;

class IClientRPCService_testInsertStringRecords_args {
 public:

  IClientRPCService_testInsertStringRecords_args(const IClientRPCService_testInsertStringRecords_args&);
  IClientRPCService_testInsertStringRecords_args& operator=(const IClientRPCService_testInsertStringRecords_args&);
  IClientRPCService_testInsertStringRecords_args() {
  }

  virtual ~IClientRPCService_testInsertStringRecords_args() noexcept;
  TSInsertStringRecordsReq req;

  _IClientRPCService_testInsertStringRecords_args__isset __isset;

  void __set_req(const TSInsertStringRecordsReq& val);

  bool operator == (const IClientRPCService_testInsertStringRecords_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_testInsertStringRecords_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testInsertStringRecords_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_testInsertStringRecords_pargs {
 public:


  virtual ~IClientRPCService_testInsertStringRecords_pargs() noexcept;
  const TSInsertStringRecordsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testInsertStringRecords_result__isset {
  _IClientRPCService_testInsertStringRecords_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testInsertStringRecords_result__isset;

class IClientRPCService_testInsertStringRecords_result {
 public:

  IClientRPCService_testInsertStringRecords_result(const IClientRPCService_testInsertStringRecords_result&);
  IClientRPCService_testInsertStringRecords_result& operator=(const IClientRPCService_testInsertStringRecords_result&);
  IClientRPCService_testInsertStringRecords_result() {
  }

  virtual ~IClientRPCService_testInsertStringRecords_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_testInsertStringRecords_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_testInsertStringRecords_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_testInsertStringRecords_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testInsertStringRecords_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testInsertStringRecords_presult__isset {
  _IClientRPCService_testInsertStringRecords_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testInsertStringRecords_presult__isset;

class IClientRPCService_testInsertStringRecords_presult {
 public:


  virtual ~IClientRPCService_testInsertStringRecords_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_testInsertStringRecords_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_deleteData_args__isset {
  _IClientRPCService_deleteData_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_deleteData_args__isset;

class IClientRPCService_deleteData_args {
 public:

  IClientRPCService_deleteData_args(const IClientRPCService_deleteData_args&);
  IClientRPCService_deleteData_args& operator=(const IClientRPCService_deleteData_args&);
  IClientRPCService_deleteData_args() {
  }

  virtual ~IClientRPCService_deleteData_args() noexcept;
  TSDeleteDataReq req;

  _IClientRPCService_deleteData_args__isset __isset;

  void __set_req(const TSDeleteDataReq& val);

  bool operator == (const IClientRPCService_deleteData_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_deleteData_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_deleteData_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_deleteData_pargs {
 public:


  virtual ~IClientRPCService_deleteData_pargs() noexcept;
  const TSDeleteDataReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_deleteData_result__isset {
  _IClientRPCService_deleteData_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_deleteData_result__isset;

class IClientRPCService_deleteData_result {
 public:

  IClientRPCService_deleteData_result(const IClientRPCService_deleteData_result&);
  IClientRPCService_deleteData_result& operator=(const IClientRPCService_deleteData_result&);
  IClientRPCService_deleteData_result() {
  }

  virtual ~IClientRPCService_deleteData_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_deleteData_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_deleteData_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_deleteData_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_deleteData_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_deleteData_presult__isset {
  _IClientRPCService_deleteData_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_deleteData_presult__isset;

class IClientRPCService_deleteData_presult {
 public:


  virtual ~IClientRPCService_deleteData_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_deleteData_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_executeRawDataQuery_args__isset {
  _IClientRPCService_executeRawDataQuery_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_executeRawDataQuery_args__isset;

class IClientRPCService_executeRawDataQuery_args {
 public:

  IClientRPCService_executeRawDataQuery_args(const IClientRPCService_executeRawDataQuery_args&);
  IClientRPCService_executeRawDataQuery_args& operator=(const IClientRPCService_executeRawDataQuery_args&);
  IClientRPCService_executeRawDataQuery_args() {
  }

  virtual ~IClientRPCService_executeRawDataQuery_args() noexcept;
  TSRawDataQueryReq req;

  _IClientRPCService_executeRawDataQuery_args__isset __isset;

  void __set_req(const TSRawDataQueryReq& val);

  bool operator == (const IClientRPCService_executeRawDataQuery_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeRawDataQuery_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeRawDataQuery_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_executeRawDataQuery_pargs {
 public:


  virtual ~IClientRPCService_executeRawDataQuery_pargs() noexcept;
  const TSRawDataQueryReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeRawDataQuery_result__isset {
  _IClientRPCService_executeRawDataQuery_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeRawDataQuery_result__isset;

class IClientRPCService_executeRawDataQuery_result {
 public:

  IClientRPCService_executeRawDataQuery_result(const IClientRPCService_executeRawDataQuery_result&);
  IClientRPCService_executeRawDataQuery_result& operator=(const IClientRPCService_executeRawDataQuery_result&);
  IClientRPCService_executeRawDataQuery_result() {
  }

  virtual ~IClientRPCService_executeRawDataQuery_result() noexcept;
  TSExecuteStatementResp success;

  _IClientRPCService_executeRawDataQuery_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

  bool operator == (const IClientRPCService_executeRawDataQuery_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeRawDataQuery_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeRawDataQuery_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeRawDataQuery_presult__isset {
  _IClientRPCService_executeRawDataQuery_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeRawDataQuery_presult__isset;

class IClientRPCService_executeRawDataQuery_presult {
 public:


  virtual ~IClientRPCService_executeRawDataQuery_presult() noexcept;
  TSExecuteStatementResp* success;

  _IClientRPCService_executeRawDataQuery_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_executeLastDataQuery_args__isset {
  _IClientRPCService_executeLastDataQuery_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_executeLastDataQuery_args__isset;

class IClientRPCService_executeLastDataQuery_args {
 public:

  IClientRPCService_executeLastDataQuery_args(const IClientRPCService_executeLastDataQuery_args&);
  IClientRPCService_executeLastDataQuery_args& operator=(const IClientRPCService_executeLastDataQuery_args&);
  IClientRPCService_executeLastDataQuery_args() {
  }

  virtual ~IClientRPCService_executeLastDataQuery_args() noexcept;
  TSLastDataQueryReq req;

  _IClientRPCService_executeLastDataQuery_args__isset __isset;

  void __set_req(const TSLastDataQueryReq& val);

  bool operator == (const IClientRPCService_executeLastDataQuery_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeLastDataQuery_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeLastDataQuery_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_executeLastDataQuery_pargs {
 public:


  virtual ~IClientRPCService_executeLastDataQuery_pargs() noexcept;
  const TSLastDataQueryReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeLastDataQuery_result__isset {
  _IClientRPCService_executeLastDataQuery_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeLastDataQuery_result__isset;

class IClientRPCService_executeLastDataQuery_result {
 public:

  IClientRPCService_executeLastDataQuery_result(const IClientRPCService_executeLastDataQuery_result&);
  IClientRPCService_executeLastDataQuery_result& operator=(const IClientRPCService_executeLastDataQuery_result&);
  IClientRPCService_executeLastDataQuery_result() {
  }

  virtual ~IClientRPCService_executeLastDataQuery_result() noexcept;
  TSExecuteStatementResp success;

  _IClientRPCService_executeLastDataQuery_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

  bool operator == (const IClientRPCService_executeLastDataQuery_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeLastDataQuery_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeLastDataQuery_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeLastDataQuery_presult__isset {
  _IClientRPCService_executeLastDataQuery_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeLastDataQuery_presult__isset;

class IClientRPCService_executeLastDataQuery_presult {
 public:


  virtual ~IClientRPCService_executeLastDataQuery_presult() noexcept;
  TSExecuteStatementResp* success;

  _IClientRPCService_executeLastDataQuery_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_executeAggregationQuery_args__isset {
  _IClientRPCService_executeAggregationQuery_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_executeAggregationQuery_args__isset;

class IClientRPCService_executeAggregationQuery_args {
 public:

  IClientRPCService_executeAggregationQuery_args(const IClientRPCService_executeAggregationQuery_args&);
  IClientRPCService_executeAggregationQuery_args& operator=(const IClientRPCService_executeAggregationQuery_args&);
  IClientRPCService_executeAggregationQuery_args() {
  }

  virtual ~IClientRPCService_executeAggregationQuery_args() noexcept;
  TSAggregationQueryReq req;

  _IClientRPCService_executeAggregationQuery_args__isset __isset;

  void __set_req(const TSAggregationQueryReq& val);

  bool operator == (const IClientRPCService_executeAggregationQuery_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeAggregationQuery_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeAggregationQuery_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_executeAggregationQuery_pargs {
 public:


  virtual ~IClientRPCService_executeAggregationQuery_pargs() noexcept;
  const TSAggregationQueryReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeAggregationQuery_result__isset {
  _IClientRPCService_executeAggregationQuery_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeAggregationQuery_result__isset;

class IClientRPCService_executeAggregationQuery_result {
 public:

  IClientRPCService_executeAggregationQuery_result(const IClientRPCService_executeAggregationQuery_result&);
  IClientRPCService_executeAggregationQuery_result& operator=(const IClientRPCService_executeAggregationQuery_result&);
  IClientRPCService_executeAggregationQuery_result() {
  }

  virtual ~IClientRPCService_executeAggregationQuery_result() noexcept;
  TSExecuteStatementResp success;

  _IClientRPCService_executeAggregationQuery_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

  bool operator == (const IClientRPCService_executeAggregationQuery_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_executeAggregationQuery_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_executeAggregationQuery_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_executeAggregationQuery_presult__isset {
  _IClientRPCService_executeAggregationQuery_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_executeAggregationQuery_presult__isset;

class IClientRPCService_executeAggregationQuery_presult {
 public:


  virtual ~IClientRPCService_executeAggregationQuery_presult() noexcept;
  TSExecuteStatementResp* success;

  _IClientRPCService_executeAggregationQuery_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_requestStatementId_args__isset {
  _IClientRPCService_requestStatementId_args__isset() : sessionId(false) {}
  bool sessionId :1;
} _IClientRPCService_requestStatementId_args__isset;

class IClientRPCService_requestStatementId_args {
 public:

  IClientRPCService_requestStatementId_args(const IClientRPCService_requestStatementId_args&);
  IClientRPCService_requestStatementId_args& operator=(const IClientRPCService_requestStatementId_args&);
  IClientRPCService_requestStatementId_args() : sessionId(0) {
  }

  virtual ~IClientRPCService_requestStatementId_args() noexcept;
  int64_t sessionId;

  _IClientRPCService_requestStatementId_args__isset __isset;

  void __set_sessionId(const int64_t val);

  bool operator == (const IClientRPCService_requestStatementId_args & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_requestStatementId_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_requestStatementId_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_requestStatementId_pargs {
 public:


  virtual ~IClientRPCService_requestStatementId_pargs() noexcept;
  const int64_t* sessionId;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_requestStatementId_result__isset {
  _IClientRPCService_requestStatementId_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_requestStatementId_result__isset;

class IClientRPCService_requestStatementId_result {
 public:

  IClientRPCService_requestStatementId_result(const IClientRPCService_requestStatementId_result&);
  IClientRPCService_requestStatementId_result& operator=(const IClientRPCService_requestStatementId_result&);
  IClientRPCService_requestStatementId_result() : success(0) {
  }

  virtual ~IClientRPCService_requestStatementId_result() noexcept;
  int64_t success;

  _IClientRPCService_requestStatementId_result__isset __isset;

  void __set_success(const int64_t val);

  bool operator == (const IClientRPCService_requestStatementId_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_requestStatementId_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_requestStatementId_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_requestStatementId_presult__isset {
  _IClientRPCService_requestStatementId_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_requestStatementId_presult__isset;

class IClientRPCService_requestStatementId_presult {
 public:


  virtual ~IClientRPCService_requestStatementId_presult() noexcept;
  int64_t* success;

  _IClientRPCService_requestStatementId_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_createSchemaTemplate_args__isset {
  _IClientRPCService_createSchemaTemplate_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_createSchemaTemplate_args__isset;

class IClientRPCService_createSchemaTemplate_args {
 public:

  IClientRPCService_createSchemaTemplate_args(const IClientRPCService_createSchemaTemplate_args&);
  IClientRPCService_createSchemaTemplate_args& operator=(const IClientRPCService_createSchemaTemplate_args&);
  IClientRPCService_createSchemaTemplate_args() {
  }

  virtual ~IClientRPCService_createSchemaTemplate_args() noexcept;
  TSCreateSchemaTemplateReq req;

  _IClientRPCService_createSchemaTemplate_args__isset __isset;

  void __set_req(const TSCreateSchemaTemplateReq& val);

  bool operator == (const IClientRPCService_createSchemaTemplate_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_createSchemaTemplate_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_createSchemaTemplate_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_createSchemaTemplate_pargs {
 public:


  virtual ~IClientRPCService_createSchemaTemplate_pargs() noexcept;
  const TSCreateSchemaTemplateReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_createSchemaTemplate_result__isset {
  _IClientRPCService_createSchemaTemplate_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_createSchemaTemplate_result__isset;

class IClientRPCService_createSchemaTemplate_result {
 public:

  IClientRPCService_createSchemaTemplate_result(const IClientRPCService_createSchemaTemplate_result&);
  IClientRPCService_createSchemaTemplate_result& operator=(const IClientRPCService_createSchemaTemplate_result&);
  IClientRPCService_createSchemaTemplate_result() {
  }

  virtual ~IClientRPCService_createSchemaTemplate_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_createSchemaTemplate_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_createSchemaTemplate_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_createSchemaTemplate_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_createSchemaTemplate_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_createSchemaTemplate_presult__isset {
  _IClientRPCService_createSchemaTemplate_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_createSchemaTemplate_presult__isset;

class IClientRPCService_createSchemaTemplate_presult {
 public:


  virtual ~IClientRPCService_createSchemaTemplate_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_createSchemaTemplate_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_appendSchemaTemplate_args__isset {
  _IClientRPCService_appendSchemaTemplate_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_appendSchemaTemplate_args__isset;

class IClientRPCService_appendSchemaTemplate_args {
 public:

  IClientRPCService_appendSchemaTemplate_args(const IClientRPCService_appendSchemaTemplate_args&);
  IClientRPCService_appendSchemaTemplate_args& operator=(const IClientRPCService_appendSchemaTemplate_args&);
  IClientRPCService_appendSchemaTemplate_args() {
  }

  virtual ~IClientRPCService_appendSchemaTemplate_args() noexcept;
  TSAppendSchemaTemplateReq req;

  _IClientRPCService_appendSchemaTemplate_args__isset __isset;

  void __set_req(const TSAppendSchemaTemplateReq& val);

  bool operator == (const IClientRPCService_appendSchemaTemplate_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_appendSchemaTemplate_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_appendSchemaTemplate_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_appendSchemaTemplate_pargs {
 public:


  virtual ~IClientRPCService_appendSchemaTemplate_pargs() noexcept;
  const TSAppendSchemaTemplateReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_appendSchemaTemplate_result__isset {
  _IClientRPCService_appendSchemaTemplate_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_appendSchemaTemplate_result__isset;

class IClientRPCService_appendSchemaTemplate_result {
 public:

  IClientRPCService_appendSchemaTemplate_result(const IClientRPCService_appendSchemaTemplate_result&);
  IClientRPCService_appendSchemaTemplate_result& operator=(const IClientRPCService_appendSchemaTemplate_result&);
  IClientRPCService_appendSchemaTemplate_result() {
  }

  virtual ~IClientRPCService_appendSchemaTemplate_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_appendSchemaTemplate_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_appendSchemaTemplate_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_appendSchemaTemplate_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_appendSchemaTemplate_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_appendSchemaTemplate_presult__isset {
  _IClientRPCService_appendSchemaTemplate_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_appendSchemaTemplate_presult__isset;

class IClientRPCService_appendSchemaTemplate_presult {
 public:


  virtual ~IClientRPCService_appendSchemaTemplate_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_appendSchemaTemplate_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_pruneSchemaTemplate_args__isset {
  _IClientRPCService_pruneSchemaTemplate_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_pruneSchemaTemplate_args__isset;

class IClientRPCService_pruneSchemaTemplate_args {
 public:

  IClientRPCService_pruneSchemaTemplate_args(const IClientRPCService_pruneSchemaTemplate_args&);
  IClientRPCService_pruneSchemaTemplate_args& operator=(const IClientRPCService_pruneSchemaTemplate_args&);
  IClientRPCService_pruneSchemaTemplate_args() {
  }

  virtual ~IClientRPCService_pruneSchemaTemplate_args() noexcept;
  TSPruneSchemaTemplateReq req;

  _IClientRPCService_pruneSchemaTemplate_args__isset __isset;

  void __set_req(const TSPruneSchemaTemplateReq& val);

  bool operator == (const IClientRPCService_pruneSchemaTemplate_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_pruneSchemaTemplate_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_pruneSchemaTemplate_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_pruneSchemaTemplate_pargs {
 public:


  virtual ~IClientRPCService_pruneSchemaTemplate_pargs() noexcept;
  const TSPruneSchemaTemplateReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_pruneSchemaTemplate_result__isset {
  _IClientRPCService_pruneSchemaTemplate_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_pruneSchemaTemplate_result__isset;

class IClientRPCService_pruneSchemaTemplate_result {
 public:

  IClientRPCService_pruneSchemaTemplate_result(const IClientRPCService_pruneSchemaTemplate_result&);
  IClientRPCService_pruneSchemaTemplate_result& operator=(const IClientRPCService_pruneSchemaTemplate_result&);
  IClientRPCService_pruneSchemaTemplate_result() {
  }

  virtual ~IClientRPCService_pruneSchemaTemplate_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_pruneSchemaTemplate_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_pruneSchemaTemplate_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_pruneSchemaTemplate_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_pruneSchemaTemplate_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_pruneSchemaTemplate_presult__isset {
  _IClientRPCService_pruneSchemaTemplate_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_pruneSchemaTemplate_presult__isset;

class IClientRPCService_pruneSchemaTemplate_presult {
 public:


  virtual ~IClientRPCService_pruneSchemaTemplate_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_pruneSchemaTemplate_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_querySchemaTemplate_args__isset {
  _IClientRPCService_querySchemaTemplate_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_querySchemaTemplate_args__isset;

class IClientRPCService_querySchemaTemplate_args {
 public:

  IClientRPCService_querySchemaTemplate_args(const IClientRPCService_querySchemaTemplate_args&);
  IClientRPCService_querySchemaTemplate_args& operator=(const IClientRPCService_querySchemaTemplate_args&);
  IClientRPCService_querySchemaTemplate_args() {
  }

  virtual ~IClientRPCService_querySchemaTemplate_args() noexcept;
  TSQueryTemplateReq req;

  _IClientRPCService_querySchemaTemplate_args__isset __isset;

  void __set_req(const TSQueryTemplateReq& val);

  bool operator == (const IClientRPCService_querySchemaTemplate_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_querySchemaTemplate_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_querySchemaTemplate_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_querySchemaTemplate_pargs {
 public:


  virtual ~IClientRPCService_querySchemaTemplate_pargs() noexcept;
  const TSQueryTemplateReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_querySchemaTemplate_result__isset {
  _IClientRPCService_querySchemaTemplate_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_querySchemaTemplate_result__isset;

class IClientRPCService_querySchemaTemplate_result {
 public:

  IClientRPCService_querySchemaTemplate_result(const IClientRPCService_querySchemaTemplate_result&);
  IClientRPCService_querySchemaTemplate_result& operator=(const IClientRPCService_querySchemaTemplate_result&);
  IClientRPCService_querySchemaTemplate_result() {
  }

  virtual ~IClientRPCService_querySchemaTemplate_result() noexcept;
  TSQueryTemplateResp success;

  _IClientRPCService_querySchemaTemplate_result__isset __isset;

  void __set_success(const TSQueryTemplateResp& val);

  bool operator == (const IClientRPCService_querySchemaTemplate_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_querySchemaTemplate_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_querySchemaTemplate_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_querySchemaTemplate_presult__isset {
  _IClientRPCService_querySchemaTemplate_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_querySchemaTemplate_presult__isset;

class IClientRPCService_querySchemaTemplate_presult {
 public:


  virtual ~IClientRPCService_querySchemaTemplate_presult() noexcept;
  TSQueryTemplateResp* success;

  _IClientRPCService_querySchemaTemplate_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class IClientRPCService_showConfigurationTemplate_args {
 public:

  IClientRPCService_showConfigurationTemplate_args(const IClientRPCService_showConfigurationTemplate_args&);
  IClientRPCService_showConfigurationTemplate_args& operator=(const IClientRPCService_showConfigurationTemplate_args&);
  IClientRPCService_showConfigurationTemplate_args() {
  }

  virtual ~IClientRPCService_showConfigurationTemplate_args() noexcept;

  bool operator == (const IClientRPCService_showConfigurationTemplate_args & /* rhs */) const
  {
    return true;
  }
  bool operator != (const IClientRPCService_showConfigurationTemplate_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_showConfigurationTemplate_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_showConfigurationTemplate_pargs {
 public:


  virtual ~IClientRPCService_showConfigurationTemplate_pargs() noexcept;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_showConfigurationTemplate_result__isset {
  _IClientRPCService_showConfigurationTemplate_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_showConfigurationTemplate_result__isset;

class IClientRPCService_showConfigurationTemplate_result {
 public:

  IClientRPCService_showConfigurationTemplate_result(const IClientRPCService_showConfigurationTemplate_result&);
  IClientRPCService_showConfigurationTemplate_result& operator=(const IClientRPCService_showConfigurationTemplate_result&);
  IClientRPCService_showConfigurationTemplate_result() {
  }

  virtual ~IClientRPCService_showConfigurationTemplate_result() noexcept;
   ::TShowConfigurationTemplateResp success;

  _IClientRPCService_showConfigurationTemplate_result__isset __isset;

  void __set_success(const  ::TShowConfigurationTemplateResp& val);

  bool operator == (const IClientRPCService_showConfigurationTemplate_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_showConfigurationTemplate_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_showConfigurationTemplate_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_showConfigurationTemplate_presult__isset {
  _IClientRPCService_showConfigurationTemplate_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_showConfigurationTemplate_presult__isset;

class IClientRPCService_showConfigurationTemplate_presult {
 public:


  virtual ~IClientRPCService_showConfigurationTemplate_presult() noexcept;
   ::TShowConfigurationTemplateResp* success;

  _IClientRPCService_showConfigurationTemplate_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_showConfiguration_args__isset {
  _IClientRPCService_showConfiguration_args__isset() : nodeId(false) {}
  bool nodeId :1;
} _IClientRPCService_showConfiguration_args__isset;

class IClientRPCService_showConfiguration_args {
 public:

  IClientRPCService_showConfiguration_args(const IClientRPCService_showConfiguration_args&);
  IClientRPCService_showConfiguration_args& operator=(const IClientRPCService_showConfiguration_args&);
  IClientRPCService_showConfiguration_args() : nodeId(0) {
  }

  virtual ~IClientRPCService_showConfiguration_args() noexcept;
  int32_t nodeId;

  _IClientRPCService_showConfiguration_args__isset __isset;

  void __set_nodeId(const int32_t val);

  bool operator == (const IClientRPCService_showConfiguration_args & rhs) const
  {
    if (!(nodeId == rhs.nodeId))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_showConfiguration_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_showConfiguration_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_showConfiguration_pargs {
 public:


  virtual ~IClientRPCService_showConfiguration_pargs() noexcept;
  const int32_t* nodeId;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_showConfiguration_result__isset {
  _IClientRPCService_showConfiguration_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_showConfiguration_result__isset;

class IClientRPCService_showConfiguration_result {
 public:

  IClientRPCService_showConfiguration_result(const IClientRPCService_showConfiguration_result&);
  IClientRPCService_showConfiguration_result& operator=(const IClientRPCService_showConfiguration_result&);
  IClientRPCService_showConfiguration_result() {
  }

  virtual ~IClientRPCService_showConfiguration_result() noexcept;
   ::TShowConfigurationResp success;

  _IClientRPCService_showConfiguration_result__isset __isset;

  void __set_success(const  ::TShowConfigurationResp& val);

  bool operator == (const IClientRPCService_showConfiguration_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_showConfiguration_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_showConfiguration_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_showConfiguration_presult__isset {
  _IClientRPCService_showConfiguration_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_showConfiguration_presult__isset;

class IClientRPCService_showConfiguration_presult {
 public:


  virtual ~IClientRPCService_showConfiguration_presult() noexcept;
   ::TShowConfigurationResp* success;

  _IClientRPCService_showConfiguration_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_setSchemaTemplate_args__isset {
  _IClientRPCService_setSchemaTemplate_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_setSchemaTemplate_args__isset;

class IClientRPCService_setSchemaTemplate_args {
 public:

  IClientRPCService_setSchemaTemplate_args(const IClientRPCService_setSchemaTemplate_args&);
  IClientRPCService_setSchemaTemplate_args& operator=(const IClientRPCService_setSchemaTemplate_args&);
  IClientRPCService_setSchemaTemplate_args() {
  }

  virtual ~IClientRPCService_setSchemaTemplate_args() noexcept;
  TSSetSchemaTemplateReq req;

  _IClientRPCService_setSchemaTemplate_args__isset __isset;

  void __set_req(const TSSetSchemaTemplateReq& val);

  bool operator == (const IClientRPCService_setSchemaTemplate_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_setSchemaTemplate_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_setSchemaTemplate_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_setSchemaTemplate_pargs {
 public:


  virtual ~IClientRPCService_setSchemaTemplate_pargs() noexcept;
  const TSSetSchemaTemplateReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_setSchemaTemplate_result__isset {
  _IClientRPCService_setSchemaTemplate_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_setSchemaTemplate_result__isset;

class IClientRPCService_setSchemaTemplate_result {
 public:

  IClientRPCService_setSchemaTemplate_result(const IClientRPCService_setSchemaTemplate_result&);
  IClientRPCService_setSchemaTemplate_result& operator=(const IClientRPCService_setSchemaTemplate_result&);
  IClientRPCService_setSchemaTemplate_result() {
  }

  virtual ~IClientRPCService_setSchemaTemplate_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_setSchemaTemplate_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_setSchemaTemplate_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_setSchemaTemplate_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_setSchemaTemplate_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_setSchemaTemplate_presult__isset {
  _IClientRPCService_setSchemaTemplate_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_setSchemaTemplate_presult__isset;

class IClientRPCService_setSchemaTemplate_presult {
 public:


  virtual ~IClientRPCService_setSchemaTemplate_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_setSchemaTemplate_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_unsetSchemaTemplate_args__isset {
  _IClientRPCService_unsetSchemaTemplate_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_unsetSchemaTemplate_args__isset;

class IClientRPCService_unsetSchemaTemplate_args {
 public:

  IClientRPCService_unsetSchemaTemplate_args(const IClientRPCService_unsetSchemaTemplate_args&);
  IClientRPCService_unsetSchemaTemplate_args& operator=(const IClientRPCService_unsetSchemaTemplate_args&);
  IClientRPCService_unsetSchemaTemplate_args() {
  }

  virtual ~IClientRPCService_unsetSchemaTemplate_args() noexcept;
  TSUnsetSchemaTemplateReq req;

  _IClientRPCService_unsetSchemaTemplate_args__isset __isset;

  void __set_req(const TSUnsetSchemaTemplateReq& val);

  bool operator == (const IClientRPCService_unsetSchemaTemplate_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_unsetSchemaTemplate_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_unsetSchemaTemplate_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_unsetSchemaTemplate_pargs {
 public:


  virtual ~IClientRPCService_unsetSchemaTemplate_pargs() noexcept;
  const TSUnsetSchemaTemplateReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_unsetSchemaTemplate_result__isset {
  _IClientRPCService_unsetSchemaTemplate_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_unsetSchemaTemplate_result__isset;

class IClientRPCService_unsetSchemaTemplate_result {
 public:

  IClientRPCService_unsetSchemaTemplate_result(const IClientRPCService_unsetSchemaTemplate_result&);
  IClientRPCService_unsetSchemaTemplate_result& operator=(const IClientRPCService_unsetSchemaTemplate_result&);
  IClientRPCService_unsetSchemaTemplate_result() {
  }

  virtual ~IClientRPCService_unsetSchemaTemplate_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_unsetSchemaTemplate_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_unsetSchemaTemplate_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_unsetSchemaTemplate_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_unsetSchemaTemplate_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_unsetSchemaTemplate_presult__isset {
  _IClientRPCService_unsetSchemaTemplate_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_unsetSchemaTemplate_presult__isset;

class IClientRPCService_unsetSchemaTemplate_presult {
 public:


  virtual ~IClientRPCService_unsetSchemaTemplate_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_unsetSchemaTemplate_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_dropSchemaTemplate_args__isset {
  _IClientRPCService_dropSchemaTemplate_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_dropSchemaTemplate_args__isset;

class IClientRPCService_dropSchemaTemplate_args {
 public:

  IClientRPCService_dropSchemaTemplate_args(const IClientRPCService_dropSchemaTemplate_args&);
  IClientRPCService_dropSchemaTemplate_args& operator=(const IClientRPCService_dropSchemaTemplate_args&);
  IClientRPCService_dropSchemaTemplate_args() {
  }

  virtual ~IClientRPCService_dropSchemaTemplate_args() noexcept;
  TSDropSchemaTemplateReq req;

  _IClientRPCService_dropSchemaTemplate_args__isset __isset;

  void __set_req(const TSDropSchemaTemplateReq& val);

  bool operator == (const IClientRPCService_dropSchemaTemplate_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_dropSchemaTemplate_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_dropSchemaTemplate_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_dropSchemaTemplate_pargs {
 public:


  virtual ~IClientRPCService_dropSchemaTemplate_pargs() noexcept;
  const TSDropSchemaTemplateReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_dropSchemaTemplate_result__isset {
  _IClientRPCService_dropSchemaTemplate_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_dropSchemaTemplate_result__isset;

class IClientRPCService_dropSchemaTemplate_result {
 public:

  IClientRPCService_dropSchemaTemplate_result(const IClientRPCService_dropSchemaTemplate_result&);
  IClientRPCService_dropSchemaTemplate_result& operator=(const IClientRPCService_dropSchemaTemplate_result&);
  IClientRPCService_dropSchemaTemplate_result() {
  }

  virtual ~IClientRPCService_dropSchemaTemplate_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_dropSchemaTemplate_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_dropSchemaTemplate_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_dropSchemaTemplate_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_dropSchemaTemplate_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_dropSchemaTemplate_presult__isset {
  _IClientRPCService_dropSchemaTemplate_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_dropSchemaTemplate_presult__isset;

class IClientRPCService_dropSchemaTemplate_presult {
 public:


  virtual ~IClientRPCService_dropSchemaTemplate_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_dropSchemaTemplate_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_createTimeseriesUsingSchemaTemplate_args__isset {
  _IClientRPCService_createTimeseriesUsingSchemaTemplate_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_createTimeseriesUsingSchemaTemplate_args__isset;

class IClientRPCService_createTimeseriesUsingSchemaTemplate_args {
 public:

  IClientRPCService_createTimeseriesUsingSchemaTemplate_args(const IClientRPCService_createTimeseriesUsingSchemaTemplate_args&);
  IClientRPCService_createTimeseriesUsingSchemaTemplate_args& operator=(const IClientRPCService_createTimeseriesUsingSchemaTemplate_args&);
  IClientRPCService_createTimeseriesUsingSchemaTemplate_args() {
  }

  virtual ~IClientRPCService_createTimeseriesUsingSchemaTemplate_args() noexcept;
  TCreateTimeseriesUsingSchemaTemplateReq req;

  _IClientRPCService_createTimeseriesUsingSchemaTemplate_args__isset __isset;

  void __set_req(const TCreateTimeseriesUsingSchemaTemplateReq& val);

  bool operator == (const IClientRPCService_createTimeseriesUsingSchemaTemplate_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_createTimeseriesUsingSchemaTemplate_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_createTimeseriesUsingSchemaTemplate_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_createTimeseriesUsingSchemaTemplate_pargs {
 public:


  virtual ~IClientRPCService_createTimeseriesUsingSchemaTemplate_pargs() noexcept;
  const TCreateTimeseriesUsingSchemaTemplateReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_createTimeseriesUsingSchemaTemplate_result__isset {
  _IClientRPCService_createTimeseriesUsingSchemaTemplate_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_createTimeseriesUsingSchemaTemplate_result__isset;

class IClientRPCService_createTimeseriesUsingSchemaTemplate_result {
 public:

  IClientRPCService_createTimeseriesUsingSchemaTemplate_result(const IClientRPCService_createTimeseriesUsingSchemaTemplate_result&);
  IClientRPCService_createTimeseriesUsingSchemaTemplate_result& operator=(const IClientRPCService_createTimeseriesUsingSchemaTemplate_result&);
  IClientRPCService_createTimeseriesUsingSchemaTemplate_result() {
  }

  virtual ~IClientRPCService_createTimeseriesUsingSchemaTemplate_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_createTimeseriesUsingSchemaTemplate_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_createTimeseriesUsingSchemaTemplate_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_createTimeseriesUsingSchemaTemplate_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_createTimeseriesUsingSchemaTemplate_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_createTimeseriesUsingSchemaTemplate_presult__isset {
  _IClientRPCService_createTimeseriesUsingSchemaTemplate_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_createTimeseriesUsingSchemaTemplate_presult__isset;

class IClientRPCService_createTimeseriesUsingSchemaTemplate_presult {
 public:


  virtual ~IClientRPCService_createTimeseriesUsingSchemaTemplate_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_createTimeseriesUsingSchemaTemplate_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_handshake_args__isset {
  _IClientRPCService_handshake_args__isset() : info(false) {}
  bool info :1;
} _IClientRPCService_handshake_args__isset;

class IClientRPCService_handshake_args {
 public:

  IClientRPCService_handshake_args(const IClientRPCService_handshake_args&);
  IClientRPCService_handshake_args& operator=(const IClientRPCService_handshake_args&);
  IClientRPCService_handshake_args() {
  }

  virtual ~IClientRPCService_handshake_args() noexcept;
  TSyncIdentityInfo info;

  _IClientRPCService_handshake_args__isset __isset;

  void __set_info(const TSyncIdentityInfo& val);

  bool operator == (const IClientRPCService_handshake_args & rhs) const
  {
    if (!(info == rhs.info))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_handshake_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_handshake_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_handshake_pargs {
 public:


  virtual ~IClientRPCService_handshake_pargs() noexcept;
  const TSyncIdentityInfo* info;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_handshake_result__isset {
  _IClientRPCService_handshake_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_handshake_result__isset;

class IClientRPCService_handshake_result {
 public:

  IClientRPCService_handshake_result(const IClientRPCService_handshake_result&);
  IClientRPCService_handshake_result& operator=(const IClientRPCService_handshake_result&);
  IClientRPCService_handshake_result() {
  }

  virtual ~IClientRPCService_handshake_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_handshake_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_handshake_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_handshake_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_handshake_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_handshake_presult__isset {
  _IClientRPCService_handshake_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_handshake_presult__isset;

class IClientRPCService_handshake_presult {
 public:


  virtual ~IClientRPCService_handshake_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_handshake_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_sendPipeData_args__isset {
  _IClientRPCService_sendPipeData_args__isset() : buff(false) {}
  bool buff :1;
} _IClientRPCService_sendPipeData_args__isset;

class IClientRPCService_sendPipeData_args {
 public:

  IClientRPCService_sendPipeData_args(const IClientRPCService_sendPipeData_args&);
  IClientRPCService_sendPipeData_args& operator=(const IClientRPCService_sendPipeData_args&);
  IClientRPCService_sendPipeData_args() : buff() {
  }

  virtual ~IClientRPCService_sendPipeData_args() noexcept;
  std::string buff;

  _IClientRPCService_sendPipeData_args__isset __isset;

  void __set_buff(const std::string& val);

  bool operator == (const IClientRPCService_sendPipeData_args & rhs) const
  {
    if (!(buff == rhs.buff))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_sendPipeData_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_sendPipeData_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_sendPipeData_pargs {
 public:


  virtual ~IClientRPCService_sendPipeData_pargs() noexcept;
  const std::string* buff;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_sendPipeData_result__isset {
  _IClientRPCService_sendPipeData_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_sendPipeData_result__isset;

class IClientRPCService_sendPipeData_result {
 public:

  IClientRPCService_sendPipeData_result(const IClientRPCService_sendPipeData_result&);
  IClientRPCService_sendPipeData_result& operator=(const IClientRPCService_sendPipeData_result&);
  IClientRPCService_sendPipeData_result() {
  }

  virtual ~IClientRPCService_sendPipeData_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_sendPipeData_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_sendPipeData_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_sendPipeData_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_sendPipeData_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_sendPipeData_presult__isset {
  _IClientRPCService_sendPipeData_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_sendPipeData_presult__isset;

class IClientRPCService_sendPipeData_presult {
 public:


  virtual ~IClientRPCService_sendPipeData_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_sendPipeData_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_sendFile_args__isset {
  _IClientRPCService_sendFile_args__isset() : metaInfo(false), buff(false) {}
  bool metaInfo :1;
  bool buff :1;
} _IClientRPCService_sendFile_args__isset;

class IClientRPCService_sendFile_args {
 public:

  IClientRPCService_sendFile_args(const IClientRPCService_sendFile_args&);
  IClientRPCService_sendFile_args& operator=(const IClientRPCService_sendFile_args&);
  IClientRPCService_sendFile_args() : buff() {
  }

  virtual ~IClientRPCService_sendFile_args() noexcept;
  TSyncTransportMetaInfo metaInfo;
  std::string buff;

  _IClientRPCService_sendFile_args__isset __isset;

  void __set_metaInfo(const TSyncTransportMetaInfo& val);

  void __set_buff(const std::string& val);

  bool operator == (const IClientRPCService_sendFile_args & rhs) const
  {
    if (!(metaInfo == rhs.metaInfo))
      return false;
    if (!(buff == rhs.buff))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_sendFile_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_sendFile_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_sendFile_pargs {
 public:


  virtual ~IClientRPCService_sendFile_pargs() noexcept;
  const TSyncTransportMetaInfo* metaInfo;
  const std::string* buff;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_sendFile_result__isset {
  _IClientRPCService_sendFile_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_sendFile_result__isset;

class IClientRPCService_sendFile_result {
 public:

  IClientRPCService_sendFile_result(const IClientRPCService_sendFile_result&);
  IClientRPCService_sendFile_result& operator=(const IClientRPCService_sendFile_result&);
  IClientRPCService_sendFile_result() {
  }

  virtual ~IClientRPCService_sendFile_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_sendFile_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_sendFile_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_sendFile_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_sendFile_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_sendFile_presult__isset {
  _IClientRPCService_sendFile_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_sendFile_presult__isset;

class IClientRPCService_sendFile_presult {
 public:


  virtual ~IClientRPCService_sendFile_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_sendFile_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_pipeTransfer_args__isset {
  _IClientRPCService_pipeTransfer_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_pipeTransfer_args__isset;

class IClientRPCService_pipeTransfer_args {
 public:

  IClientRPCService_pipeTransfer_args(const IClientRPCService_pipeTransfer_args&);
  IClientRPCService_pipeTransfer_args& operator=(const IClientRPCService_pipeTransfer_args&);
  IClientRPCService_pipeTransfer_args() {
  }

  virtual ~IClientRPCService_pipeTransfer_args() noexcept;
  TPipeTransferReq req;

  _IClientRPCService_pipeTransfer_args__isset __isset;

  void __set_req(const TPipeTransferReq& val);

  bool operator == (const IClientRPCService_pipeTransfer_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_pipeTransfer_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_pipeTransfer_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_pipeTransfer_pargs {
 public:


  virtual ~IClientRPCService_pipeTransfer_pargs() noexcept;
  const TPipeTransferReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_pipeTransfer_result__isset {
  _IClientRPCService_pipeTransfer_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_pipeTransfer_result__isset;

class IClientRPCService_pipeTransfer_result {
 public:

  IClientRPCService_pipeTransfer_result(const IClientRPCService_pipeTransfer_result&);
  IClientRPCService_pipeTransfer_result& operator=(const IClientRPCService_pipeTransfer_result&);
  IClientRPCService_pipeTransfer_result() {
  }

  virtual ~IClientRPCService_pipeTransfer_result() noexcept;
  TPipeTransferResp success;

  _IClientRPCService_pipeTransfer_result__isset __isset;

  void __set_success(const TPipeTransferResp& val);

  bool operator == (const IClientRPCService_pipeTransfer_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_pipeTransfer_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_pipeTransfer_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_pipeTransfer_presult__isset {
  _IClientRPCService_pipeTransfer_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_pipeTransfer_presult__isset;

class IClientRPCService_pipeTransfer_presult {
 public:


  virtual ~IClientRPCService_pipeTransfer_presult() noexcept;
  TPipeTransferResp* success;

  _IClientRPCService_pipeTransfer_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _IClientRPCService_pipeSubscribe_args__isset {
  _IClientRPCService_pipeSubscribe_args__isset() : req(false) {}
  bool req :1;
} _IClientRPCService_pipeSubscribe_args__isset;

class IClientRPCService_pipeSubscribe_args {
 public:

  IClientRPCService_pipeSubscribe_args(const IClientRPCService_pipeSubscribe_args&);
  IClientRPCService_pipeSubscribe_args& operator=(const IClientRPCService_pipeSubscribe_args&);
  IClientRPCService_pipeSubscribe_args() {
  }

  virtual ~IClientRPCService_pipeSubscribe_args() noexcept;
  TPipeSubscribeReq req;

  _IClientRPCService_pipeSubscribe_args__isset __isset;

  void __set_req(const TPipeSubscribeReq& val);

  bool operator == (const IClientRPCService_pipeSubscribe_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_pipeSubscribe_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_pipeSubscribe_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_pipeSubscribe_pargs {
 public:


  virtual ~IClientRPCService_pipeSubscribe_pargs() noexcept;
  const TPipeSubscribeReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_pipeSubscribe_result__isset {
  _IClientRPCService_pipeSubscribe_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_pipeSubscribe_result__isset;

class IClientRPCService_pipeSubscribe_result {
 public:

  IClientRPCService_pipeSubscribe_result(const IClientRPCService_pipeSubscribe_result&);
  IClientRPCService_pipeSubscribe_result& operator=(const IClientRPCService_pipeSubscribe_result&);
  IClientRPCService_pipeSubscribe_result() {
  }

  virtual ~IClientRPCService_pipeSubscribe_result() noexcept;
  TPipeSubscribeResp success;

  _IClientRPCService_pipeSubscribe_result__isset __isset;

  void __set_success(const TPipeSubscribeResp& val);

  bool operator == (const IClientRPCService_pipeSubscribe_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_pipeSubscribe_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_pipeSubscribe_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_pipeSubscribe_presult__isset {
  _IClientRPCService_pipeSubscribe_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_pipeSubscribe_presult__isset;

class IClientRPCService_pipeSubscribe_presult {
 public:


  virtual ~IClientRPCService_pipeSubscribe_presult() noexcept;
  TPipeSubscribeResp* success;

  _IClientRPCService_pipeSubscribe_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class IClientRPCService_getBackupConfiguration_args {
 public:

  IClientRPCService_getBackupConfiguration_args(const IClientRPCService_getBackupConfiguration_args&);
  IClientRPCService_getBackupConfiguration_args& operator=(const IClientRPCService_getBackupConfiguration_args&);
  IClientRPCService_getBackupConfiguration_args() {
  }

  virtual ~IClientRPCService_getBackupConfiguration_args() noexcept;

  bool operator == (const IClientRPCService_getBackupConfiguration_args & /* rhs */) const
  {
    return true;
  }
  bool operator != (const IClientRPCService_getBackupConfiguration_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_getBackupConfiguration_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_getBackupConfiguration_pargs {
 public:


  virtual ~IClientRPCService_getBackupConfiguration_pargs() noexcept;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_getBackupConfiguration_result__isset {
  _IClientRPCService_getBackupConfiguration_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_getBackupConfiguration_result__isset;

class IClientRPCService_getBackupConfiguration_result {
 public:

  IClientRPCService_getBackupConfiguration_result(const IClientRPCService_getBackupConfiguration_result&);
  IClientRPCService_getBackupConfiguration_result& operator=(const IClientRPCService_getBackupConfiguration_result&);
  IClientRPCService_getBackupConfiguration_result() {
  }

  virtual ~IClientRPCService_getBackupConfiguration_result() noexcept;
  TSBackupConfigurationResp success;

  _IClientRPCService_getBackupConfiguration_result__isset __isset;

  void __set_success(const TSBackupConfigurationResp& val);

  bool operator == (const IClientRPCService_getBackupConfiguration_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_getBackupConfiguration_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_getBackupConfiguration_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_getBackupConfiguration_presult__isset {
  _IClientRPCService_getBackupConfiguration_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_getBackupConfiguration_presult__isset;

class IClientRPCService_getBackupConfiguration_presult {
 public:


  virtual ~IClientRPCService_getBackupConfiguration_presult() noexcept;
  TSBackupConfigurationResp* success;

  _IClientRPCService_getBackupConfiguration_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class IClientRPCService_fetchAllConnectionsInfo_args {
 public:

  IClientRPCService_fetchAllConnectionsInfo_args(const IClientRPCService_fetchAllConnectionsInfo_args&);
  IClientRPCService_fetchAllConnectionsInfo_args& operator=(const IClientRPCService_fetchAllConnectionsInfo_args&);
  IClientRPCService_fetchAllConnectionsInfo_args() {
  }

  virtual ~IClientRPCService_fetchAllConnectionsInfo_args() noexcept;

  bool operator == (const IClientRPCService_fetchAllConnectionsInfo_args & /* rhs */) const
  {
    return true;
  }
  bool operator != (const IClientRPCService_fetchAllConnectionsInfo_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_fetchAllConnectionsInfo_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_fetchAllConnectionsInfo_pargs {
 public:


  virtual ~IClientRPCService_fetchAllConnectionsInfo_pargs() noexcept;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_fetchAllConnectionsInfo_result__isset {
  _IClientRPCService_fetchAllConnectionsInfo_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_fetchAllConnectionsInfo_result__isset;

class IClientRPCService_fetchAllConnectionsInfo_result {
 public:

  IClientRPCService_fetchAllConnectionsInfo_result(const IClientRPCService_fetchAllConnectionsInfo_result&);
  IClientRPCService_fetchAllConnectionsInfo_result& operator=(const IClientRPCService_fetchAllConnectionsInfo_result&);
  IClientRPCService_fetchAllConnectionsInfo_result() {
  }

  virtual ~IClientRPCService_fetchAllConnectionsInfo_result() noexcept;
  TSConnectionInfoResp success;

  _IClientRPCService_fetchAllConnectionsInfo_result__isset __isset;

  void __set_success(const TSConnectionInfoResp& val);

  bool operator == (const IClientRPCService_fetchAllConnectionsInfo_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_fetchAllConnectionsInfo_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_fetchAllConnectionsInfo_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_fetchAllConnectionsInfo_presult__isset {
  _IClientRPCService_fetchAllConnectionsInfo_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_fetchAllConnectionsInfo_presult__isset;

class IClientRPCService_fetchAllConnectionsInfo_presult {
 public:


  virtual ~IClientRPCService_fetchAllConnectionsInfo_presult() noexcept;
  TSConnectionInfoResp* success;

  _IClientRPCService_fetchAllConnectionsInfo_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class IClientRPCService_testConnectionEmptyRPC_args {
 public:

  IClientRPCService_testConnectionEmptyRPC_args(const IClientRPCService_testConnectionEmptyRPC_args&);
  IClientRPCService_testConnectionEmptyRPC_args& operator=(const IClientRPCService_testConnectionEmptyRPC_args&);
  IClientRPCService_testConnectionEmptyRPC_args() {
  }

  virtual ~IClientRPCService_testConnectionEmptyRPC_args() noexcept;

  bool operator == (const IClientRPCService_testConnectionEmptyRPC_args & /* rhs */) const
  {
    return true;
  }
  bool operator != (const IClientRPCService_testConnectionEmptyRPC_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testConnectionEmptyRPC_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class IClientRPCService_testConnectionEmptyRPC_pargs {
 public:


  virtual ~IClientRPCService_testConnectionEmptyRPC_pargs() noexcept;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testConnectionEmptyRPC_result__isset {
  _IClientRPCService_testConnectionEmptyRPC_result__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testConnectionEmptyRPC_result__isset;

class IClientRPCService_testConnectionEmptyRPC_result {
 public:

  IClientRPCService_testConnectionEmptyRPC_result(const IClientRPCService_testConnectionEmptyRPC_result&);
  IClientRPCService_testConnectionEmptyRPC_result& operator=(const IClientRPCService_testConnectionEmptyRPC_result&);
  IClientRPCService_testConnectionEmptyRPC_result() {
  }

  virtual ~IClientRPCService_testConnectionEmptyRPC_result() noexcept;
   ::TSStatus success;

  _IClientRPCService_testConnectionEmptyRPC_result__isset __isset;

  void __set_success(const  ::TSStatus& val);

  bool operator == (const IClientRPCService_testConnectionEmptyRPC_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const IClientRPCService_testConnectionEmptyRPC_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const IClientRPCService_testConnectionEmptyRPC_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _IClientRPCService_testConnectionEmptyRPC_presult__isset {
  _IClientRPCService_testConnectionEmptyRPC_presult__isset() : success(false) {}
  bool success :1;
} _IClientRPCService_testConnectionEmptyRPC_presult__isset;

class IClientRPCService_testConnectionEmptyRPC_presult {
 public:


  virtual ~IClientRPCService_testConnectionEmptyRPC_presult() noexcept;
   ::TSStatus* success;

  _IClientRPCService_testConnectionEmptyRPC_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

class IClientRPCServiceClient : virtual public IClientRPCServiceIf {
 public:
  IClientRPCServiceClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
    setProtocol(prot);
  }
  IClientRPCServiceClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    setProtocol(iprot,oprot);
  }
 private:
  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
  setProtocol(prot,prot);
  }
  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    piprot_=iprot;
    poprot_=oprot;
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
 public:
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  void executeQueryStatementV2(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  void send_executeQueryStatementV2(const TSExecuteStatementReq& req);
  void recv_executeQueryStatementV2(TSExecuteStatementResp& _return);
  void executeUpdateStatementV2(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  void send_executeUpdateStatementV2(const TSExecuteStatementReq& req);
  void recv_executeUpdateStatementV2(TSExecuteStatementResp& _return);
  void executeStatementV2(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  void send_executeStatementV2(const TSExecuteStatementReq& req);
  void recv_executeStatementV2(TSExecuteStatementResp& _return);
  void executeRawDataQueryV2(TSExecuteStatementResp& _return, const TSRawDataQueryReq& req);
  void send_executeRawDataQueryV2(const TSRawDataQueryReq& req);
  void recv_executeRawDataQueryV2(TSExecuteStatementResp& _return);
  void executeLastDataQueryV2(TSExecuteStatementResp& _return, const TSLastDataQueryReq& req);
  void send_executeLastDataQueryV2(const TSLastDataQueryReq& req);
  void recv_executeLastDataQueryV2(TSExecuteStatementResp& _return);
  void executeFastLastDataQueryForOneDeviceV2(TSExecuteStatementResp& _return, const TSFastLastDataQueryForOneDeviceReq& req);
  void send_executeFastLastDataQueryForOneDeviceV2(const TSFastLastDataQueryForOneDeviceReq& req);
  void recv_executeFastLastDataQueryForOneDeviceV2(TSExecuteStatementResp& _return);
  void executeAggregationQueryV2(TSExecuteStatementResp& _return, const TSAggregationQueryReq& req);
  void send_executeAggregationQueryV2(const TSAggregationQueryReq& req);
  void recv_executeAggregationQueryV2(TSExecuteStatementResp& _return);
  void executeGroupByQueryIntervalQuery(TSExecuteStatementResp& _return, const TSGroupByQueryIntervalReq& req);
  void send_executeGroupByQueryIntervalQuery(const TSGroupByQueryIntervalReq& req);
  void recv_executeGroupByQueryIntervalQuery(TSExecuteStatementResp& _return);
  void fetchResultsV2(TSFetchResultsResp& _return, const TSFetchResultsReq& req);
  void send_fetchResultsV2(const TSFetchResultsReq& req);
  void recv_fetchResultsV2(TSFetchResultsResp& _return);
  void openSession(TSOpenSessionResp& _return, const TSOpenSessionReq& req);
  void send_openSession(const TSOpenSessionReq& req);
  void recv_openSession(TSOpenSessionResp& _return);
  void closeSession( ::TSStatus& _return, const TSCloseSessionReq& req);
  void send_closeSession(const TSCloseSessionReq& req);
  void recv_closeSession( ::TSStatus& _return);
  void executeStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  void send_executeStatement(const TSExecuteStatementReq& req);
  void recv_executeStatement(TSExecuteStatementResp& _return);
  void executeBatchStatement( ::TSStatus& _return, const TSExecuteBatchStatementReq& req);
  void send_executeBatchStatement(const TSExecuteBatchStatementReq& req);
  void recv_executeBatchStatement( ::TSStatus& _return);
  void executeQueryStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  void send_executeQueryStatement(const TSExecuteStatementReq& req);
  void recv_executeQueryStatement(TSExecuteStatementResp& _return);
  void executeUpdateStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  void send_executeUpdateStatement(const TSExecuteStatementReq& req);
  void recv_executeUpdateStatement(TSExecuteStatementResp& _return);
  void fetchResults(TSFetchResultsResp& _return, const TSFetchResultsReq& req);
  void send_fetchResults(const TSFetchResultsReq& req);
  void recv_fetchResults(TSFetchResultsResp& _return);
  void fetchMetadata(TSFetchMetadataResp& _return, const TSFetchMetadataReq& req);
  void send_fetchMetadata(const TSFetchMetadataReq& req);
  void recv_fetchMetadata(TSFetchMetadataResp& _return);
  void cancelOperation( ::TSStatus& _return, const TSCancelOperationReq& req);
  void send_cancelOperation(const TSCancelOperationReq& req);
  void recv_cancelOperation( ::TSStatus& _return);
  void closeOperation( ::TSStatus& _return, const TSCloseOperationReq& req);
  void send_closeOperation(const TSCloseOperationReq& req);
  void recv_closeOperation( ::TSStatus& _return);
  void getTimeZone(TSGetTimeZoneResp& _return, const int64_t sessionId);
  void send_getTimeZone(const int64_t sessionId);
  void recv_getTimeZone(TSGetTimeZoneResp& _return);
  void setTimeZone( ::TSStatus& _return, const TSSetTimeZoneReq& req);
  void send_setTimeZone(const TSSetTimeZoneReq& req);
  void recv_setTimeZone( ::TSStatus& _return);
  void getProperties(ServerProperties& _return);
  void send_getProperties();
  void recv_getProperties(ServerProperties& _return);
  void setStorageGroup( ::TSStatus& _return, const int64_t sessionId, const std::string& storageGroup);
  void send_setStorageGroup(const int64_t sessionId, const std::string& storageGroup);
  void recv_setStorageGroup( ::TSStatus& _return);
  void createTimeseries( ::TSStatus& _return, const TSCreateTimeseriesReq& req);
  void send_createTimeseries(const TSCreateTimeseriesReq& req);
  void recv_createTimeseries( ::TSStatus& _return);
  void createAlignedTimeseries( ::TSStatus& _return, const TSCreateAlignedTimeseriesReq& req);
  void send_createAlignedTimeseries(const TSCreateAlignedTimeseriesReq& req);
  void recv_createAlignedTimeseries( ::TSStatus& _return);
  void createMultiTimeseries( ::TSStatus& _return, const TSCreateMultiTimeseriesReq& req);
  void send_createMultiTimeseries(const TSCreateMultiTimeseriesReq& req);
  void recv_createMultiTimeseries( ::TSStatus& _return);
  void deleteTimeseries( ::TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & path);
  void send_deleteTimeseries(const int64_t sessionId, const std::vector<std::string> & path);
  void recv_deleteTimeseries( ::TSStatus& _return);
  void deleteStorageGroups( ::TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & storageGroup);
  void send_deleteStorageGroups(const int64_t sessionId, const std::vector<std::string> & storageGroup);
  void recv_deleteStorageGroups( ::TSStatus& _return);
  void insertRecord( ::TSStatus& _return, const TSInsertRecordReq& req);
  void send_insertRecord(const TSInsertRecordReq& req);
  void recv_insertRecord( ::TSStatus& _return);
  void insertStringRecord( ::TSStatus& _return, const TSInsertStringRecordReq& req);
  void send_insertStringRecord(const TSInsertStringRecordReq& req);
  void recv_insertStringRecord( ::TSStatus& _return);
  void insertTablet( ::TSStatus& _return, const TSInsertTabletReq& req);
  void send_insertTablet(const TSInsertTabletReq& req);
  void recv_insertTablet( ::TSStatus& _return);
  void insertTablets( ::TSStatus& _return, const TSInsertTabletsReq& req);
  void send_insertTablets(const TSInsertTabletsReq& req);
  void recv_insertTablets( ::TSStatus& _return);
  void insertRecords( ::TSStatus& _return, const TSInsertRecordsReq& req);
  void send_insertRecords(const TSInsertRecordsReq& req);
  void recv_insertRecords( ::TSStatus& _return);
  void insertRecordsOfOneDevice( ::TSStatus& _return, const TSInsertRecordsOfOneDeviceReq& req);
  void send_insertRecordsOfOneDevice(const TSInsertRecordsOfOneDeviceReq& req);
  void recv_insertRecordsOfOneDevice( ::TSStatus& _return);
  void insertStringRecordsOfOneDevice( ::TSStatus& _return, const TSInsertStringRecordsOfOneDeviceReq& req);
  void send_insertStringRecordsOfOneDevice(const TSInsertStringRecordsOfOneDeviceReq& req);
  void recv_insertStringRecordsOfOneDevice( ::TSStatus& _return);
  void insertStringRecords( ::TSStatus& _return, const TSInsertStringRecordsReq& req);
  void send_insertStringRecords(const TSInsertStringRecordsReq& req);
  void recv_insertStringRecords( ::TSStatus& _return);
  void testInsertTablet( ::TSStatus& _return, const TSInsertTabletReq& req);
  void send_testInsertTablet(const TSInsertTabletReq& req);
  void recv_testInsertTablet( ::TSStatus& _return);
  void testInsertTablets( ::TSStatus& _return, const TSInsertTabletsReq& req);
  void send_testInsertTablets(const TSInsertTabletsReq& req);
  void recv_testInsertTablets( ::TSStatus& _return);
  void testInsertRecord( ::TSStatus& _return, const TSInsertRecordReq& req);
  void send_testInsertRecord(const TSInsertRecordReq& req);
  void recv_testInsertRecord( ::TSStatus& _return);
  void testInsertStringRecord( ::TSStatus& _return, const TSInsertStringRecordReq& req);
  void send_testInsertStringRecord(const TSInsertStringRecordReq& req);
  void recv_testInsertStringRecord( ::TSStatus& _return);
  void testInsertRecords( ::TSStatus& _return, const TSInsertRecordsReq& req);
  void send_testInsertRecords(const TSInsertRecordsReq& req);
  void recv_testInsertRecords( ::TSStatus& _return);
  void testInsertRecordsOfOneDevice( ::TSStatus& _return, const TSInsertRecordsOfOneDeviceReq& req);
  void send_testInsertRecordsOfOneDevice(const TSInsertRecordsOfOneDeviceReq& req);
  void recv_testInsertRecordsOfOneDevice( ::TSStatus& _return);
  void testInsertStringRecords( ::TSStatus& _return, const TSInsertStringRecordsReq& req);
  void send_testInsertStringRecords(const TSInsertStringRecordsReq& req);
  void recv_testInsertStringRecords( ::TSStatus& _return);
  void deleteData( ::TSStatus& _return, const TSDeleteDataReq& req);
  void send_deleteData(const TSDeleteDataReq& req);
  void recv_deleteData( ::TSStatus& _return);
  void executeRawDataQuery(TSExecuteStatementResp& _return, const TSRawDataQueryReq& req);
  void send_executeRawDataQuery(const TSRawDataQueryReq& req);
  void recv_executeRawDataQuery(TSExecuteStatementResp& _return);
  void executeLastDataQuery(TSExecuteStatementResp& _return, const TSLastDataQueryReq& req);
  void send_executeLastDataQuery(const TSLastDataQueryReq& req);
  void recv_executeLastDataQuery(TSExecuteStatementResp& _return);
  void executeAggregationQuery(TSExecuteStatementResp& _return, const TSAggregationQueryReq& req);
  void send_executeAggregationQuery(const TSAggregationQueryReq& req);
  void recv_executeAggregationQuery(TSExecuteStatementResp& _return);
  int64_t requestStatementId(const int64_t sessionId);
  void send_requestStatementId(const int64_t sessionId);
  int64_t recv_requestStatementId();
  void createSchemaTemplate( ::TSStatus& _return, const TSCreateSchemaTemplateReq& req);
  void send_createSchemaTemplate(const TSCreateSchemaTemplateReq& req);
  void recv_createSchemaTemplate( ::TSStatus& _return);
  void appendSchemaTemplate( ::TSStatus& _return, const TSAppendSchemaTemplateReq& req);
  void send_appendSchemaTemplate(const TSAppendSchemaTemplateReq& req);
  void recv_appendSchemaTemplate( ::TSStatus& _return);
  void pruneSchemaTemplate( ::TSStatus& _return, const TSPruneSchemaTemplateReq& req);
  void send_pruneSchemaTemplate(const TSPruneSchemaTemplateReq& req);
  void recv_pruneSchemaTemplate( ::TSStatus& _return);
  void querySchemaTemplate(TSQueryTemplateResp& _return, const TSQueryTemplateReq& req);
  void send_querySchemaTemplate(const TSQueryTemplateReq& req);
  void recv_querySchemaTemplate(TSQueryTemplateResp& _return);
  void showConfigurationTemplate( ::TShowConfigurationTemplateResp& _return);
  void send_showConfigurationTemplate();
  void recv_showConfigurationTemplate( ::TShowConfigurationTemplateResp& _return);
  void showConfiguration( ::TShowConfigurationResp& _return, const int32_t nodeId);
  void send_showConfiguration(const int32_t nodeId);
  void recv_showConfiguration( ::TShowConfigurationResp& _return);
  void setSchemaTemplate( ::TSStatus& _return, const TSSetSchemaTemplateReq& req);
  void send_setSchemaTemplate(const TSSetSchemaTemplateReq& req);
  void recv_setSchemaTemplate( ::TSStatus& _return);
  void unsetSchemaTemplate( ::TSStatus& _return, const TSUnsetSchemaTemplateReq& req);
  void send_unsetSchemaTemplate(const TSUnsetSchemaTemplateReq& req);
  void recv_unsetSchemaTemplate( ::TSStatus& _return);
  void dropSchemaTemplate( ::TSStatus& _return, const TSDropSchemaTemplateReq& req);
  void send_dropSchemaTemplate(const TSDropSchemaTemplateReq& req);
  void recv_dropSchemaTemplate( ::TSStatus& _return);
  void createTimeseriesUsingSchemaTemplate( ::TSStatus& _return, const TCreateTimeseriesUsingSchemaTemplateReq& req);
  void send_createTimeseriesUsingSchemaTemplate(const TCreateTimeseriesUsingSchemaTemplateReq& req);
  void recv_createTimeseriesUsingSchemaTemplate( ::TSStatus& _return);
  void handshake( ::TSStatus& _return, const TSyncIdentityInfo& info);
  void send_handshake(const TSyncIdentityInfo& info);
  void recv_handshake( ::TSStatus& _return);
  void sendPipeData( ::TSStatus& _return, const std::string& buff);
  void send_sendPipeData(const std::string& buff);
  void recv_sendPipeData( ::TSStatus& _return);
  void sendFile( ::TSStatus& _return, const TSyncTransportMetaInfo& metaInfo, const std::string& buff);
  void send_sendFile(const TSyncTransportMetaInfo& metaInfo, const std::string& buff);
  void recv_sendFile( ::TSStatus& _return);
  void pipeTransfer(TPipeTransferResp& _return, const TPipeTransferReq& req);
  void send_pipeTransfer(const TPipeTransferReq& req);
  void recv_pipeTransfer(TPipeTransferResp& _return);
  void pipeSubscribe(TPipeSubscribeResp& _return, const TPipeSubscribeReq& req);
  void send_pipeSubscribe(const TPipeSubscribeReq& req);
  void recv_pipeSubscribe(TPipeSubscribeResp& _return);
  void getBackupConfiguration(TSBackupConfigurationResp& _return);
  void send_getBackupConfiguration();
  void recv_getBackupConfiguration(TSBackupConfigurationResp& _return);
  void fetchAllConnectionsInfo(TSConnectionInfoResp& _return);
  void send_fetchAllConnectionsInfo();
  void recv_fetchAllConnectionsInfo(TSConnectionInfoResp& _return);
  /**
   * For other node's call
   */
  void testConnectionEmptyRPC( ::TSStatus& _return);
  void send_testConnectionEmptyRPC();
  void recv_testConnectionEmptyRPC( ::TSStatus& _return);
 protected:
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
  ::apache::thrift::protocol::TProtocol* iprot_;
  ::apache::thrift::protocol::TProtocol* oprot_;
};

class IClientRPCServiceProcessor : public ::apache::thrift::TDispatchProcessor {
 protected:
  ::std::shared_ptr<IClientRPCServiceIf> iface_;
  virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
 private:
  typedef  void (IClientRPCServiceProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
  typedef std::map<std::string, ProcessFunction> ProcessMap;
  ProcessMap processMap_;
  void process_executeQueryStatementV2(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeUpdateStatementV2(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeStatementV2(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeRawDataQueryV2(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeLastDataQueryV2(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeFastLastDataQueryForOneDeviceV2(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeAggregationQueryV2(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeGroupByQueryIntervalQuery(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_fetchResultsV2(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_openSession(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_closeSession(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeStatement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeBatchStatement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeQueryStatement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeUpdateStatement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_fetchResults(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_fetchMetadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_cancelOperation(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_closeOperation(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_getTimeZone(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_setTimeZone(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_getProperties(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_setStorageGroup(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_createTimeseries(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_createAlignedTimeseries(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_createMultiTimeseries(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_deleteTimeseries(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_deleteStorageGroups(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_insertRecord(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_insertStringRecord(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_insertTablet(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_insertTablets(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_insertRecords(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_insertRecordsOfOneDevice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_insertStringRecordsOfOneDevice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_insertStringRecords(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_testInsertTablet(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_testInsertTablets(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_testInsertRecord(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_testInsertStringRecord(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_testInsertRecords(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_testInsertRecordsOfOneDevice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_testInsertStringRecords(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_deleteData(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeRawDataQuery(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeLastDataQuery(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeAggregationQuery(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_requestStatementId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_createSchemaTemplate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_appendSchemaTemplate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_pruneSchemaTemplate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_querySchemaTemplate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_showConfigurationTemplate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_showConfiguration(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_setSchemaTemplate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_unsetSchemaTemplate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_dropSchemaTemplate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_createTimeseriesUsingSchemaTemplate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_handshake(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_sendPipeData(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_sendFile(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_pipeTransfer(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_pipeSubscribe(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_getBackupConfiguration(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_fetchAllConnectionsInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_testConnectionEmptyRPC(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
 public:
  IClientRPCServiceProcessor(::std::shared_ptr<IClientRPCServiceIf> iface) :
    iface_(iface) {
    processMap_["executeQueryStatementV2"] = &IClientRPCServiceProcessor::process_executeQueryStatementV2;
    processMap_["executeUpdateStatementV2"] = &IClientRPCServiceProcessor::process_executeUpdateStatementV2;
    processMap_["executeStatementV2"] = &IClientRPCServiceProcessor::process_executeStatementV2;
    processMap_["executeRawDataQueryV2"] = &IClientRPCServiceProcessor::process_executeRawDataQueryV2;
    processMap_["executeLastDataQueryV2"] = &IClientRPCServiceProcessor::process_executeLastDataQueryV2;
    processMap_["executeFastLastDataQueryForOneDeviceV2"] = &IClientRPCServiceProcessor::process_executeFastLastDataQueryForOneDeviceV2;
    processMap_["executeAggregationQueryV2"] = &IClientRPCServiceProcessor::process_executeAggregationQueryV2;
    processMap_["executeGroupByQueryIntervalQuery"] = &IClientRPCServiceProcessor::process_executeGroupByQueryIntervalQuery;
    processMap_["fetchResultsV2"] = &IClientRPCServiceProcessor::process_fetchResultsV2;
    processMap_["openSession"] = &IClientRPCServiceProcessor::process_openSession;
    processMap_["closeSession"] = &IClientRPCServiceProcessor::process_closeSession;
    processMap_["executeStatement"] = &IClientRPCServiceProcessor::process_executeStatement;
    processMap_["executeBatchStatement"] = &IClientRPCServiceProcessor::process_executeBatchStatement;
    processMap_["executeQueryStatement"] = &IClientRPCServiceProcessor::process_executeQueryStatement;
    processMap_["executeUpdateStatement"] = &IClientRPCServiceProcessor::process_executeUpdateStatement;
    processMap_["fetchResults"] = &IClientRPCServiceProcessor::process_fetchResults;
    processMap_["fetchMetadata"] = &IClientRPCServiceProcessor::process_fetchMetadata;
    processMap_["cancelOperation"] = &IClientRPCServiceProcessor::process_cancelOperation;
    processMap_["closeOperation"] = &IClientRPCServiceProcessor::process_closeOperation;
    processMap_["getTimeZone"] = &IClientRPCServiceProcessor::process_getTimeZone;
    processMap_["setTimeZone"] = &IClientRPCServiceProcessor::process_setTimeZone;
    processMap_["getProperties"] = &IClientRPCServiceProcessor::process_getProperties;
    processMap_["setStorageGroup"] = &IClientRPCServiceProcessor::process_setStorageGroup;
    processMap_["createTimeseries"] = &IClientRPCServiceProcessor::process_createTimeseries;
    processMap_["createAlignedTimeseries"] = &IClientRPCServiceProcessor::process_createAlignedTimeseries;
    processMap_["createMultiTimeseries"] = &IClientRPCServiceProcessor::process_createMultiTimeseries;
    processMap_["deleteTimeseries"] = &IClientRPCServiceProcessor::process_deleteTimeseries;
    processMap_["deleteStorageGroups"] = &IClientRPCServiceProcessor::process_deleteStorageGroups;
    processMap_["insertRecord"] = &IClientRPCServiceProcessor::process_insertRecord;
    processMap_["insertStringRecord"] = &IClientRPCServiceProcessor::process_insertStringRecord;
    processMap_["insertTablet"] = &IClientRPCServiceProcessor::process_insertTablet;
    processMap_["insertTablets"] = &IClientRPCServiceProcessor::process_insertTablets;
    processMap_["insertRecords"] = &IClientRPCServiceProcessor::process_insertRecords;
    processMap_["insertRecordsOfOneDevice"] = &IClientRPCServiceProcessor::process_insertRecordsOfOneDevice;
    processMap_["insertStringRecordsOfOneDevice"] = &IClientRPCServiceProcessor::process_insertStringRecordsOfOneDevice;
    processMap_["insertStringRecords"] = &IClientRPCServiceProcessor::process_insertStringRecords;
    processMap_["testInsertTablet"] = &IClientRPCServiceProcessor::process_testInsertTablet;
    processMap_["testInsertTablets"] = &IClientRPCServiceProcessor::process_testInsertTablets;
    processMap_["testInsertRecord"] = &IClientRPCServiceProcessor::process_testInsertRecord;
    processMap_["testInsertStringRecord"] = &IClientRPCServiceProcessor::process_testInsertStringRecord;
    processMap_["testInsertRecords"] = &IClientRPCServiceProcessor::process_testInsertRecords;
    processMap_["testInsertRecordsOfOneDevice"] = &IClientRPCServiceProcessor::process_testInsertRecordsOfOneDevice;
    processMap_["testInsertStringRecords"] = &IClientRPCServiceProcessor::process_testInsertStringRecords;
    processMap_["deleteData"] = &IClientRPCServiceProcessor::process_deleteData;
    processMap_["executeRawDataQuery"] = &IClientRPCServiceProcessor::process_executeRawDataQuery;
    processMap_["executeLastDataQuery"] = &IClientRPCServiceProcessor::process_executeLastDataQuery;
    processMap_["executeAggregationQuery"] = &IClientRPCServiceProcessor::process_executeAggregationQuery;
    processMap_["requestStatementId"] = &IClientRPCServiceProcessor::process_requestStatementId;
    processMap_["createSchemaTemplate"] = &IClientRPCServiceProcessor::process_createSchemaTemplate;
    processMap_["appendSchemaTemplate"] = &IClientRPCServiceProcessor::process_appendSchemaTemplate;
    processMap_["pruneSchemaTemplate"] = &IClientRPCServiceProcessor::process_pruneSchemaTemplate;
    processMap_["querySchemaTemplate"] = &IClientRPCServiceProcessor::process_querySchemaTemplate;
    processMap_["showConfigurationTemplate"] = &IClientRPCServiceProcessor::process_showConfigurationTemplate;
    processMap_["showConfiguration"] = &IClientRPCServiceProcessor::process_showConfiguration;
    processMap_["setSchemaTemplate"] = &IClientRPCServiceProcessor::process_setSchemaTemplate;
    processMap_["unsetSchemaTemplate"] = &IClientRPCServiceProcessor::process_unsetSchemaTemplate;
    processMap_["dropSchemaTemplate"] = &IClientRPCServiceProcessor::process_dropSchemaTemplate;
    processMap_["createTimeseriesUsingSchemaTemplate"] = &IClientRPCServiceProcessor::process_createTimeseriesUsingSchemaTemplate;
    processMap_["handshake"] = &IClientRPCServiceProcessor::process_handshake;
    processMap_["sendPipeData"] = &IClientRPCServiceProcessor::process_sendPipeData;
    processMap_["sendFile"] = &IClientRPCServiceProcessor::process_sendFile;
    processMap_["pipeTransfer"] = &IClientRPCServiceProcessor::process_pipeTransfer;
    processMap_["pipeSubscribe"] = &IClientRPCServiceProcessor::process_pipeSubscribe;
    processMap_["getBackupConfiguration"] = &IClientRPCServiceProcessor::process_getBackupConfiguration;
    processMap_["fetchAllConnectionsInfo"] = &IClientRPCServiceProcessor::process_fetchAllConnectionsInfo;
    processMap_["testConnectionEmptyRPC"] = &IClientRPCServiceProcessor::process_testConnectionEmptyRPC;
  }

  virtual ~IClientRPCServiceProcessor() {}
};

class IClientRPCServiceProcessorFactory : public ::apache::thrift::TProcessorFactory {
 public:
  IClientRPCServiceProcessorFactory(const ::std::shared_ptr< IClientRPCServiceIfFactory >& handlerFactory) :
      handlerFactory_(handlerFactory) {}

  ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);

 protected:
  ::std::shared_ptr< IClientRPCServiceIfFactory > handlerFactory_;
};

class IClientRPCServiceMultiface : virtual public IClientRPCServiceIf {
 public:
  IClientRPCServiceMultiface(std::vector<std::shared_ptr<IClientRPCServiceIf> >& ifaces) : ifaces_(ifaces) {
  }
  virtual ~IClientRPCServiceMultiface() {}
 protected:
  std::vector<std::shared_ptr<IClientRPCServiceIf> > ifaces_;
  IClientRPCServiceMultiface() {}
  void add(::std::shared_ptr<IClientRPCServiceIf> iface) {
    ifaces_.push_back(iface);
  }
 public:
  void executeQueryStatementV2(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeQueryStatementV2(_return, req);
    }
    ifaces_[i]->executeQueryStatementV2(_return, req);
    return;
  }

  void executeUpdateStatementV2(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeUpdateStatementV2(_return, req);
    }
    ifaces_[i]->executeUpdateStatementV2(_return, req);
    return;
  }

  void executeStatementV2(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeStatementV2(_return, req);
    }
    ifaces_[i]->executeStatementV2(_return, req);
    return;
  }

  void executeRawDataQueryV2(TSExecuteStatementResp& _return, const TSRawDataQueryReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeRawDataQueryV2(_return, req);
    }
    ifaces_[i]->executeRawDataQueryV2(_return, req);
    return;
  }

  void executeLastDataQueryV2(TSExecuteStatementResp& _return, const TSLastDataQueryReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeLastDataQueryV2(_return, req);
    }
    ifaces_[i]->executeLastDataQueryV2(_return, req);
    return;
  }

  void executeFastLastDataQueryForOneDeviceV2(TSExecuteStatementResp& _return, const TSFastLastDataQueryForOneDeviceReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeFastLastDataQueryForOneDeviceV2(_return, req);
    }
    ifaces_[i]->executeFastLastDataQueryForOneDeviceV2(_return, req);
    return;
  }

  void executeAggregationQueryV2(TSExecuteStatementResp& _return, const TSAggregationQueryReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeAggregationQueryV2(_return, req);
    }
    ifaces_[i]->executeAggregationQueryV2(_return, req);
    return;
  }

  void executeGroupByQueryIntervalQuery(TSExecuteStatementResp& _return, const TSGroupByQueryIntervalReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeGroupByQueryIntervalQuery(_return, req);
    }
    ifaces_[i]->executeGroupByQueryIntervalQuery(_return, req);
    return;
  }

  void fetchResultsV2(TSFetchResultsResp& _return, const TSFetchResultsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->fetchResultsV2(_return, req);
    }
    ifaces_[i]->fetchResultsV2(_return, req);
    return;
  }

  void openSession(TSOpenSessionResp& _return, const TSOpenSessionReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->openSession(_return, req);
    }
    ifaces_[i]->openSession(_return, req);
    return;
  }

  void closeSession( ::TSStatus& _return, const TSCloseSessionReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->closeSession(_return, req);
    }
    ifaces_[i]->closeSession(_return, req);
    return;
  }

  void executeStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeStatement(_return, req);
    }
    ifaces_[i]->executeStatement(_return, req);
    return;
  }

  void executeBatchStatement( ::TSStatus& _return, const TSExecuteBatchStatementReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeBatchStatement(_return, req);
    }
    ifaces_[i]->executeBatchStatement(_return, req);
    return;
  }

  void executeQueryStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeQueryStatement(_return, req);
    }
    ifaces_[i]->executeQueryStatement(_return, req);
    return;
  }

  void executeUpdateStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeUpdateStatement(_return, req);
    }
    ifaces_[i]->executeUpdateStatement(_return, req);
    return;
  }

  void fetchResults(TSFetchResultsResp& _return, const TSFetchResultsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->fetchResults(_return, req);
    }
    ifaces_[i]->fetchResults(_return, req);
    return;
  }

  void fetchMetadata(TSFetchMetadataResp& _return, const TSFetchMetadataReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->fetchMetadata(_return, req);
    }
    ifaces_[i]->fetchMetadata(_return, req);
    return;
  }

  void cancelOperation( ::TSStatus& _return, const TSCancelOperationReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->cancelOperation(_return, req);
    }
    ifaces_[i]->cancelOperation(_return, req);
    return;
  }

  void closeOperation( ::TSStatus& _return, const TSCloseOperationReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->closeOperation(_return, req);
    }
    ifaces_[i]->closeOperation(_return, req);
    return;
  }

  void getTimeZone(TSGetTimeZoneResp& _return, const int64_t sessionId) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->getTimeZone(_return, sessionId);
    }
    ifaces_[i]->getTimeZone(_return, sessionId);
    return;
  }

  void setTimeZone( ::TSStatus& _return, const TSSetTimeZoneReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->setTimeZone(_return, req);
    }
    ifaces_[i]->setTimeZone(_return, req);
    return;
  }

  void getProperties(ServerProperties& _return) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->getProperties(_return);
    }
    ifaces_[i]->getProperties(_return);
    return;
  }

  void setStorageGroup( ::TSStatus& _return, const int64_t sessionId, const std::string& storageGroup) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->setStorageGroup(_return, sessionId, storageGroup);
    }
    ifaces_[i]->setStorageGroup(_return, sessionId, storageGroup);
    return;
  }

  void createTimeseries( ::TSStatus& _return, const TSCreateTimeseriesReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->createTimeseries(_return, req);
    }
    ifaces_[i]->createTimeseries(_return, req);
    return;
  }

  void createAlignedTimeseries( ::TSStatus& _return, const TSCreateAlignedTimeseriesReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->createAlignedTimeseries(_return, req);
    }
    ifaces_[i]->createAlignedTimeseries(_return, req);
    return;
  }

  void createMultiTimeseries( ::TSStatus& _return, const TSCreateMultiTimeseriesReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->createMultiTimeseries(_return, req);
    }
    ifaces_[i]->createMultiTimeseries(_return, req);
    return;
  }

  void deleteTimeseries( ::TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & path) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->deleteTimeseries(_return, sessionId, path);
    }
    ifaces_[i]->deleteTimeseries(_return, sessionId, path);
    return;
  }

  void deleteStorageGroups( ::TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & storageGroup) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->deleteStorageGroups(_return, sessionId, storageGroup);
    }
    ifaces_[i]->deleteStorageGroups(_return, sessionId, storageGroup);
    return;
  }

  void insertRecord( ::TSStatus& _return, const TSInsertRecordReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->insertRecord(_return, req);
    }
    ifaces_[i]->insertRecord(_return, req);
    return;
  }

  void insertStringRecord( ::TSStatus& _return, const TSInsertStringRecordReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->insertStringRecord(_return, req);
    }
    ifaces_[i]->insertStringRecord(_return, req);
    return;
  }

  void insertTablet( ::TSStatus& _return, const TSInsertTabletReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->insertTablet(_return, req);
    }
    ifaces_[i]->insertTablet(_return, req);
    return;
  }

  void insertTablets( ::TSStatus& _return, const TSInsertTabletsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->insertTablets(_return, req);
    }
    ifaces_[i]->insertTablets(_return, req);
    return;
  }

  void insertRecords( ::TSStatus& _return, const TSInsertRecordsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->insertRecords(_return, req);
    }
    ifaces_[i]->insertRecords(_return, req);
    return;
  }

  void insertRecordsOfOneDevice( ::TSStatus& _return, const TSInsertRecordsOfOneDeviceReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->insertRecordsOfOneDevice(_return, req);
    }
    ifaces_[i]->insertRecordsOfOneDevice(_return, req);
    return;
  }

  void insertStringRecordsOfOneDevice( ::TSStatus& _return, const TSInsertStringRecordsOfOneDeviceReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->insertStringRecordsOfOneDevice(_return, req);
    }
    ifaces_[i]->insertStringRecordsOfOneDevice(_return, req);
    return;
  }

  void insertStringRecords( ::TSStatus& _return, const TSInsertStringRecordsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->insertStringRecords(_return, req);
    }
    ifaces_[i]->insertStringRecords(_return, req);
    return;
  }

  void testInsertTablet( ::TSStatus& _return, const TSInsertTabletReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->testInsertTablet(_return, req);
    }
    ifaces_[i]->testInsertTablet(_return, req);
    return;
  }

  void testInsertTablets( ::TSStatus& _return, const TSInsertTabletsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->testInsertTablets(_return, req);
    }
    ifaces_[i]->testInsertTablets(_return, req);
    return;
  }

  void testInsertRecord( ::TSStatus& _return, const TSInsertRecordReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->testInsertRecord(_return, req);
    }
    ifaces_[i]->testInsertRecord(_return, req);
    return;
  }

  void testInsertStringRecord( ::TSStatus& _return, const TSInsertStringRecordReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->testInsertStringRecord(_return, req);
    }
    ifaces_[i]->testInsertStringRecord(_return, req);
    return;
  }

  void testInsertRecords( ::TSStatus& _return, const TSInsertRecordsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->testInsertRecords(_return, req);
    }
    ifaces_[i]->testInsertRecords(_return, req);
    return;
  }

  void testInsertRecordsOfOneDevice( ::TSStatus& _return, const TSInsertRecordsOfOneDeviceReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->testInsertRecordsOfOneDevice(_return, req);
    }
    ifaces_[i]->testInsertRecordsOfOneDevice(_return, req);
    return;
  }

  void testInsertStringRecords( ::TSStatus& _return, const TSInsertStringRecordsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->testInsertStringRecords(_return, req);
    }
    ifaces_[i]->testInsertStringRecords(_return, req);
    return;
  }

  void deleteData( ::TSStatus& _return, const TSDeleteDataReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->deleteData(_return, req);
    }
    ifaces_[i]->deleteData(_return, req);
    return;
  }

  void executeRawDataQuery(TSExecuteStatementResp& _return, const TSRawDataQueryReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeRawDataQuery(_return, req);
    }
    ifaces_[i]->executeRawDataQuery(_return, req);
    return;
  }

  void executeLastDataQuery(TSExecuteStatementResp& _return, const TSLastDataQueryReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeLastDataQuery(_return, req);
    }
    ifaces_[i]->executeLastDataQuery(_return, req);
    return;
  }

  void executeAggregationQuery(TSExecuteStatementResp& _return, const TSAggregationQueryReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeAggregationQuery(_return, req);
    }
    ifaces_[i]->executeAggregationQuery(_return, req);
    return;
  }

  int64_t requestStatementId(const int64_t sessionId) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->requestStatementId(sessionId);
    }
    return ifaces_[i]->requestStatementId(sessionId);
  }

  void createSchemaTemplate( ::TSStatus& _return, const TSCreateSchemaTemplateReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->createSchemaTemplate(_return, req);
    }
    ifaces_[i]->createSchemaTemplate(_return, req);
    return;
  }

  void appendSchemaTemplate( ::TSStatus& _return, const TSAppendSchemaTemplateReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->appendSchemaTemplate(_return, req);
    }
    ifaces_[i]->appendSchemaTemplate(_return, req);
    return;
  }

  void pruneSchemaTemplate( ::TSStatus& _return, const TSPruneSchemaTemplateReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->pruneSchemaTemplate(_return, req);
    }
    ifaces_[i]->pruneSchemaTemplate(_return, req);
    return;
  }

  void querySchemaTemplate(TSQueryTemplateResp& _return, const TSQueryTemplateReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->querySchemaTemplate(_return, req);
    }
    ifaces_[i]->querySchemaTemplate(_return, req);
    return;
  }

  void showConfigurationTemplate( ::TShowConfigurationTemplateResp& _return) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->showConfigurationTemplate(_return);
    }
    ifaces_[i]->showConfigurationTemplate(_return);
    return;
  }

  void showConfiguration( ::TShowConfigurationResp& _return, const int32_t nodeId) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->showConfiguration(_return, nodeId);
    }
    ifaces_[i]->showConfiguration(_return, nodeId);
    return;
  }

  void setSchemaTemplate( ::TSStatus& _return, const TSSetSchemaTemplateReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->setSchemaTemplate(_return, req);
    }
    ifaces_[i]->setSchemaTemplate(_return, req);
    return;
  }

  void unsetSchemaTemplate( ::TSStatus& _return, const TSUnsetSchemaTemplateReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->unsetSchemaTemplate(_return, req);
    }
    ifaces_[i]->unsetSchemaTemplate(_return, req);
    return;
  }

  void dropSchemaTemplate( ::TSStatus& _return, const TSDropSchemaTemplateReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->dropSchemaTemplate(_return, req);
    }
    ifaces_[i]->dropSchemaTemplate(_return, req);
    return;
  }

  void createTimeseriesUsingSchemaTemplate( ::TSStatus& _return, const TCreateTimeseriesUsingSchemaTemplateReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->createTimeseriesUsingSchemaTemplate(_return, req);
    }
    ifaces_[i]->createTimeseriesUsingSchemaTemplate(_return, req);
    return;
  }

  void handshake( ::TSStatus& _return, const TSyncIdentityInfo& info) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->handshake(_return, info);
    }
    ifaces_[i]->handshake(_return, info);
    return;
  }

  void sendPipeData( ::TSStatus& _return, const std::string& buff) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->sendPipeData(_return, buff);
    }
    ifaces_[i]->sendPipeData(_return, buff);
    return;
  }

  void sendFile( ::TSStatus& _return, const TSyncTransportMetaInfo& metaInfo, const std::string& buff) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->sendFile(_return, metaInfo, buff);
    }
    ifaces_[i]->sendFile(_return, metaInfo, buff);
    return;
  }

  void pipeTransfer(TPipeTransferResp& _return, const TPipeTransferReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->pipeTransfer(_return, req);
    }
    ifaces_[i]->pipeTransfer(_return, req);
    return;
  }

  void pipeSubscribe(TPipeSubscribeResp& _return, const TPipeSubscribeReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->pipeSubscribe(_return, req);
    }
    ifaces_[i]->pipeSubscribe(_return, req);
    return;
  }

  void getBackupConfiguration(TSBackupConfigurationResp& _return) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->getBackupConfiguration(_return);
    }
    ifaces_[i]->getBackupConfiguration(_return);
    return;
  }

  void fetchAllConnectionsInfo(TSConnectionInfoResp& _return) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->fetchAllConnectionsInfo(_return);
    }
    ifaces_[i]->fetchAllConnectionsInfo(_return);
    return;
  }

  /**
   * For other node's call
   */
  void testConnectionEmptyRPC( ::TSStatus& _return) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->testConnectionEmptyRPC(_return);
    }
    ifaces_[i]->testConnectionEmptyRPC(_return);
    return;
  }

};

// The 'concurrent' client is a thread safe client that correctly handles
// out of order responses.  It is slower than the regular client, so should
// only be used when you need to share a connection among multiple threads
class IClientRPCServiceConcurrentClient : virtual public IClientRPCServiceIf {
 public:
  IClientRPCServiceConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync)
{
    setProtocol(prot);
  }
  IClientRPCServiceConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync)
{
    setProtocol(iprot,oprot);
  }
 private:
  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
  setProtocol(prot,prot);
  }
  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    piprot_=iprot;
    poprot_=oprot;
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
 public:
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  void executeQueryStatementV2(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  int32_t send_executeQueryStatementV2(const TSExecuteStatementReq& req);
  void recv_executeQueryStatementV2(TSExecuteStatementResp& _return, const int32_t seqid);
  void executeUpdateStatementV2(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  int32_t send_executeUpdateStatementV2(const TSExecuteStatementReq& req);
  void recv_executeUpdateStatementV2(TSExecuteStatementResp& _return, const int32_t seqid);
  void executeStatementV2(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  int32_t send_executeStatementV2(const TSExecuteStatementReq& req);
  void recv_executeStatementV2(TSExecuteStatementResp& _return, const int32_t seqid);
  void executeRawDataQueryV2(TSExecuteStatementResp& _return, const TSRawDataQueryReq& req);
  int32_t send_executeRawDataQueryV2(const TSRawDataQueryReq& req);
  void recv_executeRawDataQueryV2(TSExecuteStatementResp& _return, const int32_t seqid);
  void executeLastDataQueryV2(TSExecuteStatementResp& _return, const TSLastDataQueryReq& req);
  int32_t send_executeLastDataQueryV2(const TSLastDataQueryReq& req);
  void recv_executeLastDataQueryV2(TSExecuteStatementResp& _return, const int32_t seqid);
  void executeFastLastDataQueryForOneDeviceV2(TSExecuteStatementResp& _return, const TSFastLastDataQueryForOneDeviceReq& req);
  int32_t send_executeFastLastDataQueryForOneDeviceV2(const TSFastLastDataQueryForOneDeviceReq& req);
  void recv_executeFastLastDataQueryForOneDeviceV2(TSExecuteStatementResp& _return, const int32_t seqid);
  void executeAggregationQueryV2(TSExecuteStatementResp& _return, const TSAggregationQueryReq& req);
  int32_t send_executeAggregationQueryV2(const TSAggregationQueryReq& req);
  void recv_executeAggregationQueryV2(TSExecuteStatementResp& _return, const int32_t seqid);
  void executeGroupByQueryIntervalQuery(TSExecuteStatementResp& _return, const TSGroupByQueryIntervalReq& req);
  int32_t send_executeGroupByQueryIntervalQuery(const TSGroupByQueryIntervalReq& req);
  void recv_executeGroupByQueryIntervalQuery(TSExecuteStatementResp& _return, const int32_t seqid);
  void fetchResultsV2(TSFetchResultsResp& _return, const TSFetchResultsReq& req);
  int32_t send_fetchResultsV2(const TSFetchResultsReq& req);
  void recv_fetchResultsV2(TSFetchResultsResp& _return, const int32_t seqid);
  void openSession(TSOpenSessionResp& _return, const TSOpenSessionReq& req);
  int32_t send_openSession(const TSOpenSessionReq& req);
  void recv_openSession(TSOpenSessionResp& _return, const int32_t seqid);
  void closeSession( ::TSStatus& _return, const TSCloseSessionReq& req);
  int32_t send_closeSession(const TSCloseSessionReq& req);
  void recv_closeSession( ::TSStatus& _return, const int32_t seqid);
  void executeStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  int32_t send_executeStatement(const TSExecuteStatementReq& req);
  void recv_executeStatement(TSExecuteStatementResp& _return, const int32_t seqid);
  void executeBatchStatement( ::TSStatus& _return, const TSExecuteBatchStatementReq& req);
  int32_t send_executeBatchStatement(const TSExecuteBatchStatementReq& req);
  void recv_executeBatchStatement( ::TSStatus& _return, const int32_t seqid);
  void executeQueryStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  int32_t send_executeQueryStatement(const TSExecuteStatementReq& req);
  void recv_executeQueryStatement(TSExecuteStatementResp& _return, const int32_t seqid);
  void executeUpdateStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  int32_t send_executeUpdateStatement(const TSExecuteStatementReq& req);
  void recv_executeUpdateStatement(TSExecuteStatementResp& _return, const int32_t seqid);
  void fetchResults(TSFetchResultsResp& _return, const TSFetchResultsReq& req);
  int32_t send_fetchResults(const TSFetchResultsReq& req);
  void recv_fetchResults(TSFetchResultsResp& _return, const int32_t seqid);
  void fetchMetadata(TSFetchMetadataResp& _return, const TSFetchMetadataReq& req);
  int32_t send_fetchMetadata(const TSFetchMetadataReq& req);
  void recv_fetchMetadata(TSFetchMetadataResp& _return, const int32_t seqid);
  void cancelOperation( ::TSStatus& _return, const TSCancelOperationReq& req);
  int32_t send_cancelOperation(const TSCancelOperationReq& req);
  void recv_cancelOperation( ::TSStatus& _return, const int32_t seqid);
  void closeOperation( ::TSStatus& _return, const TSCloseOperationReq& req);
  int32_t send_closeOperation(const TSCloseOperationReq& req);
  void recv_closeOperation( ::TSStatus& _return, const int32_t seqid);
  void getTimeZone(TSGetTimeZoneResp& _return, const int64_t sessionId);
  int32_t send_getTimeZone(const int64_t sessionId);
  void recv_getTimeZone(TSGetTimeZoneResp& _return, const int32_t seqid);
  void setTimeZone( ::TSStatus& _return, const TSSetTimeZoneReq& req);
  int32_t send_setTimeZone(const TSSetTimeZoneReq& req);
  void recv_setTimeZone( ::TSStatus& _return, const int32_t seqid);
  void getProperties(ServerProperties& _return);
  int32_t send_getProperties();
  void recv_getProperties(ServerProperties& _return, const int32_t seqid);
  void setStorageGroup( ::TSStatus& _return, const int64_t sessionId, const std::string& storageGroup);
  int32_t send_setStorageGroup(const int64_t sessionId, const std::string& storageGroup);
  void recv_setStorageGroup( ::TSStatus& _return, const int32_t seqid);
  void createTimeseries( ::TSStatus& _return, const TSCreateTimeseriesReq& req);
  int32_t send_createTimeseries(const TSCreateTimeseriesReq& req);
  void recv_createTimeseries( ::TSStatus& _return, const int32_t seqid);
  void createAlignedTimeseries( ::TSStatus& _return, const TSCreateAlignedTimeseriesReq& req);
  int32_t send_createAlignedTimeseries(const TSCreateAlignedTimeseriesReq& req);
  void recv_createAlignedTimeseries( ::TSStatus& _return, const int32_t seqid);
  void createMultiTimeseries( ::TSStatus& _return, const TSCreateMultiTimeseriesReq& req);
  int32_t send_createMultiTimeseries(const TSCreateMultiTimeseriesReq& req);
  void recv_createMultiTimeseries( ::TSStatus& _return, const int32_t seqid);
  void deleteTimeseries( ::TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & path);
  int32_t send_deleteTimeseries(const int64_t sessionId, const std::vector<std::string> & path);
  void recv_deleteTimeseries( ::TSStatus& _return, const int32_t seqid);
  void deleteStorageGroups( ::TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & storageGroup);
  int32_t send_deleteStorageGroups(const int64_t sessionId, const std::vector<std::string> & storageGroup);
  void recv_deleteStorageGroups( ::TSStatus& _return, const int32_t seqid);
  void insertRecord( ::TSStatus& _return, const TSInsertRecordReq& req);
  int32_t send_insertRecord(const TSInsertRecordReq& req);
  void recv_insertRecord( ::TSStatus& _return, const int32_t seqid);
  void insertStringRecord( ::TSStatus& _return, const TSInsertStringRecordReq& req);
  int32_t send_insertStringRecord(const TSInsertStringRecordReq& req);
  void recv_insertStringRecord( ::TSStatus& _return, const int32_t seqid);
  void insertTablet( ::TSStatus& _return, const TSInsertTabletReq& req);
  int32_t send_insertTablet(const TSInsertTabletReq& req);
  void recv_insertTablet( ::TSStatus& _return, const int32_t seqid);
  void insertTablets( ::TSStatus& _return, const TSInsertTabletsReq& req);
  int32_t send_insertTablets(const TSInsertTabletsReq& req);
  void recv_insertTablets( ::TSStatus& _return, const int32_t seqid);
  void insertRecords( ::TSStatus& _return, const TSInsertRecordsReq& req);
  int32_t send_insertRecords(const TSInsertRecordsReq& req);
  void recv_insertRecords( ::TSStatus& _return, const int32_t seqid);
  void insertRecordsOfOneDevice( ::TSStatus& _return, const TSInsertRecordsOfOneDeviceReq& req);
  int32_t send_insertRecordsOfOneDevice(const TSInsertRecordsOfOneDeviceReq& req);
  void recv_insertRecordsOfOneDevice( ::TSStatus& _return, const int32_t seqid);
  void insertStringRecordsOfOneDevice( ::TSStatus& _return, const TSInsertStringRecordsOfOneDeviceReq& req);
  int32_t send_insertStringRecordsOfOneDevice(const TSInsertStringRecordsOfOneDeviceReq& req);
  void recv_insertStringRecordsOfOneDevice( ::TSStatus& _return, const int32_t seqid);
  void insertStringRecords( ::TSStatus& _return, const TSInsertStringRecordsReq& req);
  int32_t send_insertStringRecords(const TSInsertStringRecordsReq& req);
  void recv_insertStringRecords( ::TSStatus& _return, const int32_t seqid);
  void testInsertTablet( ::TSStatus& _return, const TSInsertTabletReq& req);
  int32_t send_testInsertTablet(const TSInsertTabletReq& req);
  void recv_testInsertTablet( ::TSStatus& _return, const int32_t seqid);
  void testInsertTablets( ::TSStatus& _return, const TSInsertTabletsReq& req);
  int32_t send_testInsertTablets(const TSInsertTabletsReq& req);
  void recv_testInsertTablets( ::TSStatus& _return, const int32_t seqid);
  void testInsertRecord( ::TSStatus& _return, const TSInsertRecordReq& req);
  int32_t send_testInsertRecord(const TSInsertRecordReq& req);
  void recv_testInsertRecord( ::TSStatus& _return, const int32_t seqid);
  void testInsertStringRecord( ::TSStatus& _return, const TSInsertStringRecordReq& req);
  int32_t send_testInsertStringRecord(const TSInsertStringRecordReq& req);
  void recv_testInsertStringRecord( ::TSStatus& _return, const int32_t seqid);
  void testInsertRecords( ::TSStatus& _return, const TSInsertRecordsReq& req);
  int32_t send_testInsertRecords(const TSInsertRecordsReq& req);
  void recv_testInsertRecords( ::TSStatus& _return, const int32_t seqid);
  void testInsertRecordsOfOneDevice( ::TSStatus& _return, const TSInsertRecordsOfOneDeviceReq& req);
  int32_t send_testInsertRecordsOfOneDevice(const TSInsertRecordsOfOneDeviceReq& req);
  void recv_testInsertRecordsOfOneDevice( ::TSStatus& _return, const int32_t seqid);
  void testInsertStringRecords( ::TSStatus& _return, const TSInsertStringRecordsReq& req);
  int32_t send_testInsertStringRecords(const TSInsertStringRecordsReq& req);
  void recv_testInsertStringRecords( ::TSStatus& _return, const int32_t seqid);
  void deleteData( ::TSStatus& _return, const TSDeleteDataReq& req);
  int32_t send_deleteData(const TSDeleteDataReq& req);
  void recv_deleteData( ::TSStatus& _return, const int32_t seqid);
  void executeRawDataQuery(TSExecuteStatementResp& _return, const TSRawDataQueryReq& req);
  int32_t send_executeRawDataQuery(const TSRawDataQueryReq& req);
  void recv_executeRawDataQuery(TSExecuteStatementResp& _return, const int32_t seqid);
  void executeLastDataQuery(TSExecuteStatementResp& _return, const TSLastDataQueryReq& req);
  int32_t send_executeLastDataQuery(const TSLastDataQueryReq& req);
  void recv_executeLastDataQuery(TSExecuteStatementResp& _return, const int32_t seqid);
  void executeAggregationQuery(TSExecuteStatementResp& _return, const TSAggregationQueryReq& req);
  int32_t send_executeAggregationQuery(const TSAggregationQueryReq& req);
  void recv_executeAggregationQuery(TSExecuteStatementResp& _return, const int32_t seqid);
  int64_t requestStatementId(const int64_t sessionId);
  int32_t send_requestStatementId(const int64_t sessionId);
  int64_t recv_requestStatementId(const int32_t seqid);
  void createSchemaTemplate( ::TSStatus& _return, const TSCreateSchemaTemplateReq& req);
  int32_t send_createSchemaTemplate(const TSCreateSchemaTemplateReq& req);
  void recv_createSchemaTemplate( ::TSStatus& _return, const int32_t seqid);
  void appendSchemaTemplate( ::TSStatus& _return, const TSAppendSchemaTemplateReq& req);
  int32_t send_appendSchemaTemplate(const TSAppendSchemaTemplateReq& req);
  void recv_appendSchemaTemplate( ::TSStatus& _return, const int32_t seqid);
  void pruneSchemaTemplate( ::TSStatus& _return, const TSPruneSchemaTemplateReq& req);
  int32_t send_pruneSchemaTemplate(const TSPruneSchemaTemplateReq& req);
  void recv_pruneSchemaTemplate( ::TSStatus& _return, const int32_t seqid);
  void querySchemaTemplate(TSQueryTemplateResp& _return, const TSQueryTemplateReq& req);
  int32_t send_querySchemaTemplate(const TSQueryTemplateReq& req);
  void recv_querySchemaTemplate(TSQueryTemplateResp& _return, const int32_t seqid);
  void showConfigurationTemplate( ::TShowConfigurationTemplateResp& _return);
  int32_t send_showConfigurationTemplate();
  void recv_showConfigurationTemplate( ::TShowConfigurationTemplateResp& _return, const int32_t seqid);
  void showConfiguration( ::TShowConfigurationResp& _return, const int32_t nodeId);
  int32_t send_showConfiguration(const int32_t nodeId);
  void recv_showConfiguration( ::TShowConfigurationResp& _return, const int32_t seqid);
  void setSchemaTemplate( ::TSStatus& _return, const TSSetSchemaTemplateReq& req);
  int32_t send_setSchemaTemplate(const TSSetSchemaTemplateReq& req);
  void recv_setSchemaTemplate( ::TSStatus& _return, const int32_t seqid);
  void unsetSchemaTemplate( ::TSStatus& _return, const TSUnsetSchemaTemplateReq& req);
  int32_t send_unsetSchemaTemplate(const TSUnsetSchemaTemplateReq& req);
  void recv_unsetSchemaTemplate( ::TSStatus& _return, const int32_t seqid);
  void dropSchemaTemplate( ::TSStatus& _return, const TSDropSchemaTemplateReq& req);
  int32_t send_dropSchemaTemplate(const TSDropSchemaTemplateReq& req);
  void recv_dropSchemaTemplate( ::TSStatus& _return, const int32_t seqid);
  void createTimeseriesUsingSchemaTemplate( ::TSStatus& _return, const TCreateTimeseriesUsingSchemaTemplateReq& req);
  int32_t send_createTimeseriesUsingSchemaTemplate(const TCreateTimeseriesUsingSchemaTemplateReq& req);
  void recv_createTimeseriesUsingSchemaTemplate( ::TSStatus& _return, const int32_t seqid);
  void handshake( ::TSStatus& _return, const TSyncIdentityInfo& info);
  int32_t send_handshake(const TSyncIdentityInfo& info);
  void recv_handshake( ::TSStatus& _return, const int32_t seqid);
  void sendPipeData( ::TSStatus& _return, const std::string& buff);
  int32_t send_sendPipeData(const std::string& buff);
  void recv_sendPipeData( ::TSStatus& _return, const int32_t seqid);
  void sendFile( ::TSStatus& _return, const TSyncTransportMetaInfo& metaInfo, const std::string& buff);
  int32_t send_sendFile(const TSyncTransportMetaInfo& metaInfo, const std::string& buff);
  void recv_sendFile( ::TSStatus& _return, const int32_t seqid);
  void pipeTransfer(TPipeTransferResp& _return, const TPipeTransferReq& req);
  int32_t send_pipeTransfer(const TPipeTransferReq& req);
  void recv_pipeTransfer(TPipeTransferResp& _return, const int32_t seqid);
  void pipeSubscribe(TPipeSubscribeResp& _return, const TPipeSubscribeReq& req);
  int32_t send_pipeSubscribe(const TPipeSubscribeReq& req);
  void recv_pipeSubscribe(TPipeSubscribeResp& _return, const int32_t seqid);
  void getBackupConfiguration(TSBackupConfigurationResp& _return);
  int32_t send_getBackupConfiguration();
  void recv_getBackupConfiguration(TSBackupConfigurationResp& _return, const int32_t seqid);
  void fetchAllConnectionsInfo(TSConnectionInfoResp& _return);
  int32_t send_fetchAllConnectionsInfo();
  void recv_fetchAllConnectionsInfo(TSConnectionInfoResp& _return, const int32_t seqid);
  /**
   * For other node's call
   */
  void testConnectionEmptyRPC( ::TSStatus& _return);
  int32_t send_testConnectionEmptyRPC();
  void recv_testConnectionEmptyRPC( ::TSStatus& _return, const int32_t seqid);
 protected:
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
  ::apache::thrift::protocol::TProtocol* iprot_;
  ::apache::thrift::protocol::TProtocol* oprot_;
  std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync_;
};

#ifdef _MSC_VER
  #pragma warning( pop )
#endif



#endif
